/* json.c Copyright (c) 2003-2015 HandBrake Team This file is part of the HandBrake source code Homepage: . It may be used under the terms of the GNU General Public License v2. For full terms see the file COPYING file or visit http://www.gnu.org/licenses/gpl-2.0.html */ #include #include "hb.h" #include "hb_json.h" #include "libavutil/base64.h" /** * Convert an hb_state_t to a jansson dict * @param state - Pointer to hb_state_t to convert */ hb_dict_t* hb_state_to_dict( hb_state_t * state) { 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", 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", hb_value_int(state->state), "Scanning", "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", hb_value_int(state->state), "Working", "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", hb_value_int(state->state), "WorkDone", "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", hb_value_int(state->state), "Muxing", "Progress", hb_value_double(state->param.muxing.progress)); break; default: hb_error("hb_state_to_json: unrecognized state %d", state->state); break; } if (dict == NULL) { hb_error("json pack failure: %s", error.text); } return dict; } /** * Get the current state of an hb instance as a json string * @param h - Pointer to an hb_handle_t hb instance */ char* hb_get_state_json( hb_handle_t * h ) { hb_state_t state; hb_get_state(h, &state); hb_dict_t *dict = hb_state_to_dict(&state); char *json_state = hb_value_get_json(dict); hb_value_free(&dict); return json_state; } static hb_dict_t* hb_title_to_dict_internal( hb_title_t *title ) { 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 "s:o, s:o, s:o, s:o, s:o, s:o," // Duration {Ticks, Hours, Minutes, Seconds} "s:{s:o, s:o, s:o, s:o}," // Geometry {Width, Height, PAR {Num, Den}, "s:{s:o, s:o, s:{s:o, s:o}}," // Crop[Top, Bottom, Left, Right]} "s:[oooo]," // Color {Primary, Transfer, Matrix} "s:{s:o, s:o, s:o}," // FrameRate {Num, Den} "s:{s:o, s:o}," // InterlaceDetected, VideoCodec "s:o, s:o," // MetaData "s:{}" "}", "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", 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", hb_value_int(title->geometry.width), "Height", hb_value_int(title->geometry.height), "PAR", "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", hb_value_int(title->color_prim), "Transfer", hb_value_int(title->color_transfer), "Matrix", hb_value_int(title->color_matrix), "FrameRate", "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) { hb_error("json pack failure: %s", error.text); return NULL; } if (title->container_name != NULL) { hb_dict_set(dict, "Container", hb_value_string(title->container_name)); } // Add metadata hb_dict_t *meta_dict = hb_dict_get(dict, "MetaData"); if (title->metadata->name != NULL) { hb_dict_set(meta_dict, "Name", hb_value_string(title->metadata->name)); } if (title->metadata->artist != NULL) { hb_dict_set(meta_dict, "Artist", hb_value_string(title->metadata->artist)); } if (title->metadata->composer != NULL) { hb_dict_set(meta_dict, "Composer", hb_value_string(title->metadata->composer)); } if (title->metadata->comment != NULL) { hb_dict_set(meta_dict, "Comment", hb_value_string(title->metadata->comment)); } if (title->metadata->genre != NULL) { hb_dict_set(meta_dict, "Genre", hb_value_string(title->metadata->genre)); } if (title->metadata->album != NULL) { hb_dict_set(meta_dict, "Album", hb_value_string(title->metadata->album)); } if (title->metadata->album_artist != NULL) { hb_dict_set(meta_dict, "AlbumArtist", hb_value_string(title->metadata->album_artist)); } if (title->metadata->description != NULL) { hb_dict_set(meta_dict, "Description", hb_value_string(title->metadata->description)); } if (title->metadata->long_description != NULL) { hb_dict_set(meta_dict, "LongDescription", hb_value_string(title->metadata->long_description)); } if (title->metadata->release_date != NULL) { hb_dict_set(meta_dict, "ReleaseDate", hb_value_string(title->metadata->release_date)); } // process chapter list hb_dict_t * chapter_list = hb_value_array_init(); for (ii = 0; ii < hb_list_count(title->list_chapter); ii++) { hb_dict_t *chapter_dict; char *name = ""; hb_chapter_t *chapter = hb_list_item(title->list_chapter, ii); if (chapter->title != NULL) name = chapter->title; chapter_dict = json_pack_ex(&error, 0, "{s:o, s:{s:o, s:o, s:o, s:o}}", "Name", hb_value_string(name), "Duration", "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; } hb_value_array_append(chapter_list, chapter_dict); } hb_dict_set(dict, "ChapterList", chapter_list); // process audio list hb_dict_t * audio_list = hb_value_array_init(); for (ii = 0; ii < hb_list_count(title->list_audio); ii++) { 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", 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; } hb_value_array_append(audio_list, audio_dict); } hb_dict_set(dict, "AudioList", audio_list); // process subtitle list hb_dict_t * subtitle_list = hb_value_array_init(); for (ii = 0; ii < hb_list_count(title->list_subtitle); ii++) { 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", 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; } hb_value_array_append(subtitle_list, subtitle_dict); } 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 */ hb_dict_t* hb_title_set_to_dict( const hb_title_set_t * title_set ) { hb_dict_t *dict; json_error_t error; int ii; dict = json_pack_ex(&error, 0, "{s:o, s:[]}", "MainFeature", hb_value_int(title_set->feature), "TitleList"); // process title list 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); 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( hb_handle_t *h, int title_index ) { hb_dict_t *dict = hb_title_to_dict(h, title_index); if (dict == NULL) return NULL; char *json_title = hb_value_get_json(dict); hb_value_free(&dict); return json_title; } /** * Get the current title set of an hb instance as a json string * @param h - Pointer to hb_handle_t hb instance */ char* hb_get_title_set_json( hb_handle_t * h ) { hb_dict_t *dict = hb_title_set_to_dict(hb_get_title_set(h)); char *json_title_set = hb_value_get_json(dict); hb_value_free(&dict); return json_title_set; } /** * Convert an hb_job_t to an hb_dict_t * @param job - Pointer to the hb_job_t to convert */ hb_dict_t* hb_job_to_dict( const hb_job_t * job ) { hb_dict_t * dict; json_error_t error; int subtitle_search_burn; int ii; if (job == NULL || job->title == NULL) return NULL; // Assumes that the UI has reduced geometry settings to only the // necessary PAR value subtitle_search_burn = job->select_subtitle_config.dest == RENDERSUB; dict = json_pack_ex(&error, 0, "{" // SequenceID "s:o," // Destination {Mux, ChapterMarkers, ChapterList} "s:{s:o, s:o, s[]}," // Source {Title, Angle} "s:{s:o, s:o,}," // PAR {Num, Den} "s:{s:o, s:o}," // Video {Codec} "s:{s:o}," // Audio {CopyMask, FallbackEncoder, AudioList []} "s:{s:o, s:o, s:[]}," // Subtitles {Search {Enable, Forced, Default, Burn}, SubtitleList []} "s:{s:{s:o, s:o, s:o, s:o}, s:[]}," // MetaData "s:{}," // Filters {Grayscale, FilterList []} "s:{s:o, s:[]}" "}", "SequenceID", hb_value_int(job->sequence_id), "Destination", "Mux", hb_value_int(job->mux), "ChapterMarkers", hb_value_bool(job->chapter_markers), "ChapterList", "Source", "Title", hb_value_int(job->title->index), "Angle", hb_value_int(job->angle), "PAR", "Num", hb_value_int(job->par.num), "Den", hb_value_int(job->par.den), "Video", "Codec", hb_value_int(job->vcodec), "Audio", "CopyMask", hb_value_int(job->acodec_copy_mask), "FallbackEncoder", hb_value_int(job->acodec_fallback), "AudioList", "Subtitle", "Search", "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", hb_value_bool(job->grayscale), "FilterList" ); if (dict == NULL) { hb_error("json pack failure: %s", error.text); return NULL; } hb_dict_t *dest_dict = hb_dict_get(dict, "Destination"); if (job->file != NULL) { hb_dict_set(dest_dict, "File", hb_value_string(job->file)); } if (job->mux & HB_MUX_MASK_MP4) { hb_dict_t *mp4_dict; mp4_dict = json_pack_ex(&error, 0, "{s:o, s:o}", "Mp4Optimize", hb_value_bool(job->mp4_optimize), "IpodAtom", hb_value_bool(job->ipod_atom)); hb_dict_set(dest_dict, "Mp4Options", mp4_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", 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", 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", 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", hb_value_int(job->chapter_start), "ChapterEnd", hb_value_int(job->chapter_end)); } hb_dict_set(source_dict, "Range", range_dict); hb_dict_t *video_dict = hb_dict_get(dict, "Video"); if (job->color_matrix_code > 0) { hb_dict_set(video_dict, "ColorMatrixCode", hb_value_int(job->color_matrix_code)); } if (job->vquality >= 0) { hb_dict_set(video_dict, "Quality", hb_value_double(job->vquality)); } else { 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) { hb_dict_set(video_dict, "Preset", hb_value_string(job->encoder_preset)); } if (job->encoder_tune != NULL) { hb_dict_set(video_dict, "Tune", hb_value_string(job->encoder_tune)); } if (job->encoder_profile != NULL) { hb_dict_set(video_dict, "Profile", hb_value_string(job->encoder_profile)); } if (job->encoder_level != NULL) { hb_dict_set(video_dict, "Level", hb_value_string(job->encoder_level)); } if (job->encoder_options != NULL) { hb_dict_set(video_dict, "Options", hb_value_string(job->encoder_options)); } hb_dict_t *meta_dict = hb_dict_get(dict, "MetaData"); if (job->metadata->name != NULL) { hb_dict_set(meta_dict, "Name", hb_value_string(job->metadata->name)); } if (job->metadata->artist != NULL) { hb_dict_set(meta_dict, "Artist", hb_value_string(job->metadata->artist)); } if (job->metadata->composer != NULL) { hb_dict_set(meta_dict, "Composer", hb_value_string(job->metadata->composer)); } if (job->metadata->comment != NULL) { hb_dict_set(meta_dict, "Comment", hb_value_string(job->metadata->comment)); } if (job->metadata->genre != NULL) { hb_dict_set(meta_dict, "Genre", hb_value_string(job->metadata->genre)); } if (job->metadata->album != NULL) { hb_dict_set(meta_dict, "Album", hb_value_string(job->metadata->album)); } if (job->metadata->album_artist != NULL) { hb_dict_set(meta_dict, "AlbumArtist", hb_value_string(job->metadata->album_artist)); } if (job->metadata->description != NULL) { hb_dict_set(meta_dict, "Description", hb_value_string(job->metadata->description)); } if (job->metadata->long_description != NULL) { hb_dict_set(meta_dict, "LongDescription", hb_value_string(job->metadata->long_description)); } if (job->metadata->release_date != NULL) { hb_dict_set(meta_dict, "ReleaseDate", hb_value_string(job->metadata->release_date)); } // process chapter list hb_dict_t *chapter_list = hb_dict_get(dest_dict, "ChapterList"); for (ii = 0; ii < hb_list_count(job->list_chapter); ii++) { 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", hb_value_string(title)); hb_value_array_append(chapter_list, chapter_dict); } // process filter list 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++) { 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", hb_value_int(filter->id)); if (filter->settings != NULL) { hb_dict_set(filter_dict, "Settings", hb_value_string(filter->settings)); } hb_value_array_append(filter_list, filter_dict); } // process audio list 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++) { 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", 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) { hb_dict_set(audio_dict, "Name", hb_value_string(audio->config.out.name)); } hb_value_array_append(audio_list, audio_dict); } // process subtitle list 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++) { 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", hb_value_bool(subtitle->config.default_track), "Burn", hb_value_bool(subtitle->config.dest == RENDERSUB), "Offset", hb_value_int(subtitle->config.offset), "SRT", "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", 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)); } hb_value_array_append(subtitle_list, subtitle_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; } // These functions exist only to perform type checking when using // json_unpack_ex(). static double* unpack_f(double *f) { return f; } static int* unpack_i(int *i) { return i; } static json_int_t* unpack_I(json_int_t *i) { return i; } static int * unpack_b(int *b) { return b; } static char** unpack_s(char **s) { return s; } static json_t** unpack_o(json_t** o) { return o; } void hb_json_job_scan( hb_handle_t * h, const char * json_job ) { hb_dict_t * dict; int result; json_error_t error; dict = hb_value_json(json_job); int title_index; char *path = NULL; result = json_unpack_ex(dict, &error, 0, "{s:{s:s, s:i}}", "Source", "Path", unpack_s(&path), "Title", unpack_i(&title_index)); if (result < 0) { hb_error("json unpack failure, failed to find title: %s", error.text); return; } hb_scan(h, path, title_index, 10, 0, 0); // Wait for scan to complete hb_state_t state; do { hb_snooze(50); hb_get_state2(h, &state); } while (state.state == HB_STATE_SCANNING); hb_value_free(&dict); } /** * Convert a json string representation of a job to an hb_job_t * @param h - Pointer to the hb_hanle_t hb instance which contains the * title that the job refers to. * @param json_job - Pointer to json string representation of a job */ hb_job_t* hb_dict_to_job( hb_handle_t * h, hb_dict_t *dict ) { hb_job_t * job; int result; json_error_t error; int titleindex; 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("hb_dict_to_job: failed to find title: %s", error.text); return NULL; } job = hb_job_init_by_index(h, titleindex); char *destfile = NULL; char *video_preset = NULL, *video_tune = NULL; char *video_profile = NULL, *video_level = NULL; char *video_options = NULL; int subtitle_search_burn = 0; char *meta_name = NULL, *meta_artist = NULL, *meta_album_artist = NULL; char *meta_release = NULL, *meta_comment = NULL, *meta_genre = NULL; char *meta_composer = NULL, *meta_desc = NULL, *meta_long_desc = NULL; json_int_t pts_to_start = 0, pts_to_stop = 0; result = json_unpack_ex(dict, &error, 0, "{" // SequenceID "s:i," // Destination {File, Mux, ChapterMarkers, Mp4Options { // Mp4Optimize, IpodAtom} "s:{s?s, s:i, s:b s?{s?b, s?b}}," // Source {Angle, Range {ChapterStart, ChapterEnd, PtsToStart, PtsToStop, // FrameToStart, FrameToStop, StartAtPreview, SeekPoints} "s:{s?i, s:{s?i, s?i, s?I, s?I, s?i, s?i, s?i, s?i}}," // PAR {Num, Den} "s?{s:i, s:i}," // Video {Codec, Quality, Bitrate, Preset, Tune, Profile, Level, // Options, TwoPass, Turbo, ColorMatrixCode} "s:{s:i, s?f, s?i, s?s, s?s, s?s, s?s, s?s, s?b, s?b, s?i}," // Audio {CopyMask, FallbackEncoder} "s?{s?i, s?i}," // Subtitle {Search {Enable, Forced, Default, Burn}} "s?{s?{s?b, s?b, s?b, s?b}}," // MetaData {Name, Artist, Composer, AlbumArtist, ReleaseDate, // Comment, Genre, Description, LongDescription} "s?{s?s, s?s, s?s, s?s, s?s, s?s, s?s, s?s, s?s}," // Filters {} "s?{s?b}" "}", "SequenceID", unpack_i(&job->sequence_id), "Destination", "File", unpack_s(&destfile), "Mux", unpack_i(&job->mux), "ChapterMarkers", unpack_b(&job->chapter_markers), "Mp4Options", "Mp4Optimize", unpack_b(&job->mp4_optimize), "IpodAtom", unpack_b(&job->ipod_atom), "Source", "Angle", unpack_i(&job->angle), "Range", "ChapterStart", unpack_i(&job->chapter_start), "ChapterEnd", unpack_i(&job->chapter_end), "PtsToStart", unpack_I(&pts_to_start), "PtsToStop", unpack_I(&pts_to_stop), "FrameToStart", unpack_i(&job->frame_to_start), "FrameToStop", unpack_i(&job->frame_to_stop), "StartAtPreview", unpack_i(&job->start_at_preview), "SeekPoints", unpack_i(&job->seek_points), "PAR", "Num", unpack_i(&job->par.num), "Den", unpack_i(&job->par.den), "Video", "Codec", unpack_i(&job->vcodec), "Quality", unpack_f(&job->vquality), "Bitrate", unpack_i(&job->vbitrate), "Preset", unpack_s(&video_preset), "Tune", unpack_s(&video_tune), "Profile", unpack_s(&video_profile), "Level", unpack_s(&video_level), "Options", unpack_s(&video_options), "TwoPass", unpack_b(&job->twopass), "Turbo", unpack_b(&job->fastfirstpass), "ColorMatrixCode", unpack_i(&job->color_matrix_code), "Audio", "CopyMask", unpack_i(&job->acodec_copy_mask), "FallbackEncoder", unpack_i(&job->acodec_fallback), "Subtitle", "Search", "Enable", unpack_b(&job->indepth_scan), "Forced", unpack_b(&job->select_subtitle_config.force), "Default", unpack_b(&job->select_subtitle_config.default_track), "Burn", unpack_b(&subtitle_search_burn), "MetaData", "Name", unpack_s(&meta_name), "Artist", unpack_s(&meta_artist), "Composer", unpack_s(&meta_composer), "AlbumArtist", unpack_s(&meta_album_artist), "ReleaseDate", unpack_s(&meta_release), "Comment", unpack_s(&meta_comment), "Genre", unpack_s(&meta_genre), "Description", unpack_s(&meta_desc), "LongDescription", unpack_s(&meta_long_desc), "Filter", "Grayscale", unpack_b(&job->grayscale) ); if (result < 0) { hb_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } job->pts_to_start = pts_to_start; job->pts_to_stop = pts_to_stop; if (destfile != NULL && destfile[0] != 0) { hb_job_set_file(job, destfile); } hb_job_set_encoder_preset(job, video_preset); hb_job_set_encoder_tune(job, video_tune); hb_job_set_encoder_profile(job, video_profile); hb_job_set_encoder_level(job, video_level); hb_job_set_encoder_options(job, video_options); job->select_subtitle_config.dest = subtitle_search_burn ? RENDERSUB : PASSTHRUSUB; if (meta_name != NULL && meta_name[0] != 0) { hb_metadata_set_name(job->metadata, meta_name); } if (meta_artist != NULL && meta_artist[0] != 0) { hb_metadata_set_artist(job->metadata, meta_artist); } if (meta_composer != NULL && meta_composer[0] != 0) { hb_metadata_set_composer(job->metadata, meta_composer); } if (meta_album_artist != NULL && meta_album_artist[0] != 0) { hb_metadata_set_album_artist(job->metadata, meta_album_artist); } if (meta_release != NULL && meta_release[0] != 0) { hb_metadata_set_release_date(job->metadata, meta_release); } if (meta_comment != NULL && meta_comment[0] != 0) { hb_metadata_set_comment(job->metadata, meta_comment); } if (meta_genre != NULL && meta_genre[0] != 0) { hb_metadata_set_genre(job->metadata, meta_genre); } if (meta_desc != NULL && meta_desc[0] != 0) { hb_metadata_set_description(job->metadata, meta_desc); } if (meta_long_desc != NULL && meta_long_desc[0] != 0) { hb_metadata_set_long_description(job->metadata, meta_long_desc); } // process chapter list hb_dict_t * chapter_list = NULL; result = json_unpack_ex(dict, &error, 0, "{s:{s:o}}", "Destination", "ChapterList", unpack_o(&chapter_list)); if (result < 0) { hb_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } if (hb_value_type(chapter_list) == HB_VALUE_TYPE_ARRAY) { 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)); if (result < 0) { hb_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } if (name != NULL && name[0] != 0) { hb_chapter_t *chapter; chapter = hb_list_item(job->list_chapter, ii); if (chapter != NULL) { hb_chapter_set_title(chapter, name); } } } } // process filter list hb_dict_t * filter_list = NULL; result = json_unpack_ex(dict, &error, 0, "{s:{s:o}}", "Filter", "FilterList", unpack_o(&filter_list)); if (result < 0) { hb_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } if (hb_value_type(filter_list) == HB_VALUE_TYPE_ARRAY) { 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}", "ID", unpack_i(&filter_id), "Settings", unpack_s(&filter_settings)); if (result < 0) { hb_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } if (filter_id >= HB_FILTER_FIRST && filter_id <= HB_FILTER_LAST) { hb_filter_object_t *filter; filter = hb_filter_init(filter_id); hb_add_filter(job, filter, filter_settings); } } } // process audio list 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_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } if (hb_value_type(audio_list) == HB_VALUE_TYPE_ARRAY) { 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); result = json_unpack_ex(audio_dict, &error, 0, "{s:i, s?s, s?i, s?F, s?F, s?i, s?b, s?i, s?i, s?F, s?F}", "Track", unpack_i(&audio.in.track), "Name", unpack_s(&audio.out.name), "Encoder", unpack_i((int*)&audio.out.codec), "Gain", unpack_f(&audio.out.gain), "DRC", unpack_f(&audio.out.dynamic_range_compression), "Mixdown", unpack_i(&audio.out.mixdown), "NormalizeMixLevel", unpack_b(&audio.out.normalize_mix_level), "Samplerate", unpack_i(&audio.out.samplerate), "Bitrate", unpack_i(&audio.out.bitrate), "Quality", unpack_f(&audio.out.quality), "CompressionLevel", unpack_f(&audio.out.compression_level)); if (result < 0) { hb_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } if (audio.in.track >= 0) { audio.out.track = ii; hb_audio_add(job, &audio); } } } // process subtitle list hb_dict_t * subtitle_list = NULL; result = json_unpack_ex(dict, &error, 0, "{s:{s:o}}", "Subtitle", "SubtitleList", unpack_o(&subtitle_list)); if (result < 0) { hb_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } if (hb_value_type(subtitle_list) == HB_VALUE_TYPE_ARRAY) { 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; char *srtfile = NULL; json_int_t offset = 0; result = json_unpack_ex(subtitle_dict, &error, 0, "{s?i, s?{s:s}}", "Track", unpack_i(&track), "SRT", "Filename", unpack_s(&srtfile)); if (result < 0) { hb_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } // Embedded subtitle track if (track >= 0 && srtfile == NULL) { hb_subtitle_t *subtitle; subtitle = hb_list_item(job->title->list_subtitle, track); if (subtitle != NULL) { sub_config = subtitle->config; result = json_unpack_ex(subtitle_dict, &error, 0, "{s?b, s?b, s?b, s?i}", "Default", unpack_i(&sub_config.default_track), "Force", unpack_b(&sub_config.force), "Burn", unpack_b(&burn), "Offset", unpack_I(&offset)); if (result < 0) { hb_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } sub_config.offset = offset; sub_config.dest = burn ? RENDERSUB : PASSTHRUSUB; hb_subtitle_add(job, &sub_config, track); } } else if (srtfile != NULL) { strncpy(sub_config.src_filename, srtfile, 255); sub_config.src_filename[255] = 0; char *srtlang = "und"; char *srtcodeset = "UTF-8"; result = json_unpack_ex(subtitle_dict, &error, 0, "{s?b, s?b, s?i, " // Common "s?{s?s, s?s, s?s}}", // SRT "Default", unpack_b(&sub_config.default_track), "Burn", unpack_b(&burn), "Offset", unpack_I(&offset), "SRT", "Filename", unpack_s(&srtfile), "Language", unpack_s(&srtlang), "Codeset", unpack_s(&srtcodeset)); if (result < 0) { hb_error("json unpack failure: %s", error.text); hb_job_close(&job); return NULL; } sub_config.offset = offset; sub_config.dest = burn ? RENDERSUB : PASSTHRUSUB; strncpy(sub_config.src_codeset, srtcodeset, 39); sub_config.src_codeset[39] = 0; hb_srt_add(job, &sub_config, srtlang); } } } 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 * specified title_index * @param title_index - Index of hb_title_t to use for job initialization. * Index comes from title->index or "Index" key * in json representation of a title. */ char* hb_job_init_json(hb_handle_t *h, int title_index) { hb_job_t *job = hb_job_init_by_index(h, title_index); char *json_job = hb_job_to_json(job); hb_job_close(&job); return json_job; } /** * Add a json string job to the hb queue * @param h - Pointer to hb_handle_t instance that job is added to * @param json_job - json string representation of job to add */ int hb_add_json( hb_handle_t * h, const char * json_job ) { hb_job_t job; job.json = json_job; hb_add(h, &job); return 0; } /** * Calculates destination width and height for anamorphic content * * Returns geometry as json string {Width, Height, PAR {Num, Den}} * @param json_param - contains source and destination geometry params. * This encapsulates the values that are in * hb_geometry_t and hb_geometry_settings_t */ char* hb_set_anamorphic_size_json(const char * json_param) { int json_result; json_error_t error; 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 = hb_value_json(json_param); json_result = json_unpack_ex(dict, &error, 0, "{" // SourceGeometry // {Width, Height, PAR {Num, Den}} "s:{s:i, s:i, s:{s:i, s:i}}," // DestSettings "s:{" // Geometry {Width, Height, PAR {Num, Den}}, "s:{s:i, s:i, s:{s:i, s:i}}," // AnamorphicMode, Keep, ItuPAR, Modulus, MaxWidth, MaxHeight, "s:i, s?i, s?b, s:i, s:i, s:i," // Crop [Top, Bottom, Left, Right] "s?[iiii]" " }" "}", "SourceGeometry", "Width", unpack_i(&src.width), "Height", unpack_i(&src.height), "PAR", "Num", unpack_i(&src.par.num), "Den", unpack_i(&src.par.den), "DestSettings", "Geometry", "Width", unpack_i(&ui_geo.geometry.width), "Height", unpack_i(&ui_geo.geometry.height), "PAR", "Num", unpack_i(&ui_geo.geometry.par.num), "Den", unpack_i(&ui_geo.geometry.par.den), "AnamorphicMode", unpack_i(&ui_geo.mode), "Keep", unpack_i(&ui_geo.keep), "ItuPAR", unpack_b(&ui_geo.itu_par), "Modulus", unpack_i(&ui_geo.modulus), "MaxWidth", unpack_i(&ui_geo.maxWidth), "MaxHeight", unpack_i(&ui_geo.maxHeight), "Crop", unpack_i(&ui_geo.crop[0]), unpack_i(&ui_geo.crop[1]), unpack_i(&ui_geo.crop[2]), unpack_i(&ui_geo.crop[3]) ); hb_value_free(&dict); if (json_result < 0) { hb_error("json unpack failure: %s", error.text); return NULL; } hb_set_anamorphic_size2(&src, &ui_geo, &geo_result); dict = json_pack_ex(&error, 0, "{s:o, s:o, s:{s:o, s:o}}", "Width", hb_value_int(geo_result.width), "Height", hb_value_int(geo_result.height), "PAR", "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 = hb_value_get_json(dict); hb_value_free(&dict); return result; } char* hb_get_preview_json(hb_handle_t * h, const char *json_param) { hb_image_t *image; int ii, title_idx, preview_idx, deinterlace = 0; int json_result; json_error_t error; hb_dict_t * dict; hb_geometry_settings_t settings; // Clear dest geometry since some fields are optional. memset(&settings, 0, sizeof(settings)); dict = hb_value_json(json_param); json_result = json_unpack_ex(dict, &error, 0, "{" // Title, Preview, Deinterlace "s:i, s:i, s?b," // DestSettings "s:{" // Geometry {Width, Height, PAR {Num, Den}}, "s:{s:i, s:i, s:{s:i, s:i}}," // AnamorphicMode, Keep, ItuPAR, Modulus, MaxWidth, MaxHeight, "s:i, s?i, s?b, s:i, s:i, s:i," // Crop [Top, Bottom, Left, Right] "s?[iiii]" " }" "}", "Title", unpack_i(&title_idx), "Preview", unpack_i(&preview_idx), "Deinterlace", unpack_b(&deinterlace), "DestSettings", "Geometry", "Width", unpack_i(&settings.geometry.width), "Height", unpack_i(&settings.geometry.height), "PAR", "Num", unpack_i(&settings.geometry.par.num), "Den", unpack_i(&settings.geometry.par.den), "AnamorphicMode", unpack_i(&settings.mode), "Keep", unpack_i(&settings.keep), "ItuPAR", unpack_b(&settings.itu_par), "Modulus", unpack_i(&settings.modulus), "MaxWidth", unpack_i(&settings.maxWidth), "MaxHeight", unpack_i(&settings.maxHeight), "Crop", unpack_i(&settings.crop[0]), unpack_i(&settings.crop[1]), unpack_i(&settings.crop[2]), unpack_i(&settings.crop[3]) ); hb_value_free(&dict); if (json_result < 0) { hb_error("preview params: json unpack failure: %s", error.text); return NULL; } image = hb_get_preview2(h, title_idx, preview_idx, &settings, deinterlace); if (image == NULL) { return NULL; } dict = json_pack_ex(&error, 0, "{s:o, s:o, s:o}", "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; } hb_value_array_t * planes = hb_value_array_init(); for (ii = 0; ii < 4; ii++) { int base64size = AV_BASE64_SIZE(image->plane[ii].size); if (image->plane[ii].size <= 0 || base64size <= 0) continue; char *plane_base64 = calloc(base64size, 1); av_base64_encode(plane_base64, base64size, image->plane[ii].data, image->plane[ii].size); base64size = strlen(plane_base64); 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", 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; } hb_value_array_append(planes, plane_dict); } hb_dict_set(dict, "Planes", planes); hb_image_close(&image); char *result = hb_value_get_json(dict); hb_value_free(&dict); return result; } char* hb_get_preview_params_json(int title_idx, int preview_idx, int deinterlace, hb_geometry_settings_t *settings) { json_error_t error; hb_dict_t * dict; dict = json_pack_ex(&error, 0, "{" "s:o, s:o, s:o," "s:{" " s:{s:o, s:o, s:{s:o, s:o}}," " s:o, s:o, s:o, s:o, s:o, s:o" " s:[oooo]" " }" "}", "Title", hb_value_int(title_idx), "Preview", hb_value_int(preview_idx), "Deinterlace", hb_value_bool(deinterlace), "DestSettings", "Geometry", "Width", hb_value_int(settings->geometry.width), "Height", hb_value_int(settings->geometry.height), "PAR", "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) { hb_error("hb_get_preview_params_json: pack failure: %s", error.text); return NULL; } char *result = hb_value_get_json(dict); hb_value_free(&dict); return result; } hb_image_t* hb_json_to_image(char *json_image) { int json_result; json_error_t error; hb_dict_t * dict; int pix_fmt, width, height; dict = hb_value_json(json_image); json_result = json_unpack_ex(dict, &error, 0, "{" // Format, Width, Height "s:i, s:i, s:i," "}", "Format", unpack_i(&pix_fmt), "Width", unpack_i(&width), "Height", unpack_b(&height) ); if (json_result < 0) { hb_error("image: json unpack failure: %s", error.text); hb_value_free(&dict); return NULL; } hb_image_t *image = hb_image_init(pix_fmt, width, height); if (image == NULL) { hb_value_free(&dict); return 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); hb_value_free(&dict); return image; } if (hb_value_type(planes) == HB_VALUE_TYPE_ARRAY) { 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, "{s:i, s:s}", "Size", unpack_i(&size), "Data", unpack_s(&data)); if (json_result < 0) { hb_error("image::plane::data: json unpack failure: %s", error.text); hb_value_free(&dict); return image; } if (image->plane[ii].size > 0 && data != NULL) { av_base64_decode(image->plane[ii].data, data, image->plane[ii].size); } } } hb_value_free(&dict); return image; }