* Convert an hb_state_t to a jansson dict
* @param state - Pointer to hb_state_t to convert
*/
-static json_t* hb_state_to_dict( hb_state_t * state)
+hb_dict_t* hb_state_to_dict( hb_state_t * state)
{
- json_t *dict = NULL;
+ hb_dict_t *dict = NULL;
json_error_t error;
switch (state->state)
{
case HB_STATE_IDLE:
dict = json_pack_ex(&error, 0, "{s:o}",
- "State", json_integer(state->state));
+ "State", hb_value_int(state->state));
break;
case HB_STATE_SCANNING:
case HB_STATE_SCANDONE:
dict = json_pack_ex(&error, 0,
"{s:o, s{s:o, s:o, s:o, s:o, s:o}}",
- "State", json_integer(state->state),
+ "State", hb_value_int(state->state),
"Scanning",
- "Progress", json_real(state->param.scanning.progress),
- "Preview", json_integer(state->param.scanning.preview_cur),
- "PreviewCount", json_integer(state->param.scanning.preview_count),
- "Title", json_integer(state->param.scanning.title_cur),
- "TitleCount", json_integer(state->param.scanning.title_count));
+ "Progress", hb_value_double(state->param.scanning.progress),
+ "Preview", hb_value_int(state->param.scanning.preview_cur),
+ "PreviewCount", hb_value_int(state->param.scanning.preview_count),
+ "Title", hb_value_int(state->param.scanning.title_cur),
+ "TitleCount", hb_value_int(state->param.scanning.title_count));
break;
case HB_STATE_WORKING:
case HB_STATE_PAUSED:
case HB_STATE_SEARCHING:
dict = json_pack_ex(&error, 0,
"{s:o, s{s:o, s:o, s:o, s:o, s:o, s:o, s:o, s:o, s:o, s:o}}",
- "State", json_integer(state->state),
+ "State", hb_value_int(state->state),
"Working",
- "Progress", json_real(state->param.working.progress),
- "PassID", json_integer(state->param.working.pass_id),
- "Pass", json_integer(state->param.working.pass),
- "PassCount", json_integer(state->param.working.pass_count),
- "Rate", json_real(state->param.working.rate_cur),
- "RateAvg", json_real(state->param.working.rate_avg),
- "Hours", json_integer(state->param.working.hours),
- "Minutes", json_integer(state->param.working.minutes),
- "Seconds", json_integer(state->param.working.seconds),
- "SequenceID", json_integer(state->param.working.sequence_id));
+ "Progress", hb_value_double(state->param.working.progress),
+ "PassID", hb_value_int(state->param.working.pass_id),
+ "Pass", hb_value_int(state->param.working.pass),
+ "PassCount", hb_value_int(state->param.working.pass_count),
+ "Rate", hb_value_double(state->param.working.rate_cur),
+ "RateAvg", hb_value_double(state->param.working.rate_avg),
+ "Hours", hb_value_int(state->param.working.hours),
+ "Minutes", hb_value_int(state->param.working.minutes),
+ "Seconds", hb_value_int(state->param.working.seconds),
+ "SequenceID", hb_value_int(state->param.working.sequence_id));
break;
case HB_STATE_WORKDONE:
dict = json_pack_ex(&error, 0,
"{s:o, s{s:o}}",
- "State", json_integer(state->state),
+ "State", hb_value_int(state->state),
"WorkDone",
- "Error", json_integer(state->param.workdone.error));
+ "Error", hb_value_int(state->param.workdone.error));
break;
case HB_STATE_MUXING:
dict = json_pack_ex(&error, 0,
"{s:o, s{s:o}}",
- "State", json_integer(state->state),
+ "State", hb_value_int(state->state),
"Muxing",
- "Progress", json_real(state->param.muxing.progress));
+ "Progress", hb_value_double(state->param.muxing.progress));
break;
default:
hb_error("hb_state_to_json: unrecognized state %d", state->state);
hb_state_t state;
hb_get_state(h, &state);
- json_t *dict = hb_state_to_dict(&state);
+ hb_dict_t *dict = hb_state_to_dict(&state);
- char *json_state = json_dumps(dict, JSON_INDENT(4)|JSON_PRESERVE_ORDER);
- json_decref(dict);
+ char *json_state = hb_value_get_json(dict);
+ hb_value_free(&dict);
return json_state;
}
-/**
- * Convert an hb_title_t to a jansson dict
- * @param title - Pointer to the hb_title_t to convert
- */
-static json_t* hb_title_to_dict( const hb_title_t * title )
+static hb_dict_t* hb_title_to_dict_internal( hb_title_t *title )
{
- json_t *dict;
+ hb_dict_t *dict;
json_error_t error;
int ii;
+ if (title == NULL)
+ return NULL;
+
dict = json_pack_ex(&error, 0,
"{"
// Type, Path, Name, Index, Playlist, AngleCount
// MetaData
"s:{}"
"}",
- "Type", json_integer(title->type),
- "Path", json_string(title->path),
- "Name", json_string(title->name),
- "Index", json_integer(title->index),
- "Playlist", json_integer(title->playlist),
- "AngleCount", json_integer(title->angle_count),
+ "Type", hb_value_int(title->type),
+ "Path", hb_value_string(title->path),
+ "Name", hb_value_string(title->name),
+ "Index", hb_value_int(title->index),
+ "Playlist", hb_value_int(title->playlist),
+ "AngleCount", hb_value_int(title->angle_count),
"Duration",
- "Ticks", json_integer(title->duration),
- "Hours", json_integer(title->hours),
- "Minutes", json_integer(title->minutes),
- "Seconds", json_integer(title->seconds),
+ "Ticks", hb_value_int(title->duration),
+ "Hours", hb_value_int(title->hours),
+ "Minutes", hb_value_int(title->minutes),
+ "Seconds", hb_value_int(title->seconds),
"Geometry",
- "Width", json_integer(title->geometry.width),
- "Height", json_integer(title->geometry.height),
+ "Width", hb_value_int(title->geometry.width),
+ "Height", hb_value_int(title->geometry.height),
"PAR",
- "Num", json_integer(title->geometry.par.num),
- "Den", json_integer(title->geometry.par.den),
- "Crop", json_integer(title->crop[0]),
- json_integer(title->crop[1]),
- json_integer(title->crop[2]),
- json_integer(title->crop[3]),
+ "Num", hb_value_int(title->geometry.par.num),
+ "Den", hb_value_int(title->geometry.par.den),
+ "Crop", hb_value_int(title->crop[0]),
+ hb_value_int(title->crop[1]),
+ hb_value_int(title->crop[2]),
+ hb_value_int(title->crop[3]),
"Color",
- "Primary", json_integer(title->color_prim),
- "Transfer", json_integer(title->color_transfer),
- "Matrix", json_integer(title->color_matrix),
+ "Primary", hb_value_int(title->color_prim),
+ "Transfer", hb_value_int(title->color_transfer),
+ "Matrix", hb_value_int(title->color_matrix),
"FrameRate",
- "Num", json_integer(title->vrate.num),
- "Den", json_integer(title->vrate.den),
- "InterlaceDetected", json_boolean(title->detected_interlacing),
- "VideoCodec", json_string(title->video_codec_name),
+ "Num", hb_value_int(title->vrate.num),
+ "Den", hb_value_int(title->vrate.den),
+ "InterlaceDetected", hb_value_bool(title->detected_interlacing),
+ "VideoCodec", hb_value_string(title->video_codec_name),
"MetaData"
);
if (dict == NULL)
if (title->container_name != NULL)
{
- json_object_set_new(dict, "Container",
- json_string(title->container_name));
+ hb_dict_set(dict, "Container", hb_value_string(title->container_name));
}
// Add metadata
- json_t *meta_dict = json_object_get(dict, "MetaData");
+ hb_dict_t *meta_dict = hb_dict_get(dict, "MetaData");
if (title->metadata->name != NULL)
{
- json_object_set_new(meta_dict, "Name",
- json_string(title->metadata->name));
+ hb_dict_set(meta_dict, "Name", hb_value_string(title->metadata->name));
}
if (title->metadata->artist != NULL)
{
- json_object_set_new(meta_dict, "Artist",
- json_string(title->metadata->artist));
+ hb_dict_set(meta_dict, "Artist",
+ hb_value_string(title->metadata->artist));
}
if (title->metadata->composer != NULL)
{
- json_object_set_new(meta_dict, "Composer",
- json_string(title->metadata->composer));
+ hb_dict_set(meta_dict, "Composer",
+ hb_value_string(title->metadata->composer));
}
if (title->metadata->comment != NULL)
{
- json_object_set_new(meta_dict, "Comment",
- json_string(title->metadata->comment));
+ hb_dict_set(meta_dict, "Comment",
+ hb_value_string(title->metadata->comment));
}
if (title->metadata->genre != NULL)
{
- json_object_set_new(meta_dict, "Genre",
- json_string(title->metadata->genre));
+ hb_dict_set(meta_dict, "Genre",
+ hb_value_string(title->metadata->genre));
}
if (title->metadata->album != NULL)
{
- json_object_set_new(meta_dict, "Album",
- json_string(title->metadata->album));
+ hb_dict_set(meta_dict, "Album",
+ hb_value_string(title->metadata->album));
}
if (title->metadata->album_artist != NULL)
{
- json_object_set_new(meta_dict, "AlbumArtist",
- json_string(title->metadata->album_artist));
+ hb_dict_set(meta_dict, "AlbumArtist",
+ hb_value_string(title->metadata->album_artist));
}
if (title->metadata->description != NULL)
{
- json_object_set_new(meta_dict, "Description",
- json_string(title->metadata->description));
+ hb_dict_set(meta_dict, "Description",
+ hb_value_string(title->metadata->description));
}
if (title->metadata->long_description != NULL)
{
- json_object_set_new(meta_dict, "LongDescription",
- json_string(title->metadata->long_description));
+ hb_dict_set(meta_dict, "LongDescription",
+ hb_value_string(title->metadata->long_description));
}
if (title->metadata->release_date != NULL)
{
- json_object_set_new(meta_dict, "ReleaseDate",
- json_string(title->metadata->release_date));
+ hb_dict_set(meta_dict, "ReleaseDate",
+ hb_value_string(title->metadata->release_date));
}
// process chapter list
- json_t * chapter_list = json_array();
+ hb_dict_t * chapter_list = hb_value_array_init();
for (ii = 0; ii < hb_list_count(title->list_chapter); ii++)
{
- json_t *chapter_dict;
+ hb_dict_t *chapter_dict;
char *name = "";
hb_chapter_t *chapter = hb_list_item(title->list_chapter, ii);
if (chapter->title != NULL)
chapter_dict = json_pack_ex(&error, 0,
"{s:o, s:{s:o, s:o, s:o, s:o}}",
- "Name", json_string(name),
+ "Name", hb_value_string(name),
"Duration",
- "Ticks", json_integer(chapter->duration),
- "Hours", json_integer(chapter->hours),
- "Minutes", json_integer(chapter->minutes),
- "Seconds", json_integer(chapter->seconds)
+ "Ticks", hb_value_int(chapter->duration),
+ "Hours", hb_value_int(chapter->hours),
+ "Minutes", hb_value_int(chapter->minutes),
+ "Seconds", hb_value_int(chapter->seconds)
);
if (chapter_dict == NULL)
{
hb_error("json pack failure: %s", error.text);
return NULL;
}
- json_array_append_new(chapter_list, chapter_dict);
+ hb_value_array_append(chapter_list, chapter_dict);
}
- json_object_set_new(dict, "ChapterList", chapter_list);
+ hb_dict_set(dict, "ChapterList", chapter_list);
// process audio list
- json_t * audio_list = json_array();
+ hb_dict_t * audio_list = hb_value_array_init();
for (ii = 0; ii < hb_list_count(title->list_audio); ii++)
{
- json_t *audio_dict;
+ hb_dict_t *audio_dict;
hb_audio_t *audio = hb_list_item(title->list_audio, ii);
audio_dict = json_pack_ex(&error, 0,
"{s:o, s:o, s:o, s:o, s:o, s:o}",
- "Description", json_string(audio->config.lang.description),
- "Language", json_string(audio->config.lang.simple),
- "LanguageCode", json_string(audio->config.lang.iso639_2),
- "Codec", json_integer(audio->config.in.codec),
- "SampleRate", json_integer(audio->config.in.samplerate),
- "BitRate", json_integer(audio->config.in.bitrate),
- "ChannelLayout", json_integer(audio->config.in.channel_layout));
+ "Description", hb_value_string(audio->config.lang.description),
+ "Language", hb_value_string(audio->config.lang.simple),
+ "LanguageCode", hb_value_string(audio->config.lang.iso639_2),
+ "Codec", hb_value_int(audio->config.in.codec),
+ "SampleRate", hb_value_int(audio->config.in.samplerate),
+ "BitRate", hb_value_int(audio->config.in.bitrate),
+ "ChannelLayout", hb_value_int(audio->config.in.channel_layout));
if (audio_dict == NULL)
{
hb_error("json pack failure: %s", error.text);
return NULL;
}
- json_array_append_new(audio_list, audio_dict);
+ hb_value_array_append(audio_list, audio_dict);
}
- json_object_set_new(dict, "AudioList", audio_list);
+ hb_dict_set(dict, "AudioList", audio_list);
// process subtitle list
- json_t * subtitle_list = json_array();
+ hb_dict_t * subtitle_list = hb_value_array_init();
for (ii = 0; ii < hb_list_count(title->list_subtitle); ii++)
{
- json_t *subtitle_dict;
+ hb_dict_t *subtitle_dict;
hb_subtitle_t *subtitle = hb_list_item(title->list_subtitle, ii);
subtitle_dict = json_pack_ex(&error, 0,
"{s:o, s:o, s:o, s:o}",
- "Format", json_integer(subtitle->format),
- "Source", json_integer(subtitle->source),
- "Language", json_string(subtitle->lang),
- "LanguageCode", json_string(subtitle->iso639_2));
+ "Format", hb_value_int(subtitle->format),
+ "Source", hb_value_int(subtitle->source),
+ "Language", hb_value_string(subtitle->lang),
+ "LanguageCode", hb_value_string(subtitle->iso639_2));
if (subtitle_dict == NULL)
{
hb_error("json pack failure: %s", error.text);
return NULL;
}
- json_array_append_new(subtitle_list, subtitle_dict);
+ hb_value_array_append(subtitle_list, subtitle_dict);
}
- json_object_set_new(dict, "SubtitleList", subtitle_list);
+ hb_dict_set(dict, "SubtitleList", subtitle_list);
return dict;
}
+/**
+ * Convert an hb_title_t to a jansson dict
+ * @param title - Pointer to the hb_title_t to convert
+ */
+hb_dict_t* hb_title_to_dict( hb_handle_t *h, int title_index )
+{
+ hb_title_t *title = hb_find_title_by_index(h, title_index);
+ return hb_title_to_dict_internal(title);
+}
+
/**
* Convert an hb_title_set_t to a jansson dict
* @param title - Pointer to the hb_title_set_t to convert
*/
-static json_t* hb_title_set_to_dict( const hb_title_set_t * title_set )
+hb_dict_t* hb_title_set_to_dict( const hb_title_set_t * title_set )
{
- json_t *dict;
+ hb_dict_t *dict;
json_error_t error;
int ii;
dict = json_pack_ex(&error, 0,
"{s:o, s:[]}",
- "MainFeature", json_integer(title_set->feature),
+ "MainFeature", hb_value_int(title_set->feature),
"TitleList");
// process title list
- json_t *title_list = json_object_get(dict, "TitleList");
+ hb_dict_t *title_list = hb_dict_get(dict, "TitleList");
for (ii = 0; ii < hb_list_count(title_set->list_title); ii++)
{
hb_title_t *title = hb_list_item(title_set->list_title, ii);
- json_t *title_dict = hb_title_to_dict(title);
- json_array_append_new(title_list, title_dict);
+ hb_dict_t *title_dict = hb_title_to_dict_internal(title);
+ hb_value_array_append(title_list, title_dict);
}
return dict;
* Convert an hb_title_t to a json string
* @param title - Pointer to hb_title_t to convert
*/
-char* hb_title_to_json( const hb_title_t * title )
+char* hb_title_to_json( hb_handle_t *h, int title_index )
{
- json_t *dict = hb_title_to_dict(title);
+ hb_dict_t *dict = hb_title_to_dict(h, title_index);
+ if (dict == NULL)
+ return NULL;
- char *json_title = json_dumps(dict, JSON_INDENT(4)|JSON_PRESERVE_ORDER);
- json_decref(dict);
+ char *json_title = hb_value_get_json(dict);
+ hb_value_free(&dict);
return json_title;
}
*/
char* hb_get_title_set_json( hb_handle_t * h )
{
- json_t *dict = hb_title_set_to_dict(hb_get_title_set(h));
+ hb_dict_t *dict = hb_title_set_to_dict(hb_get_title_set(h));
- char *json_title_set = json_dumps(dict, JSON_INDENT(4)|JSON_PRESERVE_ORDER);
- json_decref(dict);
+ char *json_title_set = hb_value_get_json(dict);
+ hb_value_free(&dict);
return json_title_set;
}
/**
- * Convert an hb_job_t to a json string
+ * Convert an hb_job_t to an hb_dict_t
* @param job - Pointer to the hb_job_t to convert
*/
-char* hb_job_to_json( const hb_job_t * job )
+hb_dict_t* hb_job_to_dict( const hb_job_t * job )
{
- json_t * dict;
+ hb_dict_t * dict;
json_error_t error;
int subtitle_search_burn;
int ii;
// Filters {Grayscale, FilterList []}
"s:{s:o, s:[]}"
"}",
- "SequenceID", json_integer(job->sequence_id),
+ "SequenceID", hb_value_int(job->sequence_id),
"Destination",
- "Mux", json_integer(job->mux),
- "ChapterMarkers", json_boolean(job->chapter_markers),
+ "Mux", hb_value_int(job->mux),
+ "ChapterMarkers", hb_value_bool(job->chapter_markers),
"ChapterList",
"Source",
- "Title", json_integer(job->title->index),
- "Angle", json_integer(job->angle),
+ "Title", hb_value_int(job->title->index),
+ "Angle", hb_value_int(job->angle),
"PAR",
- "Num", json_integer(job->par.num),
- "Den", json_integer(job->par.den),
+ "Num", hb_value_int(job->par.num),
+ "Den", hb_value_int(job->par.den),
"Video",
- "Codec", json_integer(job->vcodec),
+ "Codec", hb_value_int(job->vcodec),
"Audio",
- "CopyMask", json_integer(job->acodec_copy_mask),
- "FallbackEncoder", json_integer(job->acodec_fallback),
+ "CopyMask", hb_value_int(job->acodec_copy_mask),
+ "FallbackEncoder", hb_value_int(job->acodec_fallback),
"AudioList",
"Subtitle",
"Search",
- "Enable", json_boolean(job->indepth_scan),
- "Forced", json_boolean(job->select_subtitle_config.force),
- "Default", json_boolean(job->select_subtitle_config.default_track),
- "Burn", json_boolean(subtitle_search_burn),
+ "Enable", hb_value_bool(job->indepth_scan),
+ "Forced", hb_value_bool(job->select_subtitle_config.force),
+ "Default", hb_value_bool(job->select_subtitle_config.default_track),
+ "Burn", hb_value_bool(subtitle_search_burn),
"SubtitleList",
"MetaData",
"Filter",
- "Grayscale", json_boolean(job->grayscale),
+ "Grayscale", hb_value_bool(job->grayscale),
"FilterList"
);
if (dict == NULL)
hb_error("json pack failure: %s", error.text);
return NULL;
}
- json_t *dest_dict = json_object_get(dict, "Destination");
+ hb_dict_t *dest_dict = hb_dict_get(dict, "Destination");
if (job->file != NULL)
{
- json_object_set_new(dest_dict, "File", json_string(job->file));
+ hb_dict_set(dest_dict, "File", hb_value_string(job->file));
}
if (job->mux & HB_MUX_MASK_MP4)
{
- json_t *mp4_dict;
+ hb_dict_t *mp4_dict;
mp4_dict = json_pack_ex(&error, 0, "{s:o, s:o}",
- "Mp4Optimize", json_boolean(job->mp4_optimize),
- "IpodAtom", json_boolean(job->ipod_atom));
- json_object_set_new(dest_dict, "Mp4Options", mp4_dict);
+ "Mp4Optimize", hb_value_bool(job->mp4_optimize),
+ "IpodAtom", hb_value_bool(job->ipod_atom));
+ hb_dict_set(dest_dict, "Mp4Options", mp4_dict);
}
- json_t *source_dict = json_object_get(dict, "Source");
- json_t *range_dict;
+ hb_dict_t *source_dict = hb_dict_get(dict, "Source");
+ hb_dict_t *range_dict;
if (job->start_at_preview > 0)
{
range_dict = json_pack_ex(&error, 0, "{s:o, s:o, s:o}",
- "StartAtPreview", json_integer(job->start_at_preview),
- "PtsToStop", json_integer(job->pts_to_stop),
- "SeekPoints", json_integer(job->seek_points));
+ "StartAtPreview", hb_value_int(job->start_at_preview),
+ "PtsToStop", hb_value_int(job->pts_to_stop),
+ "SeekPoints", hb_value_int(job->seek_points));
}
else if (job->pts_to_start != 0)
{
range_dict = json_pack_ex(&error, 0, "{s:o, s:o}",
- "PtsToStart", json_integer(job->pts_to_start),
- "PtsToStop", json_integer(job->pts_to_stop));
+ "PtsToStart", hb_value_int(job->pts_to_start),
+ "PtsToStop", hb_value_int(job->pts_to_stop));
}
else if (job->frame_to_start != 0)
{
range_dict = json_pack_ex(&error, 0, "{s:o, s:o}",
- "FrameToStart", json_integer(job->frame_to_start),
- "FrameToStop", json_integer(job->frame_to_stop));
+ "FrameToStart", hb_value_int(job->frame_to_start),
+ "FrameToStop", hb_value_int(job->frame_to_stop));
}
else
{
range_dict = json_pack_ex(&error, 0, "{s:o, s:o}",
- "ChapterStart", json_integer(job->chapter_start),
- "ChapterEnd", json_integer(job->chapter_end));
+ "ChapterStart", hb_value_int(job->chapter_start),
+ "ChapterEnd", hb_value_int(job->chapter_end));
}
- json_object_set_new(source_dict, "Range", range_dict);
+ hb_dict_set(source_dict, "Range", range_dict);
- json_t *video_dict = json_object_get(dict, "Video");
+ hb_dict_t *video_dict = hb_dict_get(dict, "Video");
if (job->color_matrix_code > 0)
{
- json_object_set_new(video_dict, "ColorMatrixCode",
- json_integer(job->color_matrix_code));
+ hb_dict_set(video_dict, "ColorMatrixCode",
+ hb_value_int(job->color_matrix_code));
}
if (job->vquality >= 0)
{
- json_object_set_new(video_dict, "Quality", json_real(job->vquality));
+ hb_dict_set(video_dict, "Quality", hb_value_double(job->vquality));
}
else
{
- json_object_set_new(video_dict, "Bitrate", json_integer(job->vbitrate));
- json_object_set_new(video_dict, "TwoPass", json_boolean(job->twopass));
- json_object_set_new(video_dict, "Turbo",
- json_boolean(job->fastfirstpass));
+ hb_dict_set(video_dict, "Bitrate", hb_value_int(job->vbitrate));
+ hb_dict_set(video_dict, "TwoPass", hb_value_bool(job->twopass));
+ hb_dict_set(video_dict, "Turbo",
+ hb_value_bool(job->fastfirstpass));
}
if (job->encoder_preset != NULL)
{
- json_object_set_new(video_dict, "Preset",
- json_string(job->encoder_preset));
+ hb_dict_set(video_dict, "Preset",
+ hb_value_string(job->encoder_preset));
}
if (job->encoder_tune != NULL)
{
- json_object_set_new(video_dict, "Tune",
- json_string(job->encoder_tune));
+ hb_dict_set(video_dict, "Tune", hb_value_string(job->encoder_tune));
}
if (job->encoder_profile != NULL)
{
- json_object_set_new(video_dict, "Profile",
- json_string(job->encoder_profile));
+ hb_dict_set(video_dict, "Profile",
+ hb_value_string(job->encoder_profile));
}
if (job->encoder_level != NULL)
{
- json_object_set_new(video_dict, "Level",
- json_string(job->encoder_level));
+ hb_dict_set(video_dict, "Level", hb_value_string(job->encoder_level));
}
if (job->encoder_options != NULL)
{
- json_object_set_new(video_dict, "Options",
- json_string(job->encoder_options));
+ hb_dict_set(video_dict, "Options",
+ hb_value_string(job->encoder_options));
}
- json_t *meta_dict = json_object_get(dict, "MetaData");
+ hb_dict_t *meta_dict = hb_dict_get(dict, "MetaData");
if (job->metadata->name != NULL)
{
- json_object_set_new(meta_dict, "Name",
- json_string(job->metadata->name));
+ hb_dict_set(meta_dict, "Name", hb_value_string(job->metadata->name));
}
if (job->metadata->artist != NULL)
{
- json_object_set_new(meta_dict, "Artist",
- json_string(job->metadata->artist));
+ hb_dict_set(meta_dict, "Artist",
+ hb_value_string(job->metadata->artist));
}
if (job->metadata->composer != NULL)
{
- json_object_set_new(meta_dict, "Composer",
- json_string(job->metadata->composer));
+ hb_dict_set(meta_dict, "Composer",
+ hb_value_string(job->metadata->composer));
}
if (job->metadata->comment != NULL)
{
- json_object_set_new(meta_dict, "Comment",
- json_string(job->metadata->comment));
+ hb_dict_set(meta_dict, "Comment",
+ hb_value_string(job->metadata->comment));
}
if (job->metadata->genre != NULL)
{
- json_object_set_new(meta_dict, "Genre",
- json_string(job->metadata->genre));
+ hb_dict_set(meta_dict, "Genre", hb_value_string(job->metadata->genre));
}
if (job->metadata->album != NULL)
{
- json_object_set_new(meta_dict, "Album",
- json_string(job->metadata->album));
+ hb_dict_set(meta_dict, "Album", hb_value_string(job->metadata->album));
}
if (job->metadata->album_artist != NULL)
{
- json_object_set_new(meta_dict, "AlbumArtist",
- json_string(job->metadata->album_artist));
+ hb_dict_set(meta_dict, "AlbumArtist",
+ hb_value_string(job->metadata->album_artist));
}
if (job->metadata->description != NULL)
{
- json_object_set_new(meta_dict, "Description",
- json_string(job->metadata->description));
+ hb_dict_set(meta_dict, "Description",
+ hb_value_string(job->metadata->description));
}
if (job->metadata->long_description != NULL)
{
- json_object_set_new(meta_dict, "LongDescription",
- json_string(job->metadata->long_description));
+ hb_dict_set(meta_dict, "LongDescription",
+ hb_value_string(job->metadata->long_description));
}
if (job->metadata->release_date != NULL)
{
- json_object_set_new(meta_dict, "ReleaseDate",
- json_string(job->metadata->release_date));
+ hb_dict_set(meta_dict, "ReleaseDate",
+ hb_value_string(job->metadata->release_date));
}
// process chapter list
- json_t *chapter_list = json_object_get(dest_dict, "ChapterList");
+ hb_dict_t *chapter_list = hb_dict_get(dest_dict, "ChapterList");
for (ii = 0; ii < hb_list_count(job->list_chapter); ii++)
{
- json_t *chapter_dict;
+ hb_dict_t *chapter_dict;
char *title = "";
hb_chapter_t *chapter = hb_list_item(job->list_chapter, ii);
if (chapter->title != NULL)
title = chapter->title;
chapter_dict = json_pack_ex(&error, 0, "{s:o}",
- "Name", json_string(title));
- json_array_append_new(chapter_list, chapter_dict);
+ "Name", hb_value_string(title));
+ hb_value_array_append(chapter_list, chapter_dict);
}
// process filter list
- json_t *filters_dict = json_object_get(dict, "Filter");
- json_t *filter_list = json_object_get(filters_dict, "FilterList");
+ hb_dict_t *filters_dict = hb_dict_get(dict, "Filter");
+ hb_dict_t *filter_list = hb_dict_get(filters_dict, "FilterList");
for (ii = 0; ii < hb_list_count(job->list_filter); ii++)
{
- json_t *filter_dict;
+ hb_dict_t *filter_dict;
hb_filter_object_t *filter = hb_list_item(job->list_filter, ii);
filter_dict = json_pack_ex(&error, 0, "{s:o}",
- "ID", json_integer(filter->id));
+ "ID", hb_value_int(filter->id));
if (filter->settings != NULL)
{
- json_object_set_new(filter_dict, "Settings",
- json_string(filter->settings));
+ hb_dict_set(filter_dict, "Settings",
+ hb_value_string(filter->settings));
}
- json_array_append_new(filter_list, filter_dict);
+ hb_value_array_append(filter_list, filter_dict);
}
// process audio list
- json_t *audios_dict = json_object_get(dict, "Audio");
- json_t *audio_list = json_object_get(audios_dict, "AudioList");
+ hb_dict_t *audios_dict = hb_dict_get(dict, "Audio");
+ hb_dict_t *audio_list = hb_dict_get(audios_dict, "AudioList");
for (ii = 0; ii < hb_list_count(job->list_audio); ii++)
{
- json_t *audio_dict;
+ hb_dict_t *audio_dict;
hb_audio_t *audio = hb_list_item(job->list_audio, ii);
audio_dict = json_pack_ex(&error, 0,
"{s:o, s:o, s:o, s:o, s:o, s:o, s:o, s:o, s:o, s:o}",
- "Track", json_integer(audio->config.in.track),
- "Encoder", json_integer(audio->config.out.codec),
- "Gain", json_real(audio->config.out.gain),
- "DRC", json_real(audio->config.out.dynamic_range_compression),
- "Mixdown", json_integer(audio->config.out.mixdown),
- "NormalizeMixLevel", json_boolean(audio->config.out.normalize_mix_level),
- "Samplerate", json_integer(audio->config.out.samplerate),
- "Bitrate", json_integer(audio->config.out.bitrate),
- "Quality", json_real(audio->config.out.quality),
- "CompressionLevel", json_real(audio->config.out.compression_level));
+ "Track", hb_value_int(audio->config.in.track),
+ "Encoder", hb_value_int(audio->config.out.codec),
+ "Gain", hb_value_double(audio->config.out.gain),
+ "DRC", hb_value_double(audio->config.out.dynamic_range_compression),
+ "Mixdown", hb_value_int(audio->config.out.mixdown),
+ "NormalizeMixLevel", hb_value_bool(audio->config.out.normalize_mix_level),
+ "Samplerate", hb_value_int(audio->config.out.samplerate),
+ "Bitrate", hb_value_int(audio->config.out.bitrate),
+ "Quality", hb_value_double(audio->config.out.quality),
+ "CompressionLevel", hb_value_double(audio->config.out.compression_level));
if (audio->config.out.name != NULL)
{
- json_object_set_new(audio_dict, "Name",
- json_string(audio->config.out.name));
+ hb_dict_set(audio_dict, "Name",
+ hb_value_string(audio->config.out.name));
}
- json_array_append_new(audio_list, audio_dict);
+ hb_value_array_append(audio_list, audio_dict);
}
// process subtitle list
- json_t *subtitles_dict = json_object_get(dict, "Subtitle");
- json_t *subtitle_list = json_object_get(subtitles_dict, "SubtitleList");
+ hb_dict_t *subtitles_dict = hb_dict_get(dict, "Subtitle");
+ hb_dict_t *subtitle_list = hb_dict_get(subtitles_dict, "SubtitleList");
for (ii = 0; ii < hb_list_count(job->list_subtitle); ii++)
{
- json_t *subtitle_dict;
+ hb_dict_t *subtitle_dict;
hb_subtitle_t *subtitle = hb_list_item(job->list_subtitle, ii);
if (subtitle->source == SRTSUB)
{
subtitle_dict = json_pack_ex(&error, 0,
"{s:o, s:o, s:o, s:{s:o, s:o, s:o}}",
- "Default", json_boolean(subtitle->config.default_track),
- "Burn", json_boolean(subtitle->config.dest == RENDERSUB),
- "Offset", json_integer(subtitle->config.offset),
+ "Default", hb_value_bool(subtitle->config.default_track),
+ "Burn", hb_value_bool(subtitle->config.dest == RENDERSUB),
+ "Offset", hb_value_int(subtitle->config.offset),
"SRT",
- "Filename", json_string(subtitle->config.src_filename),
- "Language", json_string(subtitle->iso639_2),
- "Codeset", json_string(subtitle->config.src_codeset));
+ "Filename", hb_value_string(subtitle->config.src_filename),
+ "Language", hb_value_string(subtitle->iso639_2),
+ "Codeset", hb_value_string(subtitle->config.src_codeset));
}
else
{
subtitle_dict = json_pack_ex(&error, 0,
"{s:o, s:o, s:o, s:o, s:o}",
- "Track", json_integer(subtitle->track),
- "Default", json_boolean(subtitle->config.default_track),
- "Force", json_boolean(subtitle->config.force),
- "Burn", json_boolean(subtitle->config.dest == RENDERSUB),
- "Offset", json_integer(subtitle->config.offset));
+ "Track", hb_value_int(subtitle->track),
+ "Default", hb_value_bool(subtitle->config.default_track),
+ "Force", hb_value_bool(subtitle->config.force),
+ "Burn", hb_value_bool(subtitle->config.dest == RENDERSUB),
+ "Offset", hb_value_int(subtitle->config.offset));
}
- json_array_append_new(subtitle_list, subtitle_dict);
+ hb_value_array_append(subtitle_list, subtitle_dict);
}
- char *json_job = json_dumps(dict, JSON_INDENT(4));
- json_decref(dict);
+ return dict;
+}
+
+/**
+ * Convert an hb_job_t to a json string
+ * @param job - Pointer to the hb_job_t to convert
+ */
+char* hb_job_to_json( const hb_job_t * job )
+{
+ hb_dict_t *dict = hb_job_to_dict(job);
+
+ if (dict == NULL)
+ return NULL;
+
+ char *json_job = hb_value_get_json(dict);
+ hb_value_free(&dict);
return json_job;
}
void hb_json_job_scan( hb_handle_t * h, const char * json_job )
{
- json_t * dict;
+ hb_dict_t * dict;
int result;
json_error_t error;
- dict = json_loads(json_job, 0, NULL);
+ dict = hb_value_json(json_job);
int title_index;
char *path = NULL;
hb_get_state2(h, &state);
} while (state.state == HB_STATE_SCANNING);
- json_decref(dict);
+ hb_value_free(&dict);
}
/**
* title that the job refers to.
* @param json_job - Pointer to json string representation of a job
*/
-hb_job_t* hb_json_to_job( hb_handle_t * h, const char * json_job )
+hb_job_t* hb_dict_to_job( hb_handle_t * h, hb_dict_t *dict )
{
- json_t * dict;
hb_job_t * job;
int result;
json_error_t error;
int titleindex;
- dict = json_loads(json_job, 0, NULL);
+ if (dict == NULL)
+ return NULL;
result = json_unpack_ex(dict, &error, 0, "{s:{s:i}}",
"Source", "Title", unpack_i(&titleindex));
if (result < 0)
{
- hb_error("json unpack failure, failed to find title: %s", error.text);
+ hb_error("hb_dict_to_job: failed to find title: %s", error.text);
return NULL;
}
}
// process chapter list
- json_t * chapter_list = NULL;
+ hb_dict_t * chapter_list = NULL;
result = json_unpack_ex(dict, &error, 0,
"{s:{s:o}}",
"Destination",
hb_job_close(&job);
return NULL;
}
- if (json_is_array(chapter_list))
+ if (hb_value_type(chapter_list) == HB_VALUE_TYPE_ARRAY)
{
- int ii;
- json_t *chapter_dict;
- json_array_foreach(chapter_list, ii, chapter_dict)
+ int ii, count;
+ hb_dict_t *chapter_dict;
+ count = hb_value_array_len(chapter_list);
+ for (ii = 0; ii < count; ii++)
{
+ chapter_dict = hb_value_array_get(chapter_list, ii);
char *name = NULL;
result = json_unpack_ex(chapter_dict, &error, 0,
"{s:s}", "Name", unpack_s(&name));
}
// process filter list
- json_t * filter_list = NULL;
+ hb_dict_t * filter_list = NULL;
result = json_unpack_ex(dict, &error, 0,
"{s:{s:o}}",
"Filter", "FilterList", unpack_o(&filter_list));
hb_job_close(&job);
return NULL;
}
- if (json_is_array(filter_list))
+ if (hb_value_type(filter_list) == HB_VALUE_TYPE_ARRAY)
{
- int ii;
- json_t *filter_dict;
- json_array_foreach(filter_list, ii, filter_dict)
+ int ii, count;
+ hb_dict_t *filter_dict;
+ count = hb_value_array_len(filter_list);
+ for (ii = 0; ii < count; ii++)
{
+ filter_dict = hb_value_array_get(filter_list, ii);
int filter_id = -1;
char *filter_settings = NULL;
result = json_unpack_ex(filter_dict, &error, 0, "{s:i, s?s}",
}
// process audio list
- json_t * audio_list = NULL;
+ hb_dict_t * audio_list = NULL;
result = json_unpack_ex(dict, &error, 0, "{s:{s:o}}",
"Audio", "AudioList", unpack_o(&audio_list));
if (result < 0)
hb_job_close(&job);
return NULL;
}
- if (json_is_array(audio_list))
+ if (hb_value_type(audio_list) == HB_VALUE_TYPE_ARRAY)
{
- int ii;
- json_t *audio_dict;
- json_array_foreach(audio_list, ii, audio_dict)
+ int ii, count;
+ hb_dict_t *audio_dict;
+ count = hb_value_array_len(audio_list);
+ for (ii = 0; ii < count; ii++)
{
+ audio_dict = hb_value_array_get(audio_list, ii);
hb_audio_config_t audio;
hb_audio_config_init(&audio);
}
// process subtitle list
- json_t * subtitle_list = NULL;
+ hb_dict_t * subtitle_list = NULL;
result = json_unpack_ex(dict, &error, 0,
"{s:{s:o}}",
"Subtitle",
hb_job_close(&job);
return NULL;
}
- if (json_is_array(subtitle_list))
+ if (hb_value_type(subtitle_list) == HB_VALUE_TYPE_ARRAY)
{
- int ii;
- json_t *subtitle_dict;
- json_array_foreach(subtitle_list, ii, subtitle_dict)
+ int ii, count;
+ hb_dict_t *subtitle_dict;
+ count = hb_value_array_len(subtitle_list);
+ for (ii = 0; ii < count; ii++)
{
+ subtitle_dict = hb_value_array_get(subtitle_list, ii);
hb_subtitle_config_t sub_config;
int track = -1;
int burn = 0;
}
}
}
- json_decref(dict);
return job;
}
+hb_job_t* hb_json_to_job( hb_handle_t * h, const char * json_job )
+{
+ hb_dict_t *dict = hb_value_json(json_job);
+ hb_job_t *job = hb_dict_to_job(h, dict);
+ hb_value_free(&dict);
+ return job;
+}
+
/**
* Initialize an hb_job_t and return a json string representation of the job
* @param h - Pointer to hb_handle_t instance that contains the
{
int json_result;
json_error_t error;
- json_t * dict;
+ hb_dict_t * dict;
hb_geometry_t geo_result;
hb_geometry_t src;
hb_geometry_settings_t ui_geo;
// Clear dest geometry since some fields are optional.
memset(&ui_geo, 0, sizeof(ui_geo));
- dict = json_loads(json_param, 0, NULL);
+ dict = hb_value_json(json_param);
json_result = json_unpack_ex(dict, &error, 0,
"{"
// SourceGeometry
unpack_i(&ui_geo.crop[2]),
unpack_i(&ui_geo.crop[3])
);
- json_decref(dict);
+ hb_value_free(&dict);
if (json_result < 0)
{
dict = json_pack_ex(&error, 0,
"{s:o, s:o, s:{s:o, s:o}}",
- "Width", json_integer(geo_result.width),
- "Height", json_integer(geo_result.height),
+ "Width", hb_value_int(geo_result.width),
+ "Height", hb_value_int(geo_result.height),
"PAR",
- "Num", json_integer(geo_result.par.num),
- "Den", json_integer(geo_result.par.den));
+ "Num", hb_value_int(geo_result.par.num),
+ "Den", hb_value_int(geo_result.par.den));
if (dict == NULL)
{
hb_error("hb_set_anamorphic_size_json: pack failure: %s", error.text);
return NULL;
}
- char *result = json_dumps(dict, JSON_INDENT(4)|JSON_PRESERVE_ORDER);
- json_decref(dict);
+ char *result = hb_value_get_json(dict);
+ hb_value_free(&dict);
return result;
}
int json_result;
json_error_t error;
- json_t * dict;
+ hb_dict_t * dict;
hb_geometry_settings_t settings;
// Clear dest geometry since some fields are optional.
memset(&settings, 0, sizeof(settings));
- dict = json_loads(json_param, 0, NULL);
+ dict = hb_value_json(json_param);
json_result = json_unpack_ex(dict, &error, 0,
"{"
// Title, Preview, Deinterlace
unpack_i(&settings.crop[2]),
unpack_i(&settings.crop[3])
);
- json_decref(dict);
+ hb_value_free(&dict);
if (json_result < 0)
{
dict = json_pack_ex(&error, 0,
"{s:o, s:o, s:o}",
- "Format", json_integer(image->format),
- "Width", json_integer(image->width),
- "Height", json_integer(image->height));
+ "Format", hb_value_int(image->format),
+ "Width", hb_value_int(image->width),
+ "Height", hb_value_int(image->height));
if (dict == NULL)
{
hb_error("hb_get_preview_json: pack failure: %s", error.text);
return NULL;
}
- json_t * planes = json_array();
+ hb_value_array_t * planes = hb_value_array_init();
for (ii = 0; ii < 4; ii++)
{
int base64size = AV_BASE64_SIZE(image->plane[ii].size);
image->plane[ii].data, image->plane[ii].size);
base64size = strlen(plane_base64);
- json_t *plane_dict;
+ hb_dict_t *plane_dict;
plane_dict = json_pack_ex(&error, 0,
"{s:o, s:o, s:o, s:o, s:o, s:o}",
- "Width", json_integer(image->plane[ii].width),
- "Height", json_integer(image->plane[ii].height),
- "Stride", json_integer(image->plane[ii].stride),
- "HeightStride", json_integer(image->plane[ii].height_stride),
- "Size", json_integer(base64size),
- "Data", json_string(plane_base64)
+ "Width", hb_value_int(image->plane[ii].width),
+ "Height", hb_value_int(image->plane[ii].height),
+ "Stride", hb_value_int(image->plane[ii].stride),
+ "HeightStride", hb_value_int(image->plane[ii].height_stride),
+ "Size", hb_value_int(base64size),
+ "Data", hb_value_string(plane_base64)
);
if (plane_dict == NULL)
{
hb_error("plane_dict: json pack failure: %s", error.text);
return NULL;
}
- json_array_append_new(planes, plane_dict);
+ hb_value_array_append(planes, plane_dict);
}
- json_object_set_new(dict, "Planes", planes);
+ hb_dict_set(dict, "Planes", planes);
hb_image_close(&image);
- char *result = json_dumps(dict, JSON_INDENT(4)|JSON_PRESERVE_ORDER);
- json_decref(dict);
+ char *result = hb_value_get_json(dict);
+ hb_value_free(&dict);
return result;
}
int deinterlace, hb_geometry_settings_t *settings)
{
json_error_t error;
- json_t * dict;
+ hb_dict_t * dict;
dict = json_pack_ex(&error, 0,
"{"
" s:[oooo]"
" }"
"}",
- "Title", json_integer(title_idx),
- "Preview", json_integer(preview_idx),
- "Deinterlace", json_boolean(deinterlace),
+ "Title", hb_value_int(title_idx),
+ "Preview", hb_value_int(preview_idx),
+ "Deinterlace", hb_value_bool(deinterlace),
"DestSettings",
"Geometry",
- "Width", json_integer(settings->geometry.width),
- "Height", json_integer(settings->geometry.height),
+ "Width", hb_value_int(settings->geometry.width),
+ "Height", hb_value_int(settings->geometry.height),
"PAR",
- "Num", json_integer(settings->geometry.par.num),
- "Den", json_integer(settings->geometry.par.den),
- "AnamorphicMode", json_integer(settings->mode),
- "Keep", json_integer(settings->keep),
- "ItuPAR", json_boolean(settings->itu_par),
- "Modulus", json_integer(settings->modulus),
- "MaxWidth", json_integer(settings->maxWidth),
- "MaxHeight", json_integer(settings->maxHeight),
- "Crop", json_integer(settings->crop[0]),
- json_integer(settings->crop[1]),
- json_integer(settings->crop[2]),
- json_integer(settings->crop[3])
+ "Num", hb_value_int(settings->geometry.par.num),
+ "Den", hb_value_int(settings->geometry.par.den),
+ "AnamorphicMode", hb_value_int(settings->mode),
+ "Keep", hb_value_int(settings->keep),
+ "ItuPAR", hb_value_bool(settings->itu_par),
+ "Modulus", hb_value_int(settings->modulus),
+ "MaxWidth", hb_value_int(settings->maxWidth),
+ "MaxHeight", hb_value_int(settings->maxHeight),
+ "Crop", hb_value_int(settings->crop[0]),
+ hb_value_int(settings->crop[1]),
+ hb_value_int(settings->crop[2]),
+ hb_value_int(settings->crop[3])
);
if (dict == NULL)
{
return NULL;
}
- char *result = json_dumps(dict, JSON_INDENT(4)|JSON_PRESERVE_ORDER);
- json_decref(dict);
+ char *result = hb_value_get_json(dict);
+ hb_value_free(&dict);
return result;
}
{
int json_result;
json_error_t error;
- json_t * dict;
+ hb_dict_t * dict;
int pix_fmt, width, height;
- dict = json_loads(json_image, 0, NULL);
+ dict = hb_value_json(json_image);
json_result = json_unpack_ex(dict, &error, 0,
"{"
// Format, Width, Height
if (json_result < 0)
{
hb_error("image: json unpack failure: %s", error.text);
- json_decref(dict);
+ hb_value_free(&dict);
return NULL;
}
hb_image_t *image = hb_image_init(pix_fmt, width, height);
if (image == NULL)
{
- json_decref(dict);
+ hb_value_free(&dict);
return NULL;
}
- json_t * planes = NULL;
+ hb_value_array_t * planes = NULL;
json_result = json_unpack_ex(dict, &error, 0,
"{s:o}", "Planes", unpack_o(&planes));
if (json_result < 0)
{
hb_error("image::planes: json unpack failure: %s", error.text);
- json_decref(dict);
+ hb_value_free(&dict);
return image;
}
- if (json_is_array(planes))
+ if (hb_value_type(planes) == HB_VALUE_TYPE_ARRAY)
{
- int ii;
- json_t *plane_dict;
- json_array_foreach(planes, ii, plane_dict)
+ int ii, count;
+ hb_dict_t *plane_dict;
+ count = hb_value_array_len(planes);
+ for (ii = 0; ii < count; ii++)
{
+ plane_dict = hb_value_array_get(planes, ii);
char *data = NULL;
int size;
json_result = json_unpack_ex(plane_dict, &error, 0,
if (json_result < 0)
{
hb_error("image::plane::data: json unpack failure: %s", error.text);
- json_decref(dict);
+ hb_value_free(&dict);
return image;
}
if (image->plane[ii].size > 0 && data != NULL)
}
}
}
- json_decref(dict);
+ hb_value_free(&dict);
return image;
}
projects / handbrake / commitdiff