This is useful for scripts and other frontends that need to parse CLI output.
lang = lang_for_code2( (char*)bdaudio->lang );
- audio->config.lang.type = 0;
+ audio->config.lang.attributes = HB_AUDIO_ATTR_NONE;
snprintf( audio->config.lang.simple,
sizeof( audio->config.lang.simple ), "%s",
return ((hb_mixdown_internal_t*)last)->next;
}
+void hb_layout_get_name(char * name, int size, int64_t layout)
+{
+ av_get_channel_layout_string(name, size, 0, layout);
+}
+
+int hb_layout_get_discrete_channel_count(int64_t layout)
+{
+ return av_get_channel_layout_nb_channels(layout);
+}
+
+int hb_layout_get_low_freq_channel_count(int64_t layout)
+{
+ return !!(layout & AV_CH_LOW_FREQUENCY) +
+ !!(layout & AV_CH_LOW_FREQUENCY_2);
+}
+
int hb_video_encoder_get_default(int muxer)
{
if (!(muxer & HB_MUX_MASK))
fallback_result;
}
+const char* hb_audio_decoder_get_name(int codec, int codec_param)
+{
+ if (codec & HB_ACODEC_FF_MASK)
+ {
+ AVCodec * codec;
+
+ codec = avcodec_find_decoder(codec_param);
+ if (codec != NULL)
+ {
+ return codec->name;
+ }
+ }
+ else
+ {
+ switch (codec)
+ {
+ case HB_ACODEC_LPCM:
+ return "pcm_dvd";
+ default:
+ break;
+ }
+ }
+ return "unknown";
+}
+
hb_container_t* hb_container_get_from_format(int format)
{
int i;
case SRTSUB:
return "SRT";
case CC608SUB:
- return "CC";
+ return "CC608";
case CC708SUB:
- return "CC";
+ return "CC708";
case UTF8SUB:
return "UTF-8";
case TX3GSUB:
const char* hb_mixdown_sanitize_name(const char *name);
const hb_mixdown_t* hb_mixdown_get_next(const hb_mixdown_t *last);
+void hb_layout_get_name(char * name, int size, int64_t layout);
+int hb_layout_get_discrete_channel_count(int64_t layout);
+int hb_layout_get_low_freq_channel_count(int64_t layout);
+
int hb_video_encoder_get_default(int muxer);
hb_encoder_t* hb_video_encoder_get_from_codec(int codec);
int hb_video_encoder_get_from_name(const char *name);
const char* hb_audio_encoder_sanitize_name(const char *name);
const hb_encoder_t* hb_audio_encoder_get_next(const hb_encoder_t *last);
+const char* hb_audio_decoder_get_name(int codec, int codec_param);
+
/*
* Not typically used by the UIs
* (set hb_job_t.acodec_copy_mask, hb_job_t.acodec_fallback instead).
/* define an invalid VBR quality compatible with all VBR-capable codecs */
#define HB_INVALID_AUDIO_QUALITY (-3.)
+#define HB_AUDIO_ATTR_NONE 0x00
+#define HB_AUDIO_ATTR_NORMAL 0x01
+#define HB_AUDIO_ATTR_VISUALLY_IMPAIRED 0x02
+#define HB_AUDIO_ATTR_COMMENTARY 0x04
+#define HB_AUDIO_ATTR_ALT_COMMENTARY 0x08
+#define HB_AUDIO_ATTR_SECONDARY 0x10
+#define HB_AUDIO_ATTR_DEFAULT 0x20
+
// Update win/CS/HandBrake.Interop/HandBrakeInterop/HbLib/hb_audio_config_s.cs when changing this struct
struct hb_audio_config_s
{
PRIVATE char description[1024];
PRIVATE char simple[1024];
PRIVATE char iso639_2[4];
-#define HB_AUDIO_TYPE_NONE 0
-#define HB_AUDIO_TYPE_NORMAL 1
-#define HB_AUDIO_TYPE_VISUALLY_IMPAIRED 2
-#define HB_AUDIO_TYPE_COMMENTARY 3
-#define HB_AUDIO_TYPE_ALT_COMMENTARY 4
-#define HB_AUDIO_TYPE_BD_SECONDARY 5
- PRIVATE uint8_t type; /* normal, visually impaired, director's commentary */
+ PRIVATE uint32_t attributes; /* normal, visually impaired, director's commentary */
} lang;
};
*
* Update win/CS/HandBrake.Interop/HandBrakeInterop/HbLib/hb_subtitle_s.cs when changing this struct
*/
+
+#define HB_SUBTITLE_ATTR_UNKNOWN 0x0000
+#define HB_SUBTITLE_ATTR_NORMAL 0x0001
+#define HB_SUBTITLE_ATTR_LARGE 0x0002
+#define HB_SUBTITLE_ATTR_CHILDREN 0x0004
+#define HB_SUBTITLE_ATTR_CC 0x0008
+#define HB_SUBTITLE_ATTR_FORCED 0x0010
+#define HB_SUBTITLE_ATTR_COMMENTARY 0x0020
+#define HB_SUBTITLE_ATTR_4_3 0x0040
+#define HB_SUBTITLE_ATTR_WIDE 0x0080
+#define HB_SUBTITLE_ATTR_LETTERBOX 0x0100
+#define HB_SUBTITLE_ATTR_PANSCAN 0x0200
+#define HB_SUBTITLE_ATTR_DEFAULT 0x0400
+
struct hb_subtitle_s
{
int id;
enum subsource { VOBSUB, SRTSUB, CC608SUB, /*unused*/CC708SUB, UTF8SUB, TX3GSUB, SSASUB, PGSSUB } source;
char lang[1024];
char iso639_2[4];
- uint8_t type; /* Closed Caption, Childrens, Directors etc */
+ uint32_t attributes; /* Closed Caption, Childrens, Directors etc */
// Color lookup table for VOB subtitle tracks. Each entry is in YCbCr format.
// Must be filled out by the demuxer for VOB subtitle tracks.
subtitle->source = CC608SUB;
subtitle->config.dest = PASSTHRUSUB;
subtitle->codec = WORK_DECCC608;
- subtitle->type = 5;
+ subtitle->attributes = HB_SUBTITLE_ATTR_CC;
/*
* The language of the subtitles will be the same as the
subtitle->substream_type = 0x20 + position;
subtitle->codec = WORK_DECVOBSUB;
- subtitle->type = lang_extension;
-
memcpy(subtitle->palette, palette, 16 * sizeof(uint32_t));
subtitle->palette_set = 1;
switch (lang_extension)
{
+ case 1:
+ subtitle->attributes = HB_SUBTITLE_ATTR_NORMAL;
+ break;
case 2:
+ subtitle->attributes = HB_SUBTITLE_ATTR_LARGE;
strcat(subtitle->lang, " Large Type");
break;
case 3:
+ subtitle->attributes = HB_SUBTITLE_ATTR_CHILDREN;
strcat(subtitle->lang, " Children");
break;
case 5:
+ subtitle->attributes = HB_SUBTITLE_ATTR_CC;
strcat(subtitle->lang, " Closed Caption");
break;
case 6:
+ subtitle->attributes = HB_SUBTITLE_ATTR_CC | HB_SUBTITLE_ATTR_LARGE;
strcat(subtitle->lang, " Closed Caption, Large Type");
break;
case 7:
+ subtitle->attributes = HB_SUBTITLE_ATTR_CC |
+ HB_SUBTITLE_ATTR_CHILDREN;
strcat(subtitle->lang, " Closed Caption, Children");
break;
case 9:
+ subtitle->attributes = HB_SUBTITLE_ATTR_FORCED;
strcat(subtitle->lang, " Forced");
break;
case 13:
+ subtitle->attributes = HB_SUBTITLE_ATTR_COMMENTARY;
strcat(subtitle->lang, " Director's Commentary");
break;
case 14:
+ subtitle->attributes = HB_SUBTITLE_ATTR_COMMENTARY |
+ HB_SUBTITLE_ATTR_LARGE;
strcat(subtitle->lang, " Director's Commentary, Large Type");
break;
case 15:
+ subtitle->attributes = HB_SUBTITLE_ATTR_COMMENTARY |
+ HB_SUBTITLE_ATTR_CHILDREN;
strcat(subtitle->lang, " Director's Commentary, Children");
default:
+ subtitle->attributes = HB_SUBTITLE_ATTR_UNKNOWN;
break;
}
-
switch (style)
{
case HB_VOBSUB_STYLE_4_3:
+ subtitle->attributes |= HB_SUBTITLE_ATTR_4_3;
strcat(subtitle->lang, " (4:3)");
break;
case HB_VOBSUB_STYLE_WIDE:
+ subtitle->attributes |= HB_SUBTITLE_ATTR_WIDE;
strcat(subtitle->lang, " (Wide Screen)");
break;
case HB_VOBSUB_STYLE_LETTERBOX:
+ subtitle->attributes |= HB_SUBTITLE_ATTR_LETTERBOX;
strcat(subtitle->lang, " (Letterbox)");
break;
case HB_VOBSUB_STYLE_PANSCAN:
+ subtitle->attributes |= HB_SUBTITLE_ATTR_PANSCAN;
strcat(subtitle->lang, " (Pan & Scan)");
break;
}
lang = lang_for_code( lang_code );
- audio->config.lang.type = lang_extension;
+ switch ( lang_extension )
+ {
+ case 1:
+ audio->config.lang.attributes = HB_AUDIO_ATTR_NORMAL;
+ break;
+ case 2:
+ audio->config.lang.attributes = HB_AUDIO_ATTR_VISUALLY_IMPAIRED;
+ break;
+ case 3:
+ audio->config.lang.attributes = HB_AUDIO_ATTR_COMMENTARY;
+ break;
+ case 4:
+ audio->config.lang.attributes = HB_AUDIO_ATTR_ALT_COMMENTARY;
+ break;
+ default:
+ audio->config.lang.attributes = HB_AUDIO_ATTR_NONE;
+ break;
+ }
snprintf( audio->config.lang.simple,
sizeof( audio->config.lang.simple ), "%s",
subtitle->substream_type = 0x20 + position;
subtitle->codec = WORK_DECVOBSUB;
- subtitle->type = lang_extension;
-
memcpy(subtitle->palette, palette, 16 * sizeof(uint32_t));
subtitle->palette_set = 1;
switch (lang_extension)
{
+ case 1:
+ subtitle->attributes = HB_SUBTITLE_ATTR_NORMAL;
+ break;
case 2:
+ subtitle->attributes = HB_SUBTITLE_ATTR_LARGE;
strcat(subtitle->lang, " Large Type");
break;
case 3:
+ subtitle->attributes = HB_SUBTITLE_ATTR_CHILDREN;
strcat(subtitle->lang, " Children");
break;
case 5:
+ subtitle->attributes = HB_SUBTITLE_ATTR_CC;
strcat(subtitle->lang, " Closed Caption");
break;
case 6:
+ subtitle->attributes = HB_SUBTITLE_ATTR_CC | HB_SUBTITLE_ATTR_LARGE;
strcat(subtitle->lang, " Closed Caption, Large Type");
break;
case 7:
+ subtitle->attributes = HB_SUBTITLE_ATTR_CC |
+ HB_SUBTITLE_ATTR_CHILDREN;
strcat(subtitle->lang, " Closed Caption, Children");
break;
case 9:
+ subtitle->attributes = HB_SUBTITLE_ATTR_FORCED;
strcat(subtitle->lang, " Forced");
break;
case 13:
+ subtitle->attributes = HB_SUBTITLE_ATTR_COMMENTARY;
strcat(subtitle->lang, " Director's Commentary");
break;
case 14:
+ subtitle->attributes = HB_SUBTITLE_ATTR_COMMENTARY |
+ HB_SUBTITLE_ATTR_LARGE;
strcat(subtitle->lang, " Director's Commentary, Large Type");
break;
case 15:
+ subtitle->attributes = HB_SUBTITLE_ATTR_COMMENTARY |
+ HB_SUBTITLE_ATTR_CHILDREN;
strcat(subtitle->lang, " Director's Commentary, Children");
default:
+ subtitle->attributes = HB_SUBTITLE_ATTR_UNKNOWN;
break;
}
-
switch (style)
{
case HB_VOBSUB_STYLE_4_3:
+ subtitle->attributes |= HB_SUBTITLE_ATTR_4_3;
strcat(subtitle->lang, " (4:3)");
break;
case HB_VOBSUB_STYLE_WIDE:
+ subtitle->attributes |= HB_SUBTITLE_ATTR_WIDE;
strcat(subtitle->lang, " (Wide Screen)");
break;
case HB_VOBSUB_STYLE_LETTERBOX:
+ subtitle->attributes |= HB_SUBTITLE_ATTR_LETTERBOX;
strcat(subtitle->lang, " (Letterbox)");
break;
case HB_VOBSUB_STYLE_PANSCAN:
+ subtitle->attributes |= HB_SUBTITLE_ATTR_PANSCAN;
strcat(subtitle->lang, " (Pan & Scan)");
break;
}
{
continue;
}
+ switch ( lang_extension )
+ {
+ case 1:
+ audio->config.lang.attributes = HB_AUDIO_ATTR_NORMAL;
+ break;
+ case 2:
+ audio->config.lang.attributes = HB_AUDIO_ATTR_VISUALLY_IMPAIRED;
+ break;
+ case 3:
+ audio->config.lang.attributes = HB_AUDIO_ATTR_COMMENTARY;
+ break;
+ case 4:
+ audio->config.lang.attributes = HB_AUDIO_ATTR_ALT_COMMENTARY;
+ break;
+ default:
+ audio->config.lang.attributes = HB_AUDIO_ATTR_NONE;
+ break;
+ }
/* Check for duplicate tracks */
audio_tmp = NULL;
lang = lang_for_code( lang_code );
- audio->config.lang.type = lang_extension;
snprintf( audio->config.lang.simple,
sizeof( audio->config.lang.simple ), "%s",
*/
hb_dict_t* hb_state_to_dict( hb_state_t * state)
{
+ const char * state_s;
hb_dict_t *dict = NULL;
json_error_t error;
+ switch (state->state)
+ {
+ case HB_STATE_IDLE:
+ state_s = "IDLE";
+ break;
+ case HB_STATE_SCANNING:
+ state_s = "SCANNING";
+ break;
+ case HB_STATE_SCANDONE:
+ state_s = "SCANDONE";
+ break;
+ case HB_STATE_WORKING:
+ state_s = "WORKING";
+ break;
+ case HB_STATE_PAUSED:
+ state_s = "PAUSED";
+ break;
+ case HB_STATE_SEARCHING:
+ state_s = "SEARCHING";
+ break;
+ case HB_STATE_WORKDONE:
+ state_s = "WORKDONE";
+ break;
+ case HB_STATE_MUXING:
+ state_s = "MUXING";
+ break;
+ default:
+ state_s = "UNKNOWN";
+ break;
+ }
+
switch (state->state)
{
case HB_STATE_IDLE:
dict = json_pack_ex(&error, 0, "{s:o}",
- "State", hb_value_int(state->state));
+ "State", hb_value_string(state_s));
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),
+ "State", hb_value_string(state_s),
"Scanning",
"Progress", hb_value_double(state->param.scanning.progress),
"Preview", hb_value_int(state->param.scanning.preview_cur),
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),
+ "State", hb_value_string(state_s),
"Working",
"Progress", hb_value_double(state->param.working.progress),
"PassID", hb_value_int(state->param.working.pass_id),
case HB_STATE_WORKDONE:
dict = json_pack_ex(&error, 0,
"{s:o, s{s:o}}",
- "State", hb_value_int(state->state),
+ "State", hb_value_string(state_s),
"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),
+ "State", hb_value_string(state_s),
"Muxing",
"Progress", hb_value_double(state->param.muxing.progress));
break;
default:
- hb_error("hb_state_to_json: unrecognized state %d", state->state);
+ dict = json_pack_ex(&error, 0, "{s:o}",
+ "State", hb_value_string(state_s));
+ hb_error("hb_state_to_dict: unrecognized state %d", state->state);
break;
}
if (dict == NULL)
return dict;
}
+hb_dict_t * hb_version_dict()
+{
+ hb_dict_t * dict;
+ json_error_t error;
+
+ dict = json_pack_ex(&error, 0,
+ "{s:o, s:o, s:o, s{s:o, s:o, s:o}, s:o, s:o, s:o, s:o, s:o}",
+ "Name", hb_value_string(HB_PROJECT_NAME),
+ "Official", hb_value_bool(HB_PROJECT_REPO_OFFICIAL),
+ "Type", hb_value_string(HB_PROJECT_REPO_TYPE),
+ "Version",
+ "Major", hb_value_int(HB_PROJECT_VERSION_MAJOR),
+ "Minor", hb_value_int(HB_PROJECT_VERSION_MINOR),
+ "Point", hb_value_int(HB_PROJECT_VERSION_POINT),
+ "VersionString", hb_value_string(HB_PROJECT_VERSION),
+ "RepoHash", hb_value_string(HB_PROJECT_REPO_HASH),
+ "RepoDate", hb_value_string(HB_PROJECT_REPO_DATE),
+ "System", hb_value_string(HB_PROJECT_BUILD_SYSTEMF),
+ "Arch", hb_value_string(HB_PROJECT_BUILD_ARCH));
+ if (dict == NULL)
+ {
+ hb_error("json pack failure: %s", error.text);
+ return NULL;
+ }
+
+ return dict;
+}
+
/**
* Get the current state of an hb instance as a json string
* @param h - Pointer to an hb_handle_t hb instance
return json_state;
}
+hb_dict_t * hb_audio_attributes_to_dict(uint32_t attributes)
+{
+ json_error_t error;
+ hb_dict_t * dict;
+
+ dict = json_pack_ex(&error, 0,
+ "{s:o, s:o, s:o, s:o, s:o, s:o}",
+ "Normal", hb_value_bool(attributes & HB_AUDIO_ATTR_NORMAL),
+ "VisuallyImpaired", hb_value_bool(attributes &
+ HB_AUDIO_ATTR_VISUALLY_IMPAIRED),
+ "Commentary", hb_value_bool(attributes &
+ HB_AUDIO_ATTR_COMMENTARY),
+ "AltCommentary", hb_value_bool(attributes &
+ HB_AUDIO_ATTR_ALT_COMMENTARY),
+ "Secondary", hb_value_bool(attributes & HB_AUDIO_ATTR_SECONDARY),
+ "Default", hb_value_bool(attributes & HB_AUDIO_ATTR_DEFAULT));
+ if (dict == NULL)
+ {
+ hb_error("json pack failure: %s", error.text);
+ }
+ return dict;
+}
+
+hb_dict_t * hb_subtitle_attributes_to_dict(uint32_t attributes)
+{
+ json_error_t error;
+ hb_dict_t * dict;
+
+ 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, s:o}",
+ "Normal", hb_value_bool(attributes & HB_SUBTITLE_ATTR_NORMAL),
+ "Large", hb_value_bool(attributes & HB_SUBTITLE_ATTR_LARGE),
+ "Children", hb_value_bool(attributes & HB_SUBTITLE_ATTR_CHILDREN),
+ "ClosedCaption", hb_value_bool(attributes & HB_SUBTITLE_ATTR_CC),
+ "Forced", hb_value_bool(attributes & HB_SUBTITLE_ATTR_FORCED),
+ "Commentary", hb_value_bool(attributes &
+ HB_SUBTITLE_ATTR_COMMENTARY),
+ "4By3", hb_value_bool(attributes & HB_SUBTITLE_ATTR_4_3),
+ "Wide", hb_value_bool(attributes & HB_SUBTITLE_ATTR_WIDE),
+ "Letterbox", hb_value_bool(attributes & HB_SUBTITLE_ATTR_LETTERBOX),
+ "PanScan", hb_value_bool(attributes & HB_SUBTITLE_ATTR_PANSCAN),
+ "Default", hb_value_bool(attributes & HB_SUBTITLE_ATTR_DEFAULT));
+ if (dict == NULL)
+ {
+ hb_error("json pack failure: %s", error.text);
+ }
+ return dict;
+}
+
static hb_dict_t* hb_title_to_dict_internal( hb_title_t *title )
{
hb_dict_t *dict;
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);
+ const char * codec_name;
+ char channel_layout_name[64];
+ int channel_count, lfe_count;
+ hb_dict_t * audio_dict, * attributes;
+ hb_audio_t * audio = hb_list_item(title->list_audio, ii);
+ codec_name = hb_audio_decoder_get_name(audio->config.in.codec,
+ audio->config.in.codec_param);
+ hb_layout_get_name(channel_layout_name, sizeof(channel_layout_name),
+ audio->config.in.channel_layout);
+ channel_count = hb_layout_get_discrete_channel_count(
+ audio->config.in.channel_layout);
+ lfe_count = hb_layout_get_low_freq_channel_count(
+ audio->config.in.channel_layout);
+
+
+ attributes = hb_audio_attributes_to_dict(audio->config.lang.attributes);
audio_dict = json_pack_ex(&error, 0,
- "{s:o, 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));
+ "{s:o, s:o, s:o, s:o, s:o, s:o, 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),
+ "Attributes", attributes,
+ "Codec", hb_value_int(audio->config.in.codec),
+ "CodecName", hb_value_string(codec_name),
+ "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),
+ "ChannelLayoutName", hb_value_string(channel_layout_name),
+ "ChannelCount", hb_value_int(channel_count),
+ "LFECount", hb_value_int(lfe_count));
if (audio_dict == NULL)
{
hb_error("json pack failure: %s", error.text);
hb_dict_set(dict, "AudioList", audio_list);
// process subtitle list
- hb_dict_t * subtitle_list = hb_value_array_init();
+ hb_value_array_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);
+ const char * format;
+ hb_dict_t * subtitle_dict, * attributes;
+ hb_subtitle_t * subtitle = hb_list_item(title->list_subtitle, ii);
+ format = subtitle->format == PICTURESUB ? "bitmap" : "text";
+ attributes = hb_subtitle_attributes_to_dict(subtitle->attributes);
subtitle_dict = json_pack_ex(&error, 0,
- "{s:o, s:o, s:o, s:o}",
- "Format", hb_value_int(subtitle->format),
+ "{s:o, s:o, s:o, s:o, s:o, s:o}",
+ "Format", hb_value_string(format),
"Source", hb_value_int(subtitle->source),
+ "SourceName", hb_value_string(hb_subsource_name(subtitle->source)),
+ "Attributes", attributes,
"Language", hb_value_string(subtitle->lang),
"LanguageCode", hb_value_string(subtitle->iso639_2));
if (subtitle_dict == NULL)
int deinterlace, hb_geometry_settings_t *settings);
char * hb_get_preview_json(hb_handle_t * h, const char *json_param);
void hb_json_job_scan( hb_handle_t * h, const char * json_job );
+hb_dict_t * hb_version_dict(void);
#ifdef __cplusplus
}
// When behavior is "all" matching tracks,
// allow any audio track type
if ((behavior == 2 ||
- audio->lang.type == HB_AUDIO_TYPE_NONE ||
- audio->lang.type == HB_AUDIO_TYPE_NORMAL) &&
+ audio->lang.attributes == HB_AUDIO_ATTR_NONE ||
+ audio->lang.attributes == HB_AUDIO_ATTR_NORMAL) &&
(!strcmp(lang, audio->lang.iso639_2) || !strcmp(lang, "und")))
{
return ii;
sprintf(audio->config.lang.description, "%s (%s)",
audio->config.lang.simple, codec_name);
- switch (audio->config.lang.type)
+ if (audio->config.lang.attributes & HB_AUDIO_ATTR_VISUALLY_IMPAIRED)
{
- case 2:
- strcat(audio->config.lang.description, " (Visually Impaired)");
- break;
- case 3:
- strcat(audio->config.lang.description, " (Director's Commentary 1)");
- break;
- case 4:
- strcat(audio->config.lang.description, " (Director's Commentary 2)");
- break;
- default:
- break;
+ strncat(audio->config.lang.description, " (Visually Impaired)",
+ sizeof(audio->config.lang.description) -
+ strlen(audio->config.lang.description) - 1);
+ }
+ if (audio->config.lang.attributes & HB_AUDIO_ATTR_COMMENTARY)
+ {
+ strncat(audio->config.lang.description, " (Director's Commentary 1)",
+ sizeof(audio->config.lang.description) -
+ strlen(audio->config.lang.description) - 1);
+ }
+ if (audio->config.lang.attributes & HB_AUDIO_ATTR_ALT_COMMENTARY)
+ {
+ strncat(audio->config.lang.description, " (Director's Commentary 2)",
+ sizeof(audio->config.lang.description) -
+ strlen(audio->config.lang.description) - 1);
}
if (audio->config.in.channel_layout)
strlen( lang->native_name ) ? lang->native_name : lang->eng_name );
snprintf( audio->config.lang.iso639_2,
sizeof( audio->config.lang.iso639_2 ), "%s", lang->iso639_2 );
- audio->config.lang.type = 0;
}
// Sort specifies the index in the audio list where you would
break;
}
+ if (st->disposition & AV_DISPOSITION_DEFAULT)
+ {
+ audio->config.lang.attributes |= HB_AUDIO_ATTR_DEFAULT;
+ }
+
set_audio_description(audio,
lang_for_code2(tag != NULL ? tag->value : "und"));
hb_list_add(title->list_audio, audio);
if (st->disposition & AV_DISPOSITION_DEFAULT)
{
subtitle->config.default_track = 1;
+ subtitle->attributes |= HB_SUBTITLE_ATTR_DEFAULT;
+ }
+ if (st->disposition & AV_DISPOSITION_FORCED)
+ {
+ subtitle->attributes |= HB_SUBTITLE_ATTR_FORCED;
}
subtitle->track = hb_list_count(title->list_subtitle);
/* Options */
static int debug = HB_DEBUG_ALL;
+static int json = 0;
static int align_av_start = -1;
static int dvdnav = 1;
static char * input = NULL;
static void PrintTitleSetInfo( hb_title_set_t * title_set )
{
- int i;
- hb_title_t * title;
+ if (json)
+ {
+ hb_dict_t * title_set_dict;
+ char * title_set_json;
- for( i = 0; i < hb_list_count( title_set->list_title ); i++ )
+ title_set_dict = hb_title_set_to_dict(title_set);
+ title_set_json = hb_value_get_json(title_set_dict);
+ hb_value_free(&title_set_dict);
+ fprintf(stdout, "JSON Title Set: %s\n", title_set_json);
+ free(title_set_json);
+ }
+ else
{
- title = hb_list_item( title_set->list_title, i );
- PrintTitleInfo( title, title_set->feature );
+ int i;
+ hb_title_t * title;
+
+ for( i = 0; i < hb_list_count( title_set->list_title ); i++ )
+ {
+ title = hb_list_item( title_set->list_title, i );
+ PrintTitleInfo( title, title_set->feature );
+ }
}
}
}
}
+static void show_progress_json(hb_state_t * state)
+{
+ hb_dict_t * state_dict;
+ char * state_json;
+
+ state_dict = hb_state_to_dict(state);
+ state_json = hb_value_get_json(state_dict);
+ hb_value_free(&state_dict);
+ fprintf(stdout, "Progress: %s\n", state_json);
+ free(state_json);
+ fflush(stderr);
+}
+
static int HandleEvents(hb_handle_t * h, hb_dict_t *preset_dict)
{
hb_state_t s;
#define p s.param.scanning
case HB_STATE_SCANNING:
/* Show what title is currently being scanned */
+ if (json)
+ {
+ show_progress_json(&s);
+ break;
+ }
if (p.preview_cur)
{
fprintf(stderr, "%sScanning title %d of %d, preview %d, %.2f %%",
#define p s.param.working
case HB_STATE_SEARCHING:
+ if (json)
+ {
+ show_progress_json(&s);
+ break;
+ }
fprintf( stdout, "%sEncoding: task %d of %d, Searching for start time, %.2f %%",
stdout_sep, p.pass, p.pass_count, 100.0 * p.progress );
if( p.seconds > -1 )
break;
case HB_STATE_WORKING:
+ if (json)
+ {
+ show_progress_json(&s);
+ break;
+ }
fprintf( stdout, "%sEncoding: task %d of %d, %.2f %%",
stdout_sep, p.pass, p.pass_count, 100.0 * p.progress );
if( p.seconds > -1 )
#define p s.param.muxing
case HB_STATE_MUXING:
{
+ if (json)
+ {
+ show_progress_json(&s);
+ break;
+ }
if (show_mux_warning)
{
fprintf( stdout, "%sMuxing: this may take awhile...", stdout_sep );
#define p s.param.workdone
case HB_STATE_WORKDONE:
/* Print error if any, then exit */
+ if (json)
+ {
+ show_progress_json(&s);
+ }
switch( p.error )
{
case HB_ERROR_NONE:
"\n"
" -h, --help Print help\n"
" --version Print version\n"
+" --json Log title, progress, and version info in\n"
+" JSON format\n"
" -v, --verbose[=number] Be verbose (optional argument: logging level)\n"
" -Z. --preset <string> Select preset by name (case-sensitive)\n"
" Enclose names containing spaces in double quotation\n"
#define FILTER_UNSHARP_TUNE 313
#define FILTER_LAPSHARP 314
#define FILTER_LAPSHARP_TUNE 315
+ #define JSON_LOGGING 316
for( ;; )
{
{ "pfr", no_argument, &cfr, 2 },
{ "audio-copy-mask", required_argument, NULL, ALLOWED_AUDIO_COPY },
{ "audio-fallback", required_argument, NULL, AUDIO_FALLBACK },
+ { "json", no_argument, NULL, JSON_LOGGING },
{ 0, 0, 0, 0 }
};
case DESCRIBE:
printf("%s\n", hb_get_full_description());
return 1;
+ case JSON_LOGGING:
+ {
+ hb_dict_t * version_dict;
+ char * version_json;
+
+ version_dict = hb_version_dict();
+ version_json = hb_value_get_json(version_dict);
+ hb_value_free(&version_dict);
+ fprintf(stdout, "Version: %s\n", version_json);
+ free(version_json);
+ json = 1;
+ } break;
case 'v':
if( optarg != NULL )
{
projects / handbrake / commitdiff