?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WinGui: Fix another instance of the Caliburn vs Json.net sillyness where objects...
[HandBrake.git] / libhb / common.c
blobc64fed5911f97becaaea6a7b9d47d469a1b7e198
1 /* common.c
2
3 Copyright (c) 2003-2015 HandBrake Team
4 This file is part of the HandBrake source code
5 Homepage: <http://handbrake.fr/>.
6 It may be used under the terms of the GNU General Public License v2.
7 For full terms see the file COPYING file or visit http://www.gnu.org/licenses/gpl-2.0.html
8 */
9
10 #include <stdarg.h>
11 #include <time.h>
12 #include <ctype.h>
13 #include <sys/time.h>
14
15 #include "hb.h"
16 #include "x264.h"
17 #include "lang.h"
18 #include "common.h"
19 #include "h264_common.h"
20 #include "h265_common.h"
21 #ifdef USE_QSV
22 #include "qsv_common.h"
23 #endif
24
25 #ifdef USE_X265
26 #include "x265.h"
27 #endif
28
29 #ifdef SYS_MINGW
30 #include <windows.h>
31 #endif
32
33 /**********************************************************************
34 * Global variables
35 *********************************************************************/
36 static hb_error_handler_t *error_handler = NULL;
37
38 /* Generic IDs for encoders, containers, etc. */
39 enum
40 {
41 HB_GID_NONE = -1, // encoders must NEVER use it
42 HB_GID_VCODEC_H264,
43 HB_GID_VCODEC_H265,
44 HB_GID_VCODEC_MPEG2,
45 HB_GID_VCODEC_MPEG4,
46 HB_GID_VCODEC_THEORA,
47 HB_GID_VCODEC_VP8,
48 HB_GID_ACODEC_AAC,
49 HB_GID_ACODEC_AAC_HE,
50 HB_GID_ACODEC_AAC_PASS,
51 HB_GID_ACODEC_AC3,
52 HB_GID_ACODEC_AC3_PASS,
53 HB_GID_ACODEC_AUTO_PASS,
54 HB_GID_ACODEC_DTS_PASS,
55 HB_GID_ACODEC_DTSHD_PASS,
56 HB_GID_ACODEC_EAC3,
57 HB_GID_ACODEC_EAC3_PASS,
58 HB_GID_ACODEC_FLAC,
59 HB_GID_ACODEC_FLAC_PASS,
60 HB_GID_ACODEC_MP3,
61 HB_GID_ACODEC_MP3_PASS,
62 HB_GID_ACODEC_TRUEHD_PASS,
63 HB_GID_ACODEC_VORBIS,
64 HB_GID_MUX_MKV,
65 HB_GID_MUX_MP4,
66 };
67
68 typedef struct
69 {
70 hb_rate_t item;
71 hb_rate_t *next;
72 int enabled;
73 } hb_rate_internal_t;
74 hb_rate_t *hb_video_rates_first_item = NULL;
75 hb_rate_t *hb_video_rates_last_item = NULL;
76 hb_rate_internal_t hb_video_rates[] =
77 {
78 // legacy framerates (disabled)
79 { { "23.976 (NTSC Film)", 1126125, }, NULL, 0, },
80 { { "25 (PAL Film/Video)", 1080000, }, NULL, 0, },
81 { { "29.97 (NTSC Video)", 900900, }, NULL, 0, },
82 // actual framerates
83 { { "5", 5400000, }, NULL, 1, },
84 { { "10", 2700000, }, NULL, 1, },
85 { { "12", 2250000, }, NULL, 1, },
86 { { "15", 1800000, }, NULL, 1, },
87 { { "23.976", 1126125, }, NULL, 1, },
88 { { "24", 1125000, }, NULL, 1, },
89 { { "25", 1080000, }, NULL, 1, },
90 { { "29.97", 900900, }, NULL, 1, },
91 { { "30", 900000, }, NULL, 1, },
92 { { "50", 540000, }, NULL, 1, },
93 { { "59.94", 450450, }, NULL, 1, },
94 { { "60", 450000, }, NULL, 1, },
95 };
96 int hb_video_rates_count = sizeof(hb_video_rates) / sizeof(hb_video_rates[0]);
97
98 hb_rate_t *hb_audio_rates_first_item = NULL;
99 hb_rate_t *hb_audio_rates_last_item = NULL;
100 hb_rate_internal_t hb_audio_rates[] =
101 {
102 { { "8", 8000, }, NULL, 1, },
103 { { "11.025", 11025, }, NULL, 1, },
104 { { "12", 12000, }, NULL, 1, },
105 { { "16", 16000, }, NULL, 1, },
106 { { "22.05", 22050, }, NULL, 1, },
107 { { "24", 24000, }, NULL, 1, },
108 { { "32", 32000, }, NULL, 1, },
109 { { "44.1", 44100, }, NULL, 1, },
110 { { "48", 48000, }, NULL, 1, },
111 };
112 int hb_audio_rates_count = sizeof(hb_audio_rates) / sizeof(hb_audio_rates[0]);
113
114 hb_rate_t *hb_audio_bitrates_first_item = NULL;
115 hb_rate_t *hb_audio_bitrates_last_item = NULL;
116 hb_rate_internal_t hb_audio_bitrates[] =
117 {
118 // AC3-compatible bitrates
119 { { "32", 32, }, NULL, 1, },
120 { { "40", 40, }, NULL, 1, },
121 { { "48", 48, }, NULL, 1, },
122 { { "56", 56, }, NULL, 1, },
123 { { "64", 64, }, NULL, 1, },
124 { { "80", 80, }, NULL, 1, },
125 { { "96", 96, }, NULL, 1, },
126 { { "112", 112, }, NULL, 1, },
127 { { "128", 128, }, NULL, 1, },
128 { { "160", 160, }, NULL, 1, },
129 { { "192", 192, }, NULL, 1, },
130 { { "224", 224, }, NULL, 1, },
131 { { "256", 256, }, NULL, 1, },
132 { { "320", 320, }, NULL, 1, },
133 { { "384", 384, }, NULL, 1, },
134 { { "448", 448, }, NULL, 1, },
135 { { "512", 512, }, NULL, 1, },
136 { { "576", 576, }, NULL, 1, },
137 { { "640", 640, }, NULL, 1, },
138 // additional bitrates
139 { { "768", 768, }, NULL, 1, },
140 { { "960", 960, }, NULL, 1, },
141 { { "1152", 1152, }, NULL, 1, },
142 { { "1344", 1344, }, NULL, 1, },
143 { { "1536", 1536, }, NULL, 1, },
144 { { "2304", 2304, }, NULL, 1, },
145 { { "3072", 3072, }, NULL, 1, },
146 { { "4608", 4608, }, NULL, 1, },
147 { { "6144", 6144, }, NULL, 1, },
148 };
149 int hb_audio_bitrates_count = sizeof(hb_audio_bitrates) / sizeof(hb_audio_bitrates[0]);
150
151 typedef struct
152 {
153 hb_dither_t item;
154 hb_dither_t *next;
155 int enabled;
156 } hb_dither_internal_t;
157 hb_dither_t *hb_audio_dithers_first_item = NULL;
158 hb_dither_t *hb_audio_dithers_last_item = NULL;
159 hb_dither_internal_t hb_audio_dithers[] =
160 {
161 { { "default", "auto", AV_RESAMPLE_DITHER_NONE - 1, }, NULL, 1, },
162 { { "none", "none", AV_RESAMPLE_DITHER_NONE, }, NULL, 1, },
163 { { "rectangular", "rectangular", AV_RESAMPLE_DITHER_RECTANGULAR, }, NULL, 1, },
164 { { "triangular", "triangular", AV_RESAMPLE_DITHER_TRIANGULAR, }, NULL, 1, },
165 { { "triangular with high pass", "triangular_hp", AV_RESAMPLE_DITHER_TRIANGULAR_HP, }, NULL, 1, },
166 { { "triangular with noise shaping", "triangular_ns", AV_RESAMPLE_DITHER_TRIANGULAR_NS, }, NULL, 1, },
167 };
168 int hb_audio_dithers_count = sizeof(hb_audio_dithers) / sizeof(hb_audio_dithers[0]);
169
170 typedef struct
171 {
172 hb_mixdown_t item;
173 hb_mixdown_t *next;
174 int enabled;
175 } hb_mixdown_internal_t;
176 hb_mixdown_t *hb_audio_mixdowns_first_item = NULL;
177 hb_mixdown_t *hb_audio_mixdowns_last_item = NULL;
178 hb_mixdown_internal_t hb_audio_mixdowns[] =
179 {
180 // legacy mixdowns, back to HB 0.9.4 whenever possible (disabled)
181 { { "AC3 Passthru", "", HB_AMIXDOWN_NONE, }, NULL, 0, },
182 { { "DTS Passthru", "", HB_AMIXDOWN_NONE, }, NULL, 0, },
183 { { "DTS-HD Passthru", "", HB_AMIXDOWN_NONE, }, NULL, 0, },
184 { { "6-channel discrete", "6ch", HB_AMIXDOWN_5POINT1, }, NULL, 0, },
185 // actual mixdowns
186 { { "None", "none", HB_AMIXDOWN_NONE, }, NULL, 1, },
187 { { "Mono", "mono", HB_AMIXDOWN_MONO, }, NULL, 1, },
188 { { "Mono (Left Only)", "left_only", HB_AMIXDOWN_LEFT, }, NULL, 1, },
189 { { "Mono (Right Only)", "right_only", HB_AMIXDOWN_RIGHT, }, NULL, 1, },
190 { { "Stereo", "stereo", HB_AMIXDOWN_STEREO, }, NULL, 1, },
191 { { "Dolby Surround", "dpl1", HB_AMIXDOWN_DOLBY, }, NULL, 1, },
192 { { "Dolby Pro Logic II", "dpl2", HB_AMIXDOWN_DOLBYPLII, }, NULL, 1, },
193 { { "5.1 Channels", "5point1", HB_AMIXDOWN_5POINT1, }, NULL, 1, },
194 { { "6.1 Channels", "6point1", HB_AMIXDOWN_6POINT1, }, NULL, 1, },
195 { { "7.1 Channels", "7point1", HB_AMIXDOWN_7POINT1, }, NULL, 1, },
196 { { "7.1 (5F/2R/LFE)", "5_2_lfe", HB_AMIXDOWN_5_2_LFE, }, NULL, 1, },
197 };
198 int hb_audio_mixdowns_count = sizeof(hb_audio_mixdowns) / sizeof(hb_audio_mixdowns[0]);
199
200 typedef struct
201 {
202 hb_encoder_t item;
203 hb_encoder_t *next;
204 int enabled;
205 int gid;
206 } hb_encoder_internal_t;
207 hb_encoder_t *hb_video_encoders_first_item = NULL;
208 hb_encoder_t *hb_video_encoders_last_item = NULL;
209 hb_encoder_internal_t hb_video_encoders[] =
210 {
211 // legacy encoders, back to HB 0.9.4 whenever possible (disabled)
212 { { "FFmpeg", "ffmpeg", NULL, HB_VCODEC_FFMPEG_MPEG4, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_VCODEC_MPEG4, },
213 { { "MPEG-4 (FFmpeg)", "ffmpeg4", NULL, HB_VCODEC_FFMPEG_MPEG4, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_VCODEC_MPEG4, },
214 { { "MPEG-2 (FFmpeg)", "ffmpeg2", NULL, HB_VCODEC_FFMPEG_MPEG2, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_VCODEC_MPEG2, },
215 { { "VP3 (Theora)", "libtheora", NULL, HB_VCODEC_THEORA, HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_VCODEC_THEORA, },
216 // actual encoders
217 { { "H.264 (x264)", "x264", "H.264 (libx264)", HB_VCODEC_X264, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_H264, },
218 { { "H.264 (Intel QSV)", "qsv_h264", "H.264 (Intel Media SDK)", HB_VCODEC_QSV_H264, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_H264, },
219 { { "H.265 (x265)", "x265", "H.265 (libx265)", HB_VCODEC_X265, HB_MUX_AV_MP4|HB_MUX_AV_MKV, }, NULL, 1, HB_GID_VCODEC_H265, },
220 { { "MPEG-4", "mpeg4", "MPEG-4 (libavcodec)", HB_VCODEC_FFMPEG_MPEG4, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_MPEG4, },
221 { { "MPEG-2", "mpeg2", "MPEG-2 (libavcodec)", HB_VCODEC_FFMPEG_MPEG2, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_MPEG2, },
222 { { "VP8", "VP8", "VP8 (libvpx)", HB_VCODEC_FFMPEG_VP8, HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_VP8, },
223 { { "Theora", "theora", "Theora (libtheora)", HB_VCODEC_THEORA, HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_THEORA, },
224 };
225 int hb_video_encoders_count = sizeof(hb_video_encoders) / sizeof(hb_video_encoders[0]);
226 static int hb_video_encoder_is_enabled(int encoder)
227 {
228 #ifdef USE_QSV
229 if (encoder & HB_VCODEC_QSV_MASK)
230 {
231 return hb_qsv_video_encoder_is_enabled(encoder);
232 }
233 #endif
234 switch (encoder)
235 {
236 // the following encoders are always enabled
237 case HB_VCODEC_X264:
238 case HB_VCODEC_THEORA:
239 case HB_VCODEC_FFMPEG_MPEG4:
240 case HB_VCODEC_FFMPEG_MPEG2:
241 case HB_VCODEC_FFMPEG_VP8:
242 #ifdef USE_X265
243 case HB_VCODEC_X265:
244 #endif
245 return 1;
246
247 default:
248 return 0;
249 }
250 }
251
252 hb_encoder_t *hb_audio_encoders_first_item = NULL;
253 hb_encoder_t *hb_audio_encoders_last_item = NULL;
254 hb_encoder_internal_t hb_audio_encoders[] =
255 {
256 // legacy encoders, back to HB 0.9.4 whenever possible (disabled)
257 { { "", "dts", NULL, HB_ACODEC_DCA_PASS, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_ACODEC_DTS_PASS, },
258 { { "AAC (faac)", "faac", NULL, 0, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_ACODEC_AAC, },
259 { { "AAC (ffmpeg)", "ffaac", NULL, HB_ACODEC_FFAAC, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_ACODEC_AAC, },
260 { { "AC3 (ffmpeg)", "ffac3", NULL, HB_ACODEC_AC3, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_ACODEC_AC3, },
261 { { "MP3 (lame)", "lame", NULL, HB_ACODEC_LAME, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_ACODEC_MP3, },
262 { { "Vorbis (vorbis)", "libvorbis", NULL, HB_ACODEC_VORBIS, HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_ACODEC_VORBIS, },
263 { { "FLAC (ffmpeg)", "ffflac", NULL, HB_ACODEC_FFFLAC, HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_ACODEC_FLAC, },
264 { { "FLAC (24-bit)", "ffflac24", NULL, HB_ACODEC_FFFLAC24, HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_ACODEC_FLAC, },
265 // generic names
266 { { "AAC", "aac", NULL, 0, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_ACODEC_AAC, },
267 { { "HE-AAC", "haac", NULL, 0, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, HB_GID_ACODEC_AAC_HE, },
268 // actual encoders
269 { { "AAC (CoreAudio)", "ca_aac", "AAC (Apple AudioToolbox)", HB_ACODEC_CA_AAC, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_AAC, },
270 { { "HE-AAC (CoreAudio)", "ca_haac", "HE-AAC (Apple AudioToolbox)", HB_ACODEC_CA_HAAC, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_AAC_HE, },
271 { { "AAC (FDK)", "fdk_aac", "AAC (libfdk_aac)", HB_ACODEC_FDK_AAC, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_AAC, },
272 { { "HE-AAC (FDK)", "fdk_haac", "HE-AAC (libfdk_aac)", HB_ACODEC_FDK_HAAC, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_AAC_HE, },
273 { { "AAC (avcodec)", "av_aac", "AAC (libavcodec)", HB_ACODEC_FFAAC, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_AAC, },
274 { { "AAC Passthru", "copy:aac", "AAC Passthru", HB_ACODEC_AAC_PASS, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_AAC_PASS, },
275 { { "AC3", "ac3", "AC3 (libavcodec)", HB_ACODEC_AC3, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_AC3, },
276 { { "AC3 Passthru", "copy:ac3", "AC3 Passthru", HB_ACODEC_AC3_PASS, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_AC3_PASS, },
277 { { "E-AC3", "eac3", "E-AC3 (libavcodec)", HB_ACODEC_FFEAC3, HB_MUX_AV_MKV, }, NULL, 1, HB_GID_ACODEC_EAC3, },
278 { { "E-AC3 Passthru", "copy:eac3", "E-AC3 Passthru", HB_ACODEC_EAC3_PASS, HB_MUX_AV_MKV, }, NULL, 1, HB_GID_ACODEC_EAC3_PASS, },
279 { { "TrueHD Passthru", "copy:truehd","TrueHD Passthru", HB_ACODEC_TRUEHD_PASS, HB_MUX_AV_MKV, }, NULL, 1, HB_GID_ACODEC_TRUEHD_PASS,},
280 { { "DTS Passthru", "copy:dts", "DTS Passthru", HB_ACODEC_DCA_PASS, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_DTS_PASS, },
281 { { "DTS-HD Passthru", "copy:dtshd", "DTS-HD Passthru", HB_ACODEC_DCA_HD_PASS, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_DTSHD_PASS, },
282 { { "MP3", "mp3", "MP3 (libmp3lame)", HB_ACODEC_LAME, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_MP3, },
283 { { "MP3 Passthru", "copy:mp3", "MP3 Passthru", HB_ACODEC_MP3_PASS, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_MP3_PASS, },
284 { { "Vorbis", "vorbis", "Vorbis (libvorbis)", HB_ACODEC_VORBIS, HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_VORBIS, },
285 { { "FLAC 16-bit", "flac16", "FLAC 16-bit (libavcodec)", HB_ACODEC_FFFLAC, HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_FLAC, },
286 { { "FLAC 24-bit", "flac24", "FLAC 24-bit (libavcodec)", HB_ACODEC_FFFLAC24, HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_FLAC, },
287 { { "FLAC Passthru", "copy:flac", "FLAC Passthru", HB_ACODEC_FLAC_PASS, HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_FLAC_PASS, },
288 { { "Auto Passthru", "copy", "Auto Passthru", HB_ACODEC_AUTO_PASS, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_ACODEC_AUTO_PASS, },
289 };
290 int hb_audio_encoders_count = sizeof(hb_audio_encoders) / sizeof(hb_audio_encoders[0]);
291 static int hb_audio_encoder_is_enabled(int encoder)
292 {
293 if (encoder & HB_ACODEC_PASS_FLAG)
294 {
295 // Passthru encoders are always enabled
296 return 1;
297 }
298 switch (encoder)
299 {
300 #ifdef __APPLE__
301 case HB_ACODEC_CA_AAC:
302 case HB_ACODEC_CA_HAAC:
303 return 1;
304 #endif
305
306 #ifdef USE_LIBAV_AAC
307 case HB_ACODEC_FFAAC:
308 return avcodec_find_encoder_by_name("aac") != NULL;
309 #endif
310
311 case HB_ACODEC_FDK_AAC:
312 case HB_ACODEC_FDK_HAAC:
313 return avcodec_find_encoder_by_name("libfdk_aac") != NULL;
314
315 case HB_ACODEC_AC3:
316 return avcodec_find_encoder(AV_CODEC_ID_AC3) != NULL;
317
318 case HB_ACODEC_FFEAC3:
319 return avcodec_find_encoder(AV_CODEC_ID_EAC3) != NULL;
320
321 case HB_ACODEC_FFFLAC:
322 case HB_ACODEC_FFFLAC24:
323 return avcodec_find_encoder(AV_CODEC_ID_FLAC) != NULL;
324
325 // the following encoders are always enabled
326 case HB_ACODEC_LAME:
327 case HB_ACODEC_VORBIS:
328 return 1;
329
330 default:
331 return 0;
332 }
333 }
334
335 typedef struct
336 {
337 hb_container_t item;
338 hb_container_t *next;
339 int enabled;
340 int gid;
341 } hb_container_internal_t;
342 hb_container_t *hb_containers_first_item = NULL;
343 hb_container_t *hb_containers_last_item = NULL;
344 hb_container_internal_t hb_containers[] =
345 {
346 // legacy muxers, back to HB 0.9.4 whenever possible (disabled)
347 { { "M4V file", "m4v", NULL, "m4v", 0, }, NULL, 0, HB_GID_MUX_MP4, },
348 { { "MP4 file", "mp4", NULL, "mp4", 0, }, NULL, 0, HB_GID_MUX_MP4, },
349 { { "MKV file", "mkv", NULL, "mkv", 0, }, NULL, 0, HB_GID_MUX_MKV, },
350 // actual muxers
351 { { "MPEG-4 (avformat)", "av_mp4", "MPEG-4 (libavformat)", "mp4", HB_MUX_AV_MP4, }, NULL, 1, HB_GID_MUX_MP4, },
352 { { "MPEG-4 (mp4v2)", "mp4v2", "MPEG-4 (libmp4v2)", "mp4", HB_MUX_MP4V2, }, NULL, 1, HB_GID_MUX_MP4, },
353 { { "Matroska (avformat)", "av_mkv", "Matroska (libavformat)", "mkv", HB_MUX_AV_MKV, }, NULL, 1, HB_GID_MUX_MKV, },
354 { { "Matroska (libmkv)", "libmkv", "Matroska (libmkv)", "mkv", HB_MUX_LIBMKV, }, NULL, 1, HB_GID_MUX_MKV, },
355 };
356 int hb_containers_count = sizeof(hb_containers) / sizeof(hb_containers[0]);
357 static int hb_container_is_enabled(int format)
358 {
359 switch (format)
360 {
361 case HB_MUX_AV_MP4:
362 case HB_MUX_AV_MKV:
363 return 1;
364
365 default:
366 return 0;
367 }
368 }
369
370 void hb_common_global_init()
371 {
372 static int common_init_done = 0;
373 if (common_init_done)
374 return;
375
376 int i, j;
377
378 // video framerates
379 for (i = 0; i < hb_video_rates_count; i++)
380 {
381 if (hb_video_rates[i].enabled)
382 {
383 if (hb_video_rates_first_item == NULL)
384 {
385 hb_video_rates_first_item = &hb_video_rates[i].item;
386 }
387 else
388 {
389 ((hb_rate_internal_t*)hb_video_rates_last_item)->next =
390 &hb_video_rates[i].item;
391 }
392 hb_video_rates_last_item = &hb_video_rates[i].item;
393 }
394 }
395 // fallbacks are static for now (no setup required)
396
397 // audio samplerates
398 for (i = 0; i < hb_audio_rates_count; i++)
399 {
400 if (hb_audio_rates[i].enabled)
401 {
402 if (hb_audio_rates_first_item == NULL)
403 {
404 hb_audio_rates_first_item = &hb_audio_rates[i].item;
405 }
406 else
407 {
408 ((hb_rate_internal_t*)hb_audio_rates_last_item)->next =
409 &hb_audio_rates[i].item;
410 }
411 hb_audio_rates_last_item = &hb_audio_rates[i].item;
412 }
413 }
414 // fallbacks are static for now (no setup required)
415
416 // audio bitrates
417 for (i = 0; i < hb_audio_bitrates_count; i++)
418 {
419 if (hb_audio_bitrates[i].enabled)
420 {
421 if (hb_audio_bitrates_first_item == NULL)
422 {
423 hb_audio_bitrates_first_item = &hb_audio_bitrates[i].item;
424 }
425 else
426 {
427 ((hb_rate_internal_t*)hb_audio_bitrates_last_item)->next =
428 &hb_audio_bitrates[i].item;
429 }
430 hb_audio_bitrates_last_item = &hb_audio_bitrates[i].item;
431 }
432 }
433 // fallbacks are static for now (no setup required)
434
435 // audio dithers
436 for (i = 0; i < hb_audio_dithers_count; i++)
437 {
438 if (hb_audio_dithers[i].enabled)
439 {
440 if (hb_audio_dithers_first_item == NULL)
441 {
442 hb_audio_dithers_first_item = &hb_audio_dithers[i].item;
443 }
444 else
445 {
446 ((hb_dither_internal_t*)hb_audio_dithers_last_item)->next =
447 &hb_audio_dithers[i].item;
448 }
449 hb_audio_dithers_last_item = &hb_audio_dithers[i].item;
450 }
451 }
452 // fallbacks are static for now (no setup required)
453
454 // audio mixdowns
455 for (i = 0; i < hb_audio_mixdowns_count; i++)
456 {
457 if (hb_audio_mixdowns[i].enabled)
458 {
459 if (hb_audio_mixdowns_first_item == NULL)
460 {
461 hb_audio_mixdowns_first_item = &hb_audio_mixdowns[i].item;
462 }
463 else
464 {
465 ((hb_mixdown_internal_t*)hb_audio_mixdowns_last_item)->next =
466 &hb_audio_mixdowns[i].item;
467 }
468 hb_audio_mixdowns_last_item = &hb_audio_mixdowns[i].item;
469 }
470 }
471 // fallbacks are static for now (no setup required)
472
473 // video encoders
474 for (i = 0; i < hb_video_encoders_count; i++)
475 {
476 if (hb_video_encoders[i].enabled)
477 {
478 // we still need to check
479 hb_video_encoders[i].enabled =
480 hb_video_encoder_is_enabled(hb_video_encoders[i].item.codec);
481 }
482 if (hb_video_encoders[i].enabled)
483 {
484 if (hb_video_encoders_first_item == NULL)
485 {
486 hb_video_encoders_first_item = &hb_video_encoders[i].item;
487 }
488 else
489 {
490 ((hb_encoder_internal_t*)hb_video_encoders_last_item)->next =
491 &hb_video_encoders[i].item;
492 }
493 hb_video_encoders_last_item = &hb_video_encoders[i].item;
494 }
495 }
496 // setup fallbacks
497 for (i = 0; i < hb_video_encoders_count; i++)
498 {
499 if (!hb_video_encoders[i].enabled)
500 {
501 if ((hb_video_encoders[i].item.codec & HB_VCODEC_MASK) &&
502 (hb_video_encoder_is_enabled(hb_video_encoders[i].item.codec)))
503 {
504 // we have a specific fallback and it's enabled
505 continue;
506 }
507 for (j = 0; j < hb_video_encoders_count; j++)
508 {
509 if (hb_video_encoders[j].enabled &&
510 hb_video_encoders[j].gid == hb_video_encoders[i].gid)
511 {
512 hb_video_encoders[i].item.codec = hb_video_encoders[j].item.codec;
513 break;
514 }
515 }
516 }
517 }
518
519 // audio encoders
520 for (i = 0; i < hb_audio_encoders_count; i++)
521 {
522 if (hb_audio_encoders[i].enabled)
523 {
524 // we still need to check
525 hb_audio_encoders[i].enabled =
526 hb_audio_encoder_is_enabled(hb_audio_encoders[i].item.codec);
527 }
528 if (hb_audio_encoders[i].enabled)
529 {
530 if (hb_audio_encoders_first_item == NULL)
531 {
532 hb_audio_encoders_first_item = &hb_audio_encoders[i].item;
533 }
534 else
535 {
536 ((hb_encoder_internal_t*)hb_audio_encoders_last_item)->next =
537 &hb_audio_encoders[i].item;
538 }
539 hb_audio_encoders_last_item = &hb_audio_encoders[i].item;
540 }
541 }
542 // setup fallbacks
543 for (i = 0; i < hb_audio_encoders_count; i++)
544 {
545 if (!hb_audio_encoders[i].enabled)
546 {
547 if ((hb_audio_encoders[i].item.codec & HB_ACODEC_MASK) &&
548 (hb_audio_encoder_is_enabled(hb_audio_encoders[i].item.codec)))
549 {
550 // we have a specific fallback and it's enabled
551 continue;
552 }
553 for (j = 0; j < hb_audio_encoders_count; j++)
554 {
555 if (hb_audio_encoders[j].enabled &&
556 hb_audio_encoders[j].gid == hb_audio_encoders[i].gid)
557 {
558 hb_audio_encoders[i].item.codec = hb_audio_encoders[j].item.codec;
559 break;
560 }
561 }
562 if ((hb_audio_encoders[i].item.codec & HB_ACODEC_MASK) == 0 &&
563 (hb_audio_encoders[i].gid == HB_GID_ACODEC_AAC_HE))
564 {
565 // try to find an AAC fallback if no HE-AAC encoder is available
566 for (j = 0; j < hb_audio_encoders_count; j++)
567 {
568 if (hb_audio_encoders[j].enabled &&
569 hb_audio_encoders[j].gid == HB_GID_ACODEC_AAC)
570 {
571 hb_audio_encoders[i].item.codec = hb_audio_encoders[j].item.codec;
572 break;
573 }
574 }
575 }
576 }
577 }
578
579 // video containers
580 for (i = 0; i < hb_containers_count; i++)
581 {
582 if (hb_containers[i].enabled)
583 {
584 // we still need to check
585 hb_containers[i].enabled =
586 hb_container_is_enabled(hb_containers[i].item.format);
587 }
588 if (hb_containers[i].enabled)
589 {
590 if (hb_containers_first_item == NULL)
591 {
592 hb_containers_first_item = &hb_containers[i].item;
593 }
594 else
595 {
596 ((hb_container_internal_t*)hb_containers_last_item)->next =
597 &hb_containers[i].item;
598 }
599 hb_containers_last_item = &hb_containers[i].item;
600 }
601 }
602 // setup fallbacks
603 for (i = 0; i < hb_containers_count; i++)
604 {
605 if (!hb_containers[i].enabled)
606 {
607 if ((hb_containers[i].item.format & HB_MUX_MASK) &&
608 (hb_container_is_enabled(hb_containers[i].item.format)))
609 {
610 // we have a specific fallback and it's enabled
611 continue;
612 }
613 for (j = 0; j < hb_containers_count; j++)
614 {
615 if (hb_containers[j].enabled &&
616 hb_containers[j].gid == hb_containers[i].gid)
617 {
618 hb_containers[i].item.format = hb_containers[j].item.format;
619 break;
620 }
621 }
622 }
623 }
624
625 // we're done, yay!
626 common_init_done = 1;
627 }
628
629 int hb_video_framerate_get_from_name(const char *name)
630 {
631 if (name == NULL || *name == '\0')
632 goto fail;
633
634 int i;
635 for (i = 0; i < hb_video_rates_count; i++)
636 {
637 if (!strcasecmp(hb_video_rates[i].item.name, name))
638 {
639 return hb_video_rates[i].item.rate;
640 }
641 }
642
643 fail:
644 return -1;
645 }
646
647 const char* hb_video_framerate_get_name(int framerate)
648 {
649 if (framerate > hb_video_rates_first_item->rate ||
650 framerate < hb_video_rates_last_item ->rate)
651 goto fail;
652
653 const hb_rate_t *video_framerate = NULL;
654 while ((video_framerate = hb_video_framerate_get_next(video_framerate)) != NULL)
655 {
656 if (video_framerate->rate == framerate)
657 {
658 return video_framerate->name;
659 }
660 }
661
662 fail:
663 return NULL;
664 }
665
666 const char* hb_video_framerate_sanitize_name(const char *name)
667 {
668 return hb_video_framerate_get_name(hb_video_framerate_get_from_name(name));
669 }
670
671 const hb_rate_t* hb_video_framerate_get_next(const hb_rate_t *last)
672 {
673 if (last == NULL)
674 {
675 return hb_video_rates_first_item;
676 }
677 return ((hb_rate_internal_t*)last)->next;
678 }
679
680 int hb_audio_samplerate_get_best(uint32_t codec, int samplerate, int *sr_shift)
681 {
682 int best_samplerate;
683 if (samplerate < 32000 && (codec == HB_ACODEC_AC3 ||
684 codec == HB_ACODEC_FFEAC3 ||
685 codec == HB_ACODEC_CA_HAAC))
686 {
687 // ca_haac can't do samplerates < 32 kHz
688 // libav's E-AC-3 encoder can't do samplerates < 32 kHz
689 // AC-3 < 32 kHz suffers from poor hardware compatibility
690 best_samplerate = 32000;
691 }
692 else if (samplerate < 16000 && codec == HB_ACODEC_FDK_HAAC)
693 {
694 // fdk_haac can't do samplerates < 16 kHz
695 best_samplerate = 16000;
696 }
697 else
698 {
699 best_samplerate = hb_audio_rates_first_item->rate;
700 const hb_rate_t *audio_samplerate = NULL;
701 while ((audio_samplerate = hb_audio_samplerate_get_next(audio_samplerate)) != NULL)
702 {
703 if (samplerate == audio_samplerate->rate)
704 {
705 // valid samplerate
706 best_samplerate = audio_samplerate->rate;
707 break;
708 }
709 if (samplerate > audio_samplerate->rate)
710 {
711 // samplerates are sanitized downwards
712 best_samplerate = audio_samplerate->rate;
713 }
714 }
715 }
716 if (sr_shift != NULL)
717 {
718 /* sr_shift: 0 -> 48000, 44100, 32000 Hz
719 * 1 -> 24000, 22050, 16000 Hz
720 * 2 -> 12000, 11025, 8000 Hz
721 *
722 * also, since samplerates are sanitized downwards:
723 *
724 * (samplerate < 32000) implies (samplerate <= 24000)
725 */
726 *sr_shift = ((best_samplerate < 16000) ? 2 :
727 (best_samplerate < 32000) ? 1 : 0);
728 }
729 return best_samplerate;
730 }
731
732 int hb_audio_samplerate_get_from_name(const char *name)
733 {
734 if (name == NULL || *name == '\0')
735 goto fail;
736
737 int i;
738 for (i = 0; i < hb_audio_rates_count; i++)
739 {
740 if (!strcasecmp(hb_audio_rates[i].item.name, name))
741 {
742 return hb_audio_rates[i].item.rate;
743 }
744 }
745
746 // maybe the samplerate was specified in Hz
747 i = atoi(name);
748 if (i >= hb_audio_rates_first_item->rate &&
749 i <= hb_audio_rates_last_item ->rate)
750 {
751 return hb_audio_samplerate_get_best(0, i, NULL);
752 }
753
754 fail:
755 return -1;
756 }
757
758 const char* hb_audio_samplerate_get_name(int samplerate)
759 {
760 if (samplerate < hb_audio_rates_first_item->rate ||
761 samplerate > hb_audio_rates_last_item ->rate)
762 goto fail;
763
764 const hb_rate_t *audio_samplerate = NULL;
765 while ((audio_samplerate = hb_audio_samplerate_get_next(audio_samplerate)) != NULL)
766 {
767 if (audio_samplerate->rate == samplerate)
768 {
769 return audio_samplerate->name;
770 }
771 }
772
773 fail:
774 return NULL;
775 }
776
777 const hb_rate_t* hb_audio_samplerate_get_next(const hb_rate_t *last)
778 {
779 if (last == NULL)
780 {
781 return hb_audio_rates_first_item;
782 }
783 return ((hb_rate_internal_t*)last)->next;
784 }
785
786 // Given an input bitrate, find closest match in the set of allowed bitrates
787 static int hb_audio_bitrate_find_closest(int bitrate)
788 {
789 // Check if bitrate mode was disabled
790 if (bitrate <= 0)
791 return bitrate;
792
793 int closest_bitrate = hb_audio_bitrates_first_item->rate;
794 const hb_rate_t *audio_bitrate = NULL;
795 while ((audio_bitrate = hb_audio_bitrate_get_next(audio_bitrate)) != NULL)
796 {
797 if (bitrate == audio_bitrate->rate)
798 {
799 // valid bitrate
800 closest_bitrate = audio_bitrate->rate;
801 break;
802 }
803 if (bitrate > audio_bitrate->rate)
804 {
805 // bitrates are sanitized downwards
806 closest_bitrate = audio_bitrate->rate;
807 }
808 }
809 return closest_bitrate;
810 }
811
812 // Given an input bitrate, sanitize it.
813 // Check low and high limits and make sure it is in the set of allowed bitrates.
814 int hb_audio_bitrate_get_best(uint32_t codec, int bitrate, int samplerate,
815 int mixdown)
816 {
817 int low, high;
818 hb_audio_bitrate_get_limits(codec, samplerate, mixdown, &low, &high);
819 if (bitrate > high)
820 bitrate = high;
821 if (bitrate < low)
822 bitrate = low;
823 return hb_audio_bitrate_find_closest(bitrate);
824 }
825
826 // Get the default bitrate for a given codec/samplerate/mixdown triplet.
827 int hb_audio_bitrate_get_default(uint32_t codec, int samplerate, int mixdown)
828 {
829 if ((codec & HB_ACODEC_PASS_FLAG) || !(codec & HB_ACODEC_MASK))
830 goto fail;
831
832 int bitrate, nchannels, sr_shift;
833 /* full-bandwidth channels, sr_shift */
834 nchannels = (hb_mixdown_get_discrete_channel_count(mixdown) -
835 hb_mixdown_get_low_freq_channel_count(mixdown));
836 hb_audio_samplerate_get_best(codec, samplerate, &sr_shift);
837
838 switch (codec)
839 {
840 case HB_ACODEC_FFFLAC:
841 case HB_ACODEC_FFFLAC24:
842 goto fail;
843
844 // 96, 224, 640 Kbps
845 case HB_ACODEC_AC3:
846 bitrate = (nchannels * 128) - (32 * (nchannels < 5));
847 break;
848
849 // Our E-AC-3 encoder is pretty similar to our AC-3 encoder but it does
850 // allow for higher bitrates, should some users want a bit more quality
851 // at the expense of compression efficiency - still, let's remain
852 // compatible with passthru over S/PDIF by default: 384, 768, 1536 Kbps
853 case HB_ACODEC_FFEAC3:
854 bitrate = (nchannels * 384) - (128 * (nchannels - 2) * (nchannels > 2));
855 break;
856
857 case HB_ACODEC_CA_HAAC:
858 case HB_ACODEC_FDK_HAAC:
859 bitrate = nchannels * 32;
860 break;
861
862 default:
863 bitrate = nchannels * 80;
864 break;
865 }
866 // sample_rate adjustment
867 bitrate >>= sr_shift;
868 return hb_audio_bitrate_get_best(codec, bitrate, samplerate, mixdown);
869
870 fail:
871 return -1;
872 }
873
874 /* Get the bitrate low and high limits for a codec/samplerate/mixdown triplet.
875 *
876 * Encoder 1.0 channel 2.0 channels 5.1 channels 6.1 channels 7.1 channels
877 * --------------------------------------------------------------------------------------
878 *
879 * ffaac
880 * -----
881 * supported samplerates: 8 - 48 kHz
882 * libavcodec/aacenc.c defines a maximum bitrate:
883 * -> 6144 * samplerate / 1024 bps (per channel, incl. LFE).
884 * But output bitrates don't go as high as the theoretical maximums:
885 * 12 kHz 61 (72) 123 (144)
886 * 24 kHz 121 (144) 242 (288)
887 * 48 kHz 236 (288) 472 (576)
888 * Also, ffaac isn't a great encoder, so you don't want to allow too low a bitrate.
889 * Limits: minimum of 32 Kbps per channel
890 * maximum of 192 Kbps per channel at 32 kHz, adjusted for sr_shift
891 * maximum of 256 Kbps per channel at 44.1-48 kHz, adjusted for sr_shift
892 *
893 * vorbis
894 * ------
895 * supported samplerates: 8 - 48 kHz
896 * lib/modes/setup_*.h provides a range of allowed bitrates for various configurations.
897 * for each samplerate, the highest minimums and lowest maximums are:
898 * 8 kHz Minimum 8 Kbps, maximum 32 Kbps (per channel, incl. LFE).
899 * 12 kHz Minimum 14 Kbps, maximum 44 Kbps (per channel, incl. LFE).
900 * 16 kHz Minimum 16 Kbps, maximum 86 Kbps (per channel, incl. LFE).
901 * 24 kHz Minimum 22 Kbps, maximum 86 Kbps (per channel, incl. LFE).
902 * 32 kHz Minimum 26 Kbps, maximum 190 Kbps (per channel, incl. LFE).
903 * 48 kHz Minimum 28 Kbps, maximum 240 Kbps (per channel, incl. LFE).
904 * Limits: minimum of 14/22/28 Kbps per channel (8-12, 16-24, 32-48 kHz)
905 * maximum of 32/86/190/240 Kbps per channel (8-12, 16-24, 32, 44.1-48 kHz)
906 *
907 * lame
908 * ----
909 * supported samplerates: 8 - 48 kHz
910 * lame_init_params() allows the following bitrates:
911 * 12 kHz Minimum 8 Kbps, maximum 64 Kbps
912 * 24 kHz Minimum 8 Kbps, maximum 160 Kbps
913 * 48 kHz Minimum 32 Kbps, maximum 320 Kbps
914 * Limits: minimum of 8/8/32 Kbps (8-12, 16-24, 32-48 kHz)
915 * maximum of 64/160/320 Kbps (8-12, 16-24, 32-48 kHz)
916 *
917 * ffac3
918 * -----
919 * supported samplerates: 32 - 48 kHz (< 32 kHz disabled for compatibility reasons)
920 * Dolby's encoder has a min. of 224 Kbps for 5 full-bandwidth channels (5.0, 5.1)
921 * The maximum AC3 bitrate is 640 Kbps
922 * Limits: minimum of 224/5 Kbps per full-bandwidth channel, maximum of 640 Kbps
923 *
924 * ffeac3
925 * ------
926 * supported samplerates: 32 - 48 kHz (< 32 kHz not supported by libav encoder)
927 * Dolby's encoder has a min. of 224 Kbps for 5 full-bandwidth channels (5.0, 5.1)
928 * The maximum bitrate is 128 bits per sample per second
929 * Limits: minimum of 224/5 Kbps per full-bandwidth channel
930 * maximum of 128/1000 * samplerate Kbps
931 *
932 * ca_aac
933 * ------
934 * supported samplerates: 8 - 48 kHz
935 * Core Audio API provides a range of allowed bitrates:
936 * 8 kHz 8 - 24 16 - 48 40 - 112 48 - 144 56 - 160
937 * 12 kHz 12 - 32 24 - 64 64 - 160 72 - 192 96 - 224
938 * 16 kHz 12 - 48 24 - 96 64 - 224 72 - 288 96 - 320
939 * 24 kHz 16 - 64 32 - 128 80 - 320 96 - 384 112 - 448
940 * 32 kHz 24 - 96 48 - 192 128 - 448 144 - 576 192 - 640
941 * 48 kHz 32 - 256 64 - 320 160 - 768 192 - 960 224 - 960
942 * Limits:
943 * 8 kHz -> minimum of 8 Kbps and maximum of 24 Kbps per full-bandwidth channel
944 * 12 kHz -> minimum of 12 Kbps and maximum of 32 Kbps per full-bandwidth channel
945 * 16 kHz -> minimum of 12 Kbps and maximum of 48 Kbps per full-bandwidth channel
946 * 24 kHz -> minimum of 16 Kbps and maximum of 64 Kbps per full-bandwidth channel
947 * 32 kHz -> minimum of 24 Kbps and maximum of 96 Kbps per full-bandwidth channel
948 * 48 kHz -> minimum of 32 Kbps and maximum of 160 Kbps per full-bandwidth channel
949 * 48 kHz -> maximum of +96 Kbps for Mono
950 * Note: encCoreAudioInit() will sanitize any mistake made here.
951 *
952 * ca_haac
953 * -------
954 * supported samplerates: 32 - 48 kHz
955 * Core Audio API provides a range of allowed bitrates:
956 * 32 kHz 12 - 40 24 - 80 64 - 192 N/A 96 - 256
957 * 48 kHz 16 - 40 32 - 80 80 - 192 N/A 112 - 256
958 * Limits: minimum of 12 Kbps per full-bandwidth channel (<= 32 kHz)
959 * minimum of 16 Kbps per full-bandwidth channel ( > 32 kHz)
960 * maximum of 40 Kbps per full-bandwidth channel
961 * Note: encCoreAudioInit() will sanitize any mistake made here.
962 *
963 * fdk_aac
964 * -------
965 * supported samplerates: 8 - 48 kHz
966 * libfdk limits the bitrate to the following values:
967 * 8 kHz 48 96 240
968 * 12 kHz 72 144 360
969 * 16 kHz 96 192 480
970 * 24 kHz 144 288 720
971 * 32 kHz 192 384 960
972 * 48 kHz 288 576 1440
973 * Limits: minimum of samplerate * 2/3 Kbps per full-bandwidth channel (see ca_aac)
974 * maximum of samplerate * 6.0 Kbps per full-bandwidth channel
975 *
976 * fdk_haac
977 * --------
978 * supported samplerates: 16 - 48 kHz
979 * libfdk limits the bitrate to the following values:
980 * 16 kHz 8 - 48 16 - 96 45 - 199
981 * 24 kHz 8 - 63 16 - 127 45 - 266
982 * 32 kHz 8 - 63 16 - 127 45 - 266
983 * 48 kHz 12 - 63 16 - 127 50 - 266
984 * Limits: minimum of 12 Kbps per full-bandwidth channel (<= 32 kHz) (see ca_haac)
985 * minimum of 16 Kbps per full-bandwidth channel ( > 32 kHz) (see ca_haac)
986 * maximum of 48, 96 or 192 Kbps (1.0, 2.0, 5.1) (<= 16 kHz)
987 * maximum of 64, 128 or 256 Kbps (1.0, 2.0, 5.1) ( > 16 kHz)
988 */
989 void hb_audio_bitrate_get_limits(uint32_t codec, int samplerate, int mixdown,
990 int *low, int *high)
991 {
992 /*
993 * samplerate == 0 means "auto" (same as source) and the UIs know the source
994 * samplerate -- except where there isn't a source (audio defaults panel);
995 * but we have enough info to return the global bitrate limits for this
996 * mixdown, since the first/last samplerate are known to us and non-zero.
997 */
998 if (samplerate == 0)
999 {
1000 int dummy;
1001 hb_audio_bitrate_get_limits(codec, hb_audio_rates_first_item->rate, mixdown, low, &dummy);
1002 hb_audio_bitrate_get_limits(codec, hb_audio_rates_last_item->rate, mixdown, &dummy, high);
1003 return;
1004 }
1005
1006 /* samplerate, sr_shift */
1007 int sr_shift;
1008 samplerate = hb_audio_samplerate_get_best(codec, samplerate, &sr_shift);
1009
1010 /* LFE, full-bandwidth channels */
1011 int lfe_count, nchannels;
1012 lfe_count = hb_mixdown_get_low_freq_channel_count(mixdown);
1013 nchannels = hb_mixdown_get_discrete_channel_count(mixdown) - lfe_count;
1014
1015 switch (codec)
1016 {
1017 // Bitrates don't apply to "lossless" audio
1018 case HB_ACODEC_FFFLAC:
1019 case HB_ACODEC_FFFLAC24:
1020 *low = *high = -1;
1021 return;
1022
1023 case HB_ACODEC_AC3:
1024 *low = 224 * nchannels / 5;
1025 *high = 640;
1026 break;
1027
1028 case HB_ACODEC_FFEAC3:
1029 *low = 224 * nchannels / 5;
1030 *high = 128 * samplerate / 1000;
1031 break;
1032
1033 case HB_ACODEC_CA_AAC:
1034 {
1035 switch (samplerate)
1036 {
1037 case 8000:
1038 *low = nchannels * 8;
1039 *high = nchannels * 24;
1040 break;
1041
1042 case 11025:
1043 case 12000:
1044 *low = nchannels * 12;
1045 *high = nchannels * 32;
1046 break;
1047
1048 case 16000:
1049 *low = nchannels * 12;
1050 *high = nchannels * 48;
1051 break;
1052
1053 case 22050:
1054 case 24000:
1055 *low = nchannels * 16;
1056 *high = nchannels * 64;
1057 break;
1058
1059 case 32000:
1060 *low = nchannels * 24;
1061 *high = nchannels * 96;
1062 break;
1063
1064 case 44100:
1065 case 48000:
1066 default:
1067 *low = nchannels * 32;
1068 *high = nchannels * (160 + (96 * (nchannels == 1)));
1069 break;
1070 } break;
1071 }
1072
1073 case HB_ACODEC_CA_HAAC:
1074 *low = nchannels * (12 + (4 * (samplerate >= 44100)));
1075 *high = nchannels * 40;
1076 break;
1077
1078 case HB_ACODEC_FDK_AAC:
1079 *low = nchannels * samplerate * 2 / 3000;
1080 *high = nchannels * samplerate * 6 / 1000;
1081 break;
1082
1083 case HB_ACODEC_FDK_HAAC:
1084 *low = (nchannels * (12 + (4 * (samplerate >= 44100))));
1085 *high = (nchannels - (nchannels > 2)) * (48 +
1086 (16 *
1087 (samplerate >= 22050)));
1088 break;
1089
1090 case HB_ACODEC_FFAAC:
1091 *low = ((nchannels + lfe_count) * 32);
1092 *high = ((nchannels + lfe_count) *
1093 ((192 + (64 * ((samplerate << sr_shift) >= 44100)))
1094 >> sr_shift));
1095 break;
1096
1097 case HB_ACODEC_LAME:
1098 *low = 8 + (24 * (sr_shift < 1));
1099 *high = 64 + (96 * (sr_shift < 2)) + (160 * (sr_shift < 1));
1100 break;
1101
1102 case HB_ACODEC_VORBIS:
1103 *low = (nchannels + lfe_count) * (14 +
1104 (8 * (sr_shift < 2)) +
1105 (6 * (sr_shift < 1)));
1106 *high = (nchannels + lfe_count) * (32 +
1107 ( 54 * (sr_shift < 2)) +
1108 (104 * (sr_shift < 1)) +
1109 ( 50 * (samplerate >= 44100)));
1110 break;
1111
1112 // Bitrates don't apply to passthrough audio, but may apply if we
1113 // fall back to an encoder when the source can't be passed through.
1114 default:
1115 *low = hb_audio_bitrates_first_item->rate;
1116 *high = hb_audio_bitrates_last_item ->rate;
1117 break;
1118 }
1119
1120 // sanitize max. bitrate
1121 if (*high < hb_audio_bitrates_first_item->rate)
1122 *high = hb_audio_bitrates_first_item->rate;
1123 if (*high > hb_audio_bitrates_last_item ->rate)
1124 *high = hb_audio_bitrates_last_item ->rate;
1125 }
1126
1127 const hb_rate_t* hb_audio_bitrate_get_next(const hb_rate_t *last)
1128 {
1129 if (last == NULL)
1130 {
1131 return hb_audio_bitrates_first_item;
1132 }
1133 return ((hb_rate_internal_t*)last)->next;
1134 }
1135
1136 // Get limits and hints for the UIs.
1137 //
1138 // granularity sets the minimum step increments that should be used
1139 // (it's ok to round up to some nice multiple if you like)
1140 //
1141 // direction says whether 'low' limit is highest or lowest
1142 // quality (direction 0 == lowest value is worst quality)
1143 void hb_video_quality_get_limits(uint32_t codec, float *low, float *high,
1144 float *granularity, int *direction)
1145 {
1146 #ifdef USE_QSV
1147 if (codec & HB_VCODEC_QSV_MASK)
1148 {
1149 return hb_qsv_video_quality_get_limits(codec, low, high, granularity,
1150 direction);
1151 }
1152 #endif
1153
1154 switch (codec)
1155 {
1156 case HB_VCODEC_X264:
1157 #ifdef USE_X265
1158 case HB_VCODEC_X265:
1159 #endif
1160 *direction = 1;
1161 *granularity = 0.1;
1162 *low = 0.;
1163 *high = 51.;
1164 break;
1165
1166 case HB_VCODEC_THEORA:
1167 *direction = 0;
1168 *granularity = 1.;
1169 *low = 0.;
1170 *high = 63.;
1171 break;
1172
1173 case HB_VCODEC_FFMPEG_VP8:
1174 *direction = 1;
1175 *granularity = 1.;
1176 *low = 0.;
1177 *high = 63.;
1178 break;
1179
1180 case HB_VCODEC_FFMPEG_MPEG2:
1181 case HB_VCODEC_FFMPEG_MPEG4:
1182 default:
1183 *direction = 1;
1184 *granularity = 1.;
1185 *low = 1.;
1186 *high = 31.;
1187 break;
1188 }
1189 }
1190
1191 const char* hb_video_quality_get_name(uint32_t codec)
1192 {
1193 #ifdef USE_QSV
1194 if (codec & HB_VCODEC_QSV_MASK)
1195 {
1196 return hb_qsv_video_quality_get_name(codec);
1197 }
1198 #endif
1199
1200 switch (codec)
1201 {
1202 case HB_VCODEC_X264:
1203 #ifdef USE_X265
1204 case HB_VCODEC_X265:
1205 #endif
1206 return "RF";
1207
1208 case HB_VCODEC_FFMPEG_VP8:
1209 return "CQ";
1210
1211 default:
1212 return "QP";
1213 }
1214 }
1215
1216 const char* const* hb_video_encoder_get_presets(int encoder)
1217 {
1218 #ifdef USE_QSV
1219 if (encoder & HB_VCODEC_QSV_MASK)
1220 {
1221 return hb_qsv_preset_get_names();
1222 }
1223 #endif
1224
1225 switch (encoder)
1226 {
1227 case HB_VCODEC_X264:
1228 return x264_preset_names;
1229
1230 #ifdef USE_X265
1231 case HB_VCODEC_X265:
1232 return x265_preset_names;
1233 #endif
1234 default:
1235 return NULL;
1236 }
1237 }
1238
1239 const char* const* hb_video_encoder_get_tunes(int encoder)
1240 {
1241 switch (encoder)
1242 {
1243 case HB_VCODEC_X264:
1244 return x264_tune_names;
1245
1246 #ifdef USE_X265
1247 case HB_VCODEC_X265:
1248 return x265_tune_names;
1249 #endif
1250 default:
1251 return NULL;
1252 }
1253 }
1254
1255 const char* const* hb_video_encoder_get_profiles(int encoder)
1256 {
1257 #ifdef USE_QSV
1258 if (encoder & HB_VCODEC_QSV_MASK)
1259 {
1260 return hb_qsv_profile_get_names(encoder);
1261 }
1262 #endif
1263
1264 switch (encoder)
1265 {
1266 case HB_VCODEC_X264:
1267 return hb_h264_profile_names;
1268
1269 case HB_VCODEC_X265:
1270 return hb_h265_profile_names;
1271
1272 default:
1273 return NULL;
1274 }
1275 }
1276
1277 const char* const* hb_video_encoder_get_levels(int encoder)
1278 {
1279 #ifdef USE_QSV
1280 if (encoder & HB_VCODEC_QSV_MASK)
1281 {
1282 return hb_qsv_level_get_names(encoder);
1283 }
1284 #endif
1285
1286 switch (encoder)
1287 {
1288 case HB_VCODEC_X264:
1289 return hb_h264_level_names;
1290
1291 default:
1292 return NULL;
1293 }
1294 }
1295
1296 // Get limits and hints for the UIs.
1297 //
1298 // granularity sets the minimum step increments that should be used
1299 // (it's ok to round up to some nice multiple if you like)
1300 //
1301 // direction says whether 'low' limit is highest or lowest
1302 // quality (direction 0 == lowest value is worst quality)
1303 void hb_audio_quality_get_limits(uint32_t codec, float *low, float *high,
1304 float *granularity, int *direction)
1305 {
1306 switch (codec)
1307 {
1308 case HB_ACODEC_FFAAC:
1309 *direction = 0;
1310 *granularity = 1.;
1311 *low = 1.;
1312 *high = 10.;
1313 break;
1314
1315 case HB_ACODEC_FDK_HAAC:
1316 case HB_ACODEC_FDK_AAC:
1317 *direction = 0;
1318 *granularity = 1.;
1319 *low = 1.;
1320 *high = 5.;
1321 break;
1322
1323 case HB_ACODEC_LAME:
1324 *direction = 1;
1325 *granularity = 0.5;
1326 *low = 0.;
1327 *high = 10.;
1328 break;
1329
1330 case HB_ACODEC_VORBIS:
1331 *direction = 0;
1332 *granularity = 0.5;
1333 *low = -2.;
1334 *high = 10.;
1335 break;
1336
1337 case HB_ACODEC_CA_AAC:
1338 *direction = 0;
1339 *granularity = 9.;
1340 *low = 1.;
1341 *high = 127.;
1342 break;
1343
1344 default:
1345 *direction = 0;
1346 *granularity = 1.;
1347 *low = *high = HB_INVALID_AUDIO_QUALITY;
1348 break;
1349 }
1350 }
1351
1352 float hb_audio_quality_get_best(uint32_t codec, float quality)
1353 {
1354 int direction;
1355 float low, high, granularity;
1356 hb_audio_quality_get_limits(codec, &low, &high, &granularity, &direction);
1357 if (quality > high)
1358 quality = high;
1359 if (quality < low)
1360 quality = low;
1361 return quality;
1362 }
1363
1364 float hb_audio_quality_get_default(uint32_t codec)
1365 {
1366 switch (codec)
1367 {
1368 case HB_ACODEC_FFAAC:
1369 return 5.;
1370
1371 case HB_ACODEC_FDK_HAAC:
1372 case HB_ACODEC_FDK_AAC:
1373 return 3.;
1374
1375 case HB_ACODEC_LAME:
1376 return 2.;
1377
1378 case HB_ACODEC_VORBIS:
1379 return 5.;
1380
1381 case HB_ACODEC_CA_AAC:
1382 return 91.;
1383
1384 default:
1385 return HB_INVALID_AUDIO_QUALITY;
1386 }
1387 }
1388
1389 // Get limits and hints for the UIs.
1390 //
1391 // granularity sets the minimum step increments that should be used
1392 // (it's ok to round up to some nice multiple if you like)
1393 //
1394 // direction says whether 'low' limit is highest or lowest
1395 // compression level (direction 0 == lowest value is worst compression level)
1396 void hb_audio_compression_get_limits(uint32_t codec, float *low, float *high,
1397 float *granularity, int *direction)
1398 {
1399 switch (codec)
1400 {
1401 case HB_ACODEC_FFFLAC:
1402 case HB_ACODEC_FFFLAC24:
1403 *direction = 0;
1404 *granularity = 1.;
1405 *high = 12.;
1406 *low = 0.;
1407 break;
1408
1409 case HB_ACODEC_LAME:
1410 *direction = 1;
1411 *granularity = 1.;
1412 *high = 9.;
1413 *low = 0.;
1414 break;
1415
1416 default:
1417 *direction = 0;
1418 *granularity = 1.;
1419 *low = *high = -1.;
1420 break;
1421 }
1422 }
1423
1424 float hb_audio_compression_get_best(uint32_t codec, float compression)
1425 {
1426 int direction;
1427 float low, high, granularity;
1428 hb_audio_compression_get_limits(codec, &low, &high, &granularity, &direction);
1429 if( compression > high )
1430 compression = high;
1431 if( compression < low )
1432 compression = low;
1433 return compression;
1434 }
1435
1436 float hb_audio_compression_get_default(uint32_t codec)
1437 {
1438 switch (codec)
1439 {
1440 case HB_ACODEC_FFFLAC:
1441 case HB_ACODEC_FFFLAC24:
1442 return 5.;
1443
1444 case HB_ACODEC_LAME:
1445 return 2.;
1446
1447 default:
1448 return -1.;
1449 }
1450 }
1451
1452 int hb_audio_dither_get_default()
1453 {
1454 // "auto"
1455 return hb_audio_dithers_first_item->method;
1456 }
1457
1458 int hb_audio_dither_get_default_method()
1459 {
1460 /*
1461 * input could be s16 (possibly already dithered) converted to flt, so
1462 * let's use a "low-risk" dither algorithm (standard triangular).
1463 */
1464 return AV_RESAMPLE_DITHER_TRIANGULAR;
1465 }
1466
1467 int hb_audio_dither_is_supported(uint32_t codec)
1468 {
1469 // encoder's input sample format must be s16(p)
1470 switch (codec)
1471 {
1472 case HB_ACODEC_FFFLAC:
1473 case HB_ACODEC_FDK_AAC:
1474 case HB_ACODEC_FDK_HAAC:
1475 return 1;
1476
1477 default:
1478 return 0;
1479 }
1480 }
1481
1482 int hb_audio_dither_get_from_name(const char *name)
1483 {
1484 if (name == NULL || *name == '\0')
1485 goto fail;
1486
1487 int i;
1488 for ( i = 0; i < hb_audio_dithers_count; i++)
1489 {
1490 if (!strcasecmp(hb_audio_dithers[i].item.short_name, name) ||
1491 !strcasecmp(hb_audio_dithers[i].item.description, name))
1492 {
1493 return hb_audio_dithers[i].item.method;
1494 }
1495 }
1496
1497 fail:
1498 return hb_audio_dither_get_default();
1499 }
1500
1501 const char* hb_audio_dither_get_description(int method)
1502 {
1503 if (method < hb_audio_dithers_first_item->method ||
1504 method > hb_audio_dithers_last_item ->method)
1505 goto fail;
1506
1507 const hb_dither_t *audio_dither = NULL;
1508 while ((audio_dither = hb_audio_dither_get_next(audio_dither)) != NULL)
1509 {
1510 if (audio_dither->method == method)
1511 {
1512 return audio_dither->description;
1513 }
1514 }
1515
1516 fail:
1517 return NULL;
1518 }
1519
1520 const hb_dither_t* hb_audio_dither_get_next(const hb_dither_t *last)
1521 {
1522 if (last == NULL)
1523 {
1524 return hb_audio_dithers_first_item;
1525 }
1526 return ((hb_dither_internal_t*)last)->next;
1527 }
1528
1529 int hb_mixdown_is_supported(int mixdown, uint32_t codec, uint64_t layout)
1530 {
1531 return (hb_mixdown_has_codec_support(mixdown, codec) &&
1532 hb_mixdown_has_remix_support(mixdown, layout));
1533 }
1534
1535 int hb_mixdown_has_codec_support(int mixdown, uint32_t codec)
1536 {
1537 // Passthru, only "None" mixdown is supported
1538 if (codec & HB_ACODEC_PASS_FLAG)
1539 return (mixdown == HB_AMIXDOWN_NONE);
1540
1541 // Not passthru, "None" mixdown never supported
1542 if (mixdown == HB_AMIXDOWN_NONE)
1543 return 0;
1544
1545 switch (codec)
1546 {
1547 case HB_ACODEC_VORBIS:
1548 case HB_ACODEC_FFFLAC:
1549 case HB_ACODEC_FFFLAC24:
1550 return (mixdown <= HB_AMIXDOWN_7POINT1);
1551
1552 case HB_ACODEC_LAME:
1553 return (mixdown <= HB_AMIXDOWN_DOLBYPLII);
1554
1555 case HB_ACODEC_CA_AAC:
1556 case HB_ACODEC_CA_HAAC:
1557 return ((mixdown <= HB_AMIXDOWN_5POINT1) ||
1558 (mixdown == HB_AMIXDOWN_5_2_LFE));
1559
1560 default:
1561 return (mixdown <= HB_AMIXDOWN_5POINT1);
1562 }
1563 }
1564
1565 int hb_mixdown_has_remix_support(int mixdown, uint64_t layout)
1566 {
1567 /*
1568 * Where there isn't a source (e.g. audio defaults panel), we have no input
1569 * layout; assume remix support, as the mixdown will be sanitized later on.
1570 */
1571 if (!layout)
1572 {
1573 return 1;
1574 }
1575 switch (mixdown)
1576 {
1577 // stereo + front left/right of center
1578 case HB_AMIXDOWN_5_2_LFE:
1579 return ((layout & AV_CH_FRONT_LEFT_OF_CENTER) &&
1580 (layout & AV_CH_FRONT_RIGHT_OF_CENTER) &&
1581 (layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO);
1582
1583 // 7.0 or better
1584 case HB_AMIXDOWN_7POINT1:
1585 return ((layout & AV_CH_LAYOUT_7POINT0) == AV_CH_LAYOUT_7POINT0);
1586
1587 // 6.0 or better
1588 case HB_AMIXDOWN_6POINT1:
1589 return ((layout & AV_CH_LAYOUT_7POINT0) == AV_CH_LAYOUT_7POINT0 ||
1590 (layout & AV_CH_LAYOUT_6POINT0) == AV_CH_LAYOUT_6POINT0 ||
1591 (layout & AV_CH_LAYOUT_HEXAGONAL) == AV_CH_LAYOUT_HEXAGONAL);
1592
1593 // stereo + either of front center, side or back left/right, back center
1594 case HB_AMIXDOWN_5POINT1:
1595 return ((layout & AV_CH_LAYOUT_2_1) == AV_CH_LAYOUT_2_1 ||
1596 (layout & AV_CH_LAYOUT_2_2) == AV_CH_LAYOUT_2_2 ||
1597 (layout & AV_CH_LAYOUT_QUAD) == AV_CH_LAYOUT_QUAD ||
1598 (layout & AV_CH_LAYOUT_SURROUND) == AV_CH_LAYOUT_SURROUND);
1599
1600 // stereo + either of side or back left/right, back center
1601 // also, allow Dolby Surrounbd output if the input is already Dolby
1602 case HB_AMIXDOWN_DOLBY:
1603 case HB_AMIXDOWN_DOLBYPLII:
1604 return ((layout & AV_CH_LAYOUT_2_1) == AV_CH_LAYOUT_2_1 ||
1605 (layout & AV_CH_LAYOUT_2_2) == AV_CH_LAYOUT_2_2 ||
1606 (layout & AV_CH_LAYOUT_QUAD) == AV_CH_LAYOUT_QUAD ||
1607 (layout == AV_CH_LAYOUT_STEREO_DOWNMIX &&
1608 mixdown == HB_AMIXDOWN_DOLBY));
1609
1610 // more than 1 channel
1611 case HB_AMIXDOWN_STEREO:
1612 return (av_get_channel_layout_nb_channels(layout) > 1);
1613
1614 // regular stereo (not Dolby)
1615 case HB_AMIXDOWN_LEFT:
1616 case HB_AMIXDOWN_RIGHT:
1617 return (layout == AV_CH_LAYOUT_STEREO);
1618
1619 // mono remix always supported
1620 // HB_AMIXDOWN_NONE always supported (for Passthru)
1621 case HB_AMIXDOWN_MONO:
1622 case HB_AMIXDOWN_NONE:
1623 return 1;
1624
1625 // unknown mixdown, should never happen
1626 default:
1627 return 0;
1628 }
1629 }
1630
1631 int hb_mixdown_get_discrete_channel_count(int amixdown)
1632 {
1633 switch (amixdown)
1634 {
1635 case HB_AMIXDOWN_5_2_LFE:
1636 case HB_AMIXDOWN_7POINT1:
1637 return 8;
1638
1639 case HB_AMIXDOWN_6POINT1:
1640 return 7;
1641
1642 case HB_AMIXDOWN_5POINT1:
1643 return 6;
1644
1645 case HB_AMIXDOWN_MONO:
1646 case HB_AMIXDOWN_LEFT:
1647 case HB_AMIXDOWN_RIGHT:
1648 return 1;
1649
1650 case HB_AMIXDOWN_NONE:
1651 return 0;
1652
1653 default:
1654 return 2;
1655 }
1656 }
1657
1658 int hb_mixdown_get_low_freq_channel_count(int amixdown)
1659 {
1660 switch (amixdown)
1661 {
1662 case HB_AMIXDOWN_5POINT1:
1663 case HB_AMIXDOWN_6POINT1:
1664 case HB_AMIXDOWN_7POINT1:
1665 case HB_AMIXDOWN_5_2_LFE:
1666 return 1;
1667
1668 default:
1669 return 0;
1670 }
1671 }
1672
1673 int hb_mixdown_get_best(uint32_t codec, uint64_t layout, int mixdown)
1674 {
1675 // Passthru, only "None" mixdown is supported
1676 if (codec & HB_ACODEC_PASS_FLAG)
1677 return HB_AMIXDOWN_NONE;
1678
1679 int best_mixdown = HB_INVALID_AMIXDOWN;
1680 const hb_mixdown_t *audio_mixdown = hb_mixdown_get_next(NULL);
1681 // test all non-None mixdowns while the value is <= the requested mixdown
1682 // HB_INVALID_AMIXDOWN means the highest supported mixdown was requested
1683 while ((audio_mixdown = hb_mixdown_get_next(audio_mixdown)) != NULL)
1684 {
1685 if ((mixdown == HB_INVALID_AMIXDOWN || audio_mixdown->amixdown <= mixdown) &&
1686 (hb_mixdown_is_supported(audio_mixdown->amixdown, codec, layout)))
1687 {
1688 best_mixdown = audio_mixdown->amixdown;
1689 }
1690 }
1691 return best_mixdown;
1692 }
1693
1694 int hb_mixdown_get_default(uint32_t codec, uint64_t layout)
1695 {
1696 int mixdown;
1697 switch (codec)
1698 {
1699 // the FLAC encoder defaults to the best mixdown up to 7.1
1700 case HB_ACODEC_FFFLAC:
1701 case HB_ACODEC_FFFLAC24:
1702 mixdown = HB_AMIXDOWN_7POINT1;
1703 break;
1704
1705 // the (E-)AC-3 encoder defaults to the best mixdown up to 5.1
1706 case HB_ACODEC_AC3:
1707 case HB_ACODEC_FFEAC3:
1708 mixdown = HB_AMIXDOWN_5POINT1;
1709 break;
1710
1711 // other encoders default to the best mixdown up to DPLII
1712 default:
1713 mixdown = HB_AMIXDOWN_DOLBYPLII;
1714 break;
1715 }
1716
1717 // return the best available mixdown up to the selected default
1718 return hb_mixdown_get_best(codec, layout, mixdown);
1719 }
1720
1721 hb_mixdown_t* hb_mixdown_get_from_mixdown(int mixdown)
1722 {
1723 int i;
1724 for (i = 0; i < hb_audio_mixdowns_count; i++)
1725 {
1726 if (hb_audio_mixdowns[i].item.amixdown == mixdown)
1727 {
1728 return &hb_audio_mixdowns[i].item;
1729 }
1730 }
1731
1732 return NULL;
1733 }
1734
1735 int hb_mixdown_get_from_name(const char *name)
1736 {
1737 if (name == NULL || *name == '\0')
1738 goto fail;
1739
1740 int i;
1741 for (i = 0; i < hb_audio_mixdowns_count; i++)
1742 {
1743 if (!strcasecmp(hb_audio_mixdowns[i].item.name, name) ||
1744 !strcasecmp(hb_audio_mixdowns[i].item.short_name, name))
1745 {
1746 return hb_audio_mixdowns[i].item.amixdown;
1747 }
1748 }
1749
1750 fail:
1751 return HB_INVALID_AMIXDOWN;
1752 }
1753
1754 const char* hb_mixdown_get_name(int mixdown)
1755 {
1756 if (mixdown < hb_audio_mixdowns_first_item->amixdown ||
1757 mixdown > hb_audio_mixdowns_last_item ->amixdown)
1758 goto fail;
1759
1760 const hb_mixdown_t *audio_mixdown = NULL;
1761 while ((audio_mixdown = hb_mixdown_get_next(audio_mixdown)) != NULL)
1762 {
1763 if (audio_mixdown->amixdown == mixdown)
1764 {
1765 return audio_mixdown->name;
1766 }
1767 }
1768
1769 fail:
1770 return NULL;
1771 }
1772
1773 const char* hb_mixdown_get_short_name(int mixdown)
1774 {
1775 if (mixdown < hb_audio_mixdowns_first_item->amixdown ||
1776 mixdown > hb_audio_mixdowns_last_item ->amixdown)
1777 goto fail;
1778
1779 const hb_mixdown_t *audio_mixdown = NULL;
1780 while ((audio_mixdown = hb_mixdown_get_next(audio_mixdown)) != NULL)
1781 {
1782 if (audio_mixdown->amixdown == mixdown)
1783 {
1784 return audio_mixdown->short_name;
1785 }
1786 }
1787
1788 fail:
1789 return NULL;
1790 }
1791
1792 const char* hb_mixdown_sanitize_name(const char *name)
1793 {
1794 return hb_mixdown_get_name(hb_mixdown_get_from_name(name));
1795 }
1796
1797 const hb_mixdown_t* hb_mixdown_get_next(const hb_mixdown_t *last)
1798 {
1799 if (last == NULL)
1800 {
1801 return hb_audio_mixdowns_first_item;
1802 }
1803 return ((hb_mixdown_internal_t*)last)->next;
1804 }
1805
1806 int hb_video_encoder_get_default(int muxer)
1807 {
1808 if (!(muxer & HB_MUX_MASK))
1809 goto fail;
1810
1811 const hb_encoder_t *video_encoder = NULL;
1812 while ((video_encoder = hb_video_encoder_get_next(video_encoder)) != NULL)
1813 {
1814 if (video_encoder->muxers & muxer)
1815 {
1816 return video_encoder->codec;
1817 }
1818 }
1819
1820 fail:
1821 return HB_VCODEC_INVALID;
1822 }
1823
1824 hb_encoder_t * hb_video_encoder_get_from_codec(int codec)
1825 {
1826 int i;
1827 for (i = 0; i < hb_video_encoders_count; i++)
1828 {
1829 if (hb_video_encoders[i].item.codec == codec)
1830 {
1831 return &hb_video_encoders[i].item;
1832 }
1833 }
1834
1835 return NULL;
1836 }
1837
1838 int hb_video_encoder_get_from_name(const char *name)
1839 {
1840 if (name == NULL || *name == '\0')
1841 goto fail;
1842
1843 int i;
1844 for (i = 0; i < hb_video_encoders_count; i++)
1845 {
1846 if (!strcasecmp(hb_video_encoders[i].item.name, name) ||
1847 !strcasecmp(hb_video_encoders[i].item.short_name, name))
1848 {
1849 return hb_video_encoders[i].item.codec;
1850 }
1851 }
1852
1853 fail:
1854 return HB_VCODEC_INVALID;
1855 }
1856
1857 const char* hb_video_encoder_get_name(int encoder)
1858 {
1859 if (!(encoder & HB_VCODEC_MASK))
1860 goto fail;
1861
1862 const hb_encoder_t *video_encoder = NULL;
1863 while ((video_encoder = hb_video_encoder_get_next(video_encoder)) != NULL)
1864 {
1865 if (video_encoder->codec == encoder)
1866 {
1867 return video_encoder->name;
1868 }
1869 }
1870
1871 fail:
1872 return NULL;
1873 }
1874
1875 const char* hb_video_encoder_get_short_name(int encoder)
1876 {
1877 if (!(encoder & HB_VCODEC_MASK))
1878 goto fail;
1879
1880 const hb_encoder_t *video_encoder = NULL;
1881 while ((video_encoder = hb_video_encoder_get_next(video_encoder)) != NULL)
1882 {
1883 if (video_encoder->codec == encoder)
1884 {
1885 return video_encoder->short_name;
1886 }
1887 }
1888
1889 fail:
1890 return NULL;
1891 }
1892
1893 const char* hb_video_encoder_get_long_name(int encoder)
1894 {
1895 if (!(encoder & HB_VCODEC_MASK))
1896 goto fail;
1897
1898 const hb_encoder_t *video_encoder = NULL;
1899 while ((video_encoder = hb_video_encoder_get_next(video_encoder)) != NULL)
1900 {
1901 if (video_encoder->codec == encoder)
1902 {
1903 return video_encoder->long_name;
1904 }
1905 }
1906
1907 fail:
1908 return NULL;
1909 }
1910
1911 const char* hb_video_encoder_sanitize_name(const char *name)
1912 {
1913 return hb_video_encoder_get_name(hb_video_encoder_get_from_name(name));
1914 }
1915
1916 const hb_encoder_t* hb_video_encoder_get_next(const hb_encoder_t *last)
1917 {
1918 if (last == NULL)
1919 {
1920 return hb_video_encoders_first_item;
1921 }
1922 return ((hb_encoder_internal_t*)last)->next;
1923 }
1924
1925 // for a valid passthru, return the matching encoder for that codec (if any),
1926 // else return -1 (i.e. drop the track)
1927 int hb_audio_encoder_get_fallback_for_passthru(int passthru)
1928 {
1929 int gid;
1930 const hb_encoder_t *audio_encoder = NULL;
1931 switch (passthru)
1932 {
1933 case HB_ACODEC_AAC_PASS:
1934 gid = HB_GID_ACODEC_AAC;
1935 break;
1936
1937 case HB_ACODEC_AC3_PASS:
1938 gid = HB_GID_ACODEC_AC3;
1939 break;
1940
1941 case HB_ACODEC_EAC3_PASS:
1942 gid = HB_GID_ACODEC_EAC3;
1943 break;
1944
1945 case HB_ACODEC_FLAC_PASS:
1946 gid = HB_GID_ACODEC_FLAC;
1947 break;
1948
1949 case HB_ACODEC_MP3_PASS:
1950 gid = HB_GID_ACODEC_MP3;
1951 break;
1952
1953 default:
1954 gid = HB_GID_NONE; // will never match an enabled encoder
1955 break;
1956 }
1957 while ((audio_encoder = hb_audio_encoder_get_next(audio_encoder)) != NULL)
1958 {
1959 if (((hb_encoder_internal_t*)audio_encoder)->gid == gid)
1960 {
1961 return audio_encoder->codec;
1962 }
1963 }
1964
1965 // passthru tracks are often the second audio from the same source track
1966 // if we don't have an encoder matching the passthru codec, return INVALID
1967 // dropping the track, as well as ensuring that there is at least one
1968 // audio track in the output is then up to the UIs
1969 return HB_ACODEC_INVALID;
1970 }
1971
1972 int hb_audio_encoder_get_default(int muxer)
1973 {
1974 if (!(muxer & HB_MUX_MASK))
1975 goto fail;
1976
1977 int codec = 0;
1978 const hb_encoder_t *audio_encoder = NULL;
1979 while ((audio_encoder = hb_audio_encoder_get_next(audio_encoder)) != NULL)
1980 {
1981 // default encoder should not be passthru
1982 if ((audio_encoder->muxers & muxer) &&
1983 (audio_encoder->codec & HB_ACODEC_PASS_FLAG) == 0)
1984 {
1985 codec = audio_encoder->codec;
1986 break;
1987 }
1988 }
1989
1990 // Lame is better than our low-end AAC encoders
1991 // if the container is MKV, use the former
1992 // AAC is still used when the container is MP4 (for better compatibility)
1993 if (codec == HB_ACODEC_FFAAC && (muxer & HB_MUX_MASK_MKV) == muxer)
1994 {
1995 return HB_ACODEC_LAME;
1996 }
1997 else
1998 {
1999 return codec;
2000 }
2001
2002 fail:
2003 return HB_ACODEC_INVALID;
2004 }
2005
2006 hb_encoder_t* hb_audio_encoder_get_from_codec(int codec)
2007 {
2008 int i;
2009 for (i = 0; i < hb_audio_encoders_count; i++)
2010 {
2011 if (hb_audio_encoders[i].item.codec == codec)
2012 {
2013 return &hb_audio_encoders[i].item;
2014 }
2015 }
2016
2017 return NULL;
2018 }
2019
2020 int hb_audio_encoder_get_from_name(const char *name)
2021 {
2022 if (name == NULL || *name == '\0')
2023 goto fail;
2024
2025 int i;
2026 for (i = 0; i < hb_audio_encoders_count; i++)
2027 {
2028 if (!strcasecmp(hb_audio_encoders[i].item.name, name) ||
2029 !strcasecmp(hb_audio_encoders[i].item.short_name, name))
2030 {
2031 return hb_audio_encoders[i].item.codec;
2032 }
2033 }
2034
2035 fail:
2036 return HB_ACODEC_INVALID;
2037 }
2038
2039 const char* hb_audio_encoder_get_name(int encoder)
2040 {
2041 if (!(encoder & HB_ACODEC_ANY))
2042 goto fail;
2043
2044 const hb_encoder_t *audio_encoder = NULL;
2045 while ((audio_encoder = hb_audio_encoder_get_next(audio_encoder)) != NULL)
2046 {
2047 if (audio_encoder->codec == encoder)
2048 {
2049 return audio_encoder->name;
2050 }
2051 }
2052
2053 fail:
2054 return NULL;
2055 }
2056
2057 const char* hb_audio_encoder_get_short_name(int encoder)
2058 {
2059 if (!(encoder & HB_ACODEC_ANY))
2060 goto fail;
2061
2062 const hb_encoder_t *audio_encoder = NULL;
2063 while ((audio_encoder = hb_audio_encoder_get_next(audio_encoder)) != NULL)
2064 {
2065 if (audio_encoder->codec == encoder)
2066 {
2067 return audio_encoder->short_name;
2068 }
2069 }
2070
2071 fail:
2072 return NULL;
2073 }
2074
2075 const char* hb_audio_encoder_get_long_name(int encoder)
2076 {
2077 if (!(encoder & HB_ACODEC_ANY))
2078 goto fail;
2079
2080 const hb_encoder_t *audio_encoder = NULL;
2081 while ((audio_encoder = hb_audio_encoder_get_next(audio_encoder)) != NULL)
2082 {
2083 if (audio_encoder->codec == encoder)
2084 {
2085 return audio_encoder->long_name;
2086 }
2087 }
2088
2089 fail:
2090 return NULL;
2091 }
2092
2093 const char* hb_audio_encoder_sanitize_name(const char *name)
2094 {
2095 return hb_audio_encoder_get_name(hb_audio_encoder_get_from_name(name));
2096 }
2097
2098 const hb_encoder_t* hb_audio_encoder_get_next(const hb_encoder_t *last)
2099 {
2100 if (last == NULL)
2101 {
2102 return hb_audio_encoders_first_item;
2103 }
2104 return ((hb_encoder_internal_t*)last)->next;
2105 }
2106
2107 void hb_autopassthru_apply_settings(hb_job_t *job)
2108 {
2109 hb_audio_t *audio;
2110 int i, already_printed;
2111 for (i = already_printed = 0; i < hb_list_count(job->list_audio);)
2112 {
2113 audio = hb_list_item(job->list_audio, i);
2114 if (audio->config.out.codec == HB_ACODEC_AUTO_PASS)
2115 {
2116 if (!already_printed)
2117 hb_autopassthru_print_settings(job);
2118 already_printed = 1;
2119 audio->config.out.codec = hb_autopassthru_get_encoder(audio->config.in.codec,
2120 job->acodec_copy_mask,
2121 job->acodec_fallback,
2122 job->mux);
2123 if (!(audio->config.out.codec & HB_ACODEC_PASS_FLAG) &&
2124 !(audio->config.out.codec & HB_ACODEC_MASK))
2125 {
2126 hb_log("Auto Passthru: passthru not possible and no valid fallback specified, dropping track %d",
2127 audio->config.out.track );
2128 hb_list_rem(job->list_audio, audio);
2129 hb_audio_close(&audio);
2130 continue;
2131 }
2132 if (!(audio->config.out.codec & HB_ACODEC_PASS_FLAG))
2133 {
2134 if (audio->config.out.codec == job->acodec_fallback)
2135 {
2136 hb_log("Auto Passthru: passthru not possible for track %d, using fallback",
2137 audio->config.out.track);
2138 }
2139 else
2140 {
2141 hb_log("Auto Passthru: passthru and fallback not possible for track %d, using default encoder",
2142 audio->config.out.track);
2143 }
2144 if (audio->config.out.mixdown <= 0)
2145 {
2146 audio->config.out.mixdown =
2147 hb_mixdown_get_default(audio->config.out.codec,
2148 audio->config.in.channel_layout);
2149 }
2150 else
2151 {
2152 audio->config.out.mixdown =
2153 hb_mixdown_get_best(audio->config.out.codec,
2154 audio->config.in.channel_layout,
2155 audio->config.out.mixdown);
2156 }
2157 if (audio->config.out.samplerate <= 0)
2158 audio->config.out.samplerate = audio->config.in.samplerate;
2159 audio->config.out.samplerate =
2160 hb_audio_samplerate_get_best(audio->config.out.codec,
2161 audio->config.out.samplerate,
2162 NULL);
2163 int quality_not_allowed =
2164 hb_audio_quality_get_default(audio->config.out.codec)
2165 == HB_INVALID_AUDIO_QUALITY;
2166 if (audio->config.out.bitrate > 0)
2167 {
2168 // Use best bitrate
2169 audio->config.out.bitrate =
2170 hb_audio_bitrate_get_best(audio->config.out.codec,
2171 audio->config.out.bitrate,
2172 audio->config.out.samplerate,
2173 audio->config.out.mixdown);
2174 }
2175 else if (quality_not_allowed ||
2176 audio->config.out.quality != HB_INVALID_AUDIO_QUALITY)
2177 {
2178 // Use default bitrate
2179 audio->config.out.bitrate =
2180 hb_audio_bitrate_get_default(audio->config.out.codec,
2181 audio->config.out.samplerate,
2182 audio->config.out.mixdown);
2183 }
2184 else
2185 {
2186 // Use best quality
2187 audio->config.out.quality =
2188 hb_audio_quality_get_best(audio->config.out.codec,
2189 audio->config.out.quality);
2190 }
2191 if (audio->config.out.compression_level < 0)
2192 {
2193 audio->config.out.compression_level =
2194 hb_audio_compression_get_default(
2195 audio->config.out.codec);
2196 }
2197 else
2198 {
2199 audio->config.out.compression_level =
2200 hb_audio_compression_get_best(audio->config.out.codec,
2201 audio->config.out.compression_level);
2202 }
2203 }
2204 else
2205 {
2206 const hb_encoder_t *audio_encoder = NULL;
2207 while ((audio_encoder = hb_audio_encoder_get_next(audio_encoder)) != NULL)
2208 {
2209 if (audio_encoder->codec == audio->config.out.codec)
2210 {
2211 hb_log("Auto Passthru: using %s for track %d",
2212 audio_encoder->name,
2213 audio->config.out.track);
2214 break;
2215 }
2216 }
2217 }
2218 }
2219 /* Adjust output track number, in case we removed one.
2220 * Output tracks sadly still need to be in sequential order.
2221 * Note: out.track starts at 1, i starts at 0 */
2222 audio->config.out.track = ++i;
2223 }
2224 }
2225
2226 void hb_autopassthru_print_settings(hb_job_t *job)
2227 {
2228 char *mask = NULL, *tmp;
2229 const char *fallback = NULL;
2230 const hb_encoder_t *audio_encoder = NULL;
2231 while ((audio_encoder = hb_audio_encoder_get_next(audio_encoder)) != NULL)
2232 {
2233 if ((audio_encoder->codec & HB_ACODEC_PASS_FLAG) &&
2234 (audio_encoder->codec != HB_ACODEC_AUTO_PASS) &&
2235 (audio_encoder->codec & (job->acodec_copy_mask &
2236 HB_ACODEC_PASS_MASK)))
2237 {
2238 if (mask != NULL)
2239 {
2240 tmp = hb_strncat_dup(mask, ", ", 2);
2241 if (tmp != NULL)
2242 {
2243 free(mask);
2244 mask = tmp;
2245 }
2246 }
2247 // passthru name without " Passthru"
2248 tmp = hb_strncat_dup(mask, audio_encoder->name,
2249 strlen(audio_encoder->name) - 9);
2250 if (tmp != NULL)
2251 {
2252 free(mask);
2253 mask = tmp;
2254 }
2255 }
2256 else if ((audio_encoder->codec & HB_ACODEC_PASS_FLAG) == 0 &&
2257 (audio_encoder->codec == job->acodec_fallback))
2258 {
2259 fallback = audio_encoder->name;
2260 }
2261 }
2262 if (mask == NULL)
2263 hb_log("Auto Passthru: no codecs allowed");
2264 else
2265 hb_log("Auto Passthru: allowed codecs are %s", mask);
2266 if (fallback == NULL)
2267 hb_log("Auto Passthru: no valid fallback specified");
2268 else
2269 hb_log("Auto Passthru: fallback is %s", fallback);
2270 }
2271
2272 int hb_autopassthru_get_encoder(int in_codec, int copy_mask, int fallback,
2273 int muxer)
2274 {
2275 int i = 0;
2276 const hb_encoder_t *audio_encoder = NULL;
2277 int out_codec = (copy_mask & in_codec) | HB_ACODEC_PASS_FLAG;
2278 // sanitize fallback encoder and selected passthru
2279 // note: invalid fallbacks are caught in hb_autopassthru_apply_settings
2280 while ((audio_encoder = hb_audio_encoder_get_next(audio_encoder)) != NULL)
2281 {
2282 if (audio_encoder->codec == out_codec)
2283 {
2284 i++;
2285 if (!(audio_encoder->muxers & muxer))
2286 out_codec = 0;
2287 }
2288 else if (audio_encoder->codec == fallback)
2289 {
2290 i++;
2291 if (!(audio_encoder->muxers & muxer))
2292 fallback = hb_audio_encoder_get_default(muxer);
2293 }
2294 if (i > 1)
2295 {
2296 break;
2297 }
2298 }
2299 return (out_codec & HB_ACODEC_PASS_MASK) ? out_codec : fallback;
2300 }
2301
2302 hb_container_t* hb_container_get_from_format(int format)
2303 {
2304 int i;
2305 for (i = 0; i < hb_containers_count; i++)
2306 {
2307 if (hb_containers[i].item.format == format)
2308 {
2309 return &hb_containers[i].item;
2310 }
2311 }
2312
2313 return NULL;
2314 }
2315
2316 int hb_container_get_from_name(const char *name)
2317 {
2318 if (name == NULL || *name == '\0')
2319 goto fail;
2320
2321 int i;
2322 for (i = 0; i < hb_containers_count; i++)
2323 {
2324 if (!strcasecmp(hb_containers[i].item.name, name) ||
2325 !strcasecmp(hb_containers[i].item.short_name, name))
2326 {
2327 return hb_containers[i].item.format;
2328 }
2329 }
2330
2331 fail:
2332 return HB_MUX_INVALID;
2333 }
2334
2335 int hb_container_get_from_extension(const char *extension)
2336 {
2337 if (extension == NULL || *extension == '\0')
2338 goto fail;
2339
2340 int i;
2341 for (i = 0; i < hb_containers_count; i++)
2342 {
2343 if (!strcasecmp(hb_containers[i].item.default_extension, extension))
2344 {
2345 return hb_containers[i].item.format;
2346 }
2347 }
2348
2349 fail:
2350 return HB_MUX_INVALID;
2351 }
2352
2353 const char* hb_container_get_name(int format)
2354 {
2355 if (!(format & HB_MUX_MASK))
2356 goto fail;
2357
2358 const hb_container_t *container = NULL;
2359 while ((container = hb_container_get_next(container)) != NULL)
2360 {
2361 if (container->format == format)
2362 {
2363 return container->name;
2364 }
2365 }
2366
2367 fail:
2368 return NULL;
2369 }
2370
2371 const char* hb_container_get_short_name(int format)
2372 {
2373 if (!(format & HB_MUX_MASK))
2374 goto fail;
2375
2376 const hb_container_t *container = NULL;
2377 while ((container = hb_container_get_next(container)) != NULL)
2378 {
2379 if (container->format == format)
2380 {
2381 return container->short_name;
2382 }
2383 }
2384
2385 fail:
2386 return NULL;
2387 }
2388
2389 const char* hb_container_get_long_name(int format)
2390 {
2391 if (!(format & HB_MUX_MASK))
2392 goto fail;
2393
2394 const hb_container_t *container = NULL;
2395 while ((container = hb_container_get_next(container)) != NULL)
2396 {
2397 if (container->format == format)
2398 {
2399 return container->long_name;
2400 }
2401 }
2402
2403 fail:
2404 return NULL;
2405 }
2406
2407 const char* hb_container_get_default_extension(int format)
2408 {
2409 if (!(format & HB_MUX_MASK))
2410 goto fail;
2411
2412 const hb_container_t *container = NULL;
2413 while ((container = hb_container_get_next(container)) != NULL)
2414 {
2415 if (container->format == format)
2416 {
2417 return container->default_extension;
2418 }
2419 }
2420
2421 fail:
2422 return NULL;
2423 }
2424
2425 const char* hb_container_sanitize_name(const char *name)
2426 {
2427 return hb_container_get_name(hb_container_get_from_name(name));
2428 }
2429
2430 const hb_container_t* hb_container_get_next(const hb_container_t *last)
2431 {
2432 if (last == NULL)
2433 {
2434 return hb_containers_first_item;
2435 }
2436 return ((hb_container_internal_t*)last)->next;
2437 }
2438
2439 /**********************************************************************
2440 * hb_reduce
2441 **********************************************************************
2442 * Given a numerator (num) and a denominator (den), reduce them to an
2443 * equivalent fraction and store the result in x and y.
2444 *********************************************************************/
2445 void hb_reduce( int *x, int *y, int num, int den )
2446 {
2447 // find the greatest common divisor of num & den by Euclid's algorithm
2448 int n = num, d = den;
2449 while ( d )
2450 {
2451 int t = d;
2452 d = n % d;
2453 n = t;
2454 }
2455
2456 // at this point n is the gcd. if it's non-zero remove it from num
2457 // and den. Otherwise just return the original values.
2458 if ( n )
2459 {
2460 *x = num / n;
2461 *y = den / n;
2462 }
2463 else
2464 {
2465 *x = num;
2466 *y = den;
2467 }
2468 }
2469
2470 void hb_limit_rational( int *x, int *y, int num, int den, int limit )
2471 {
2472 hb_reduce( &num, &den, num, den );
2473 if ( num < limit && den < limit )
2474 {
2475 *x = num;
2476 *y = den;
2477 return;
2478 }
2479
2480 if ( num > den )
2481 {
2482 double div = (double)limit / num;
2483 num = limit;
2484 den *= div;
2485 }
2486 else
2487 {
2488 double div = (double)limit / den;
2489 den = limit;
2490 num *= div;
2491 }
2492 *x = num;
2493 *y = den;
2494 }
2495
2496 /**********************************************************************
2497 * hb_reduce64
2498 **********************************************************************
2499 * Given a numerator (num) and a denominator (den), reduce them to an
2500 * equivalent fraction and store the result in x and y.
2501 *********************************************************************/
2502 void hb_reduce64( int64_t *x, int64_t *y, int64_t num, int64_t den )
2503 {
2504 // find the greatest common divisor of num & den by Euclid's algorithm
2505 int64_t n = num, d = den;
2506 while ( d )
2507 {
2508 int64_t t = d;
2509 d = n % d;
2510 n = t;
2511 }
2512
2513 // at this point n is the gcd. if it's non-zero remove it from num
2514 // and den. Otherwise just return the original values.
2515 if ( n )
2516 {
2517 num /= n;
2518 den /= n;
2519 }
2520
2521 *x = num;
2522 *y = den;
2523
2524 }
2525
2526 void hb_limit_rational64( int64_t *x, int64_t *y, int64_t num, int64_t den, int64_t limit )
2527 {
2528 hb_reduce64( &num, &den, num, den );
2529 if ( num < limit && den < limit )
2530 {
2531 *x = num;
2532 *y = den;
2533 return;
2534 }
2535
2536 if ( num > den )
2537 {
2538 double div = (double)limit / num;
2539 num = limit;
2540 den *= div;
2541 }
2542 else
2543 {
2544 double div = (double)limit / den;
2545 den = limit;
2546 num *= div;
2547 }
2548 *x = num;
2549 *y = den;
2550 }
2551
2552 /**********************************************************************
2553 * hb_list implementation
2554 **********************************************************************
2555 * Basic and slow, but enough for what we need
2556 *********************************************************************/
2557
2558 #define HB_LIST_DEFAULT_SIZE 20
2559
2560 struct hb_list_s
2561 {
2562 /* Pointers to items in the list */
2563 void ** items;
2564
2565 /* How many (void *) allocated in 'items' */
2566 int items_alloc;
2567
2568 /* How many valid pointers in 'items' */
2569 int items_count;
2570 };
2571
2572 /**********************************************************************
2573 * hb_list_init
2574 **********************************************************************
2575 * Allocates an empty list ready for HB_LIST_DEFAULT_SIZE items
2576 *********************************************************************/
2577 hb_list_t * hb_list_init()
2578 {
2579 hb_list_t * l;
2580
2581 l = calloc( sizeof( hb_list_t ), 1 );
2582 l->items = calloc( HB_LIST_DEFAULT_SIZE * sizeof( void * ), 1 );
2583 l->items_alloc = HB_LIST_DEFAULT_SIZE;
2584
2585 return l;
2586 }
2587
2588 /**********************************************************************
2589 * hb_list_count
2590 **********************************************************************
2591 * Returns the number of items currently in the list
2592 *********************************************************************/
2593 int hb_list_count( const hb_list_t * l )
2594 {
2595 return l->items_count;
2596 }
2597
2598 /**********************************************************************
2599 * hb_list_add
2600 **********************************************************************
2601 * Adds an item at the end of the list, making it bigger if necessary.
2602 * Can safely be called with a NULL pointer to add, it will be ignored.
2603 *********************************************************************/
2604 void hb_list_add( hb_list_t * l, void * p )
2605 {
2606 if( !p )
2607 {
2608 return;
2609 }
2610
2611 if( l->items_count == l->items_alloc )
2612 {
2613 /* We need a bigger boat */
2614 l->items_alloc += HB_LIST_DEFAULT_SIZE;
2615 l->items = realloc( l->items,
2616 l->items_alloc * sizeof( void * ) );
2617 }
2618
2619 l->items[l->items_count] = p;
2620 (l->items_count)++;
2621 }
2622
2623 /**********************************************************************
2624 * hb_list_insert
2625 **********************************************************************
2626 * Adds an item at the specifiec position in the list, making it bigger
2627 * if necessary.
2628 * Can safely be called with a NULL pointer to add, it will be ignored.
2629 *********************************************************************/
2630 void hb_list_insert( hb_list_t * l, int pos, void * p )
2631 {
2632 if( !p )
2633 {
2634 return;
2635 }
2636
2637 if( l->items_count == l->items_alloc )
2638 {
2639 /* We need a bigger boat */
2640 l->items_alloc += HB_LIST_DEFAULT_SIZE;
2641 l->items = realloc( l->items,
2642 l->items_alloc * sizeof( void * ) );
2643 }
2644
2645 if ( l->items_count != pos )
2646 {
2647 /* Shift all items after it sizeof( void * ) bytes earlier */
2648 memmove( &l->items[pos+1], &l->items[pos],
2649 ( l->items_count - pos ) * sizeof( void * ) );
2650 }
2651
2652
2653 l->items[pos] = p;
2654 (l->items_count)++;
2655 }
2656
2657 /**********************************************************************
2658 * hb_list_rem
2659 **********************************************************************
2660 * Remove an item from the list. Bad things will happen if called
2661 * with a NULL pointer or if the item is not in the list.
2662 *********************************************************************/
2663 void hb_list_rem( hb_list_t * l, void * p )
2664 {
2665 int i;
2666
2667 /* Find the item in the list */
2668 for( i = 0; i < l->items_count; i++ )
2669 {
2670 if( l->items[i] == p )
2671 {
2672 /* Shift all items after it sizeof( void * ) bytes earlier */
2673 memmove( &l->items[i], &l->items[i+1],
2674 ( l->items_count - i - 1 ) * sizeof( void * ) );
2675
2676 (l->items_count)--;
2677 break;
2678 }
2679 }
2680 }
2681
2682 /**********************************************************************
2683 * hb_list_item
2684 **********************************************************************
2685 * Returns item at position i, or NULL if there are not that many
2686 * items in the list
2687 *********************************************************************/
2688 void * hb_list_item( const hb_list_t * l, int i )
2689 {
2690 if( l == NULL || i < 0 || i >= l->items_count )
2691 {
2692 return NULL;
2693 }
2694
2695 return l->items[i];
2696 }
2697
2698 /**********************************************************************
2699 * hb_list_bytes
2700 **********************************************************************
2701 * Assuming all items are of type hb_buffer_t, returns the total
2702 * number of bytes in the list
2703 *********************************************************************/
2704 int hb_list_bytes( hb_list_t * l )
2705 {
2706 hb_buffer_t * buf;
2707 int ret;
2708 int i;
2709
2710 ret = 0;
2711 for( i = 0; i < hb_list_count( l ); i++ )
2712 {
2713 buf = hb_list_item( l, i );
2714 ret += buf->size - buf->offset;
2715 }
2716
2717 return ret;
2718 }
2719
2720 /**********************************************************************
2721 * hb_list_seebytes
2722 **********************************************************************
2723 * Assuming all items are of type hb_buffer_t, copy <size> bytes from
2724 * the list to <dst>, keeping the list unmodified.
2725 *********************************************************************/
2726 void hb_list_seebytes( hb_list_t * l, uint8_t * dst, int size )
2727 {
2728 hb_buffer_t * buf;
2729 int copied;
2730 int copying;
2731 int i;
2732
2733 for( i = 0, copied = 0; copied < size; i++ )
2734 {
2735 buf = hb_list_item( l, i );
2736 copying = MIN( buf->size - buf->offset, size - copied );
2737 memcpy( &dst[copied], &buf->data[buf->offset], copying );
2738 copied += copying;
2739 }
2740 }
2741
2742 /**********************************************************************
2743 * hb_list_getbytes
2744 **********************************************************************
2745 * Assuming all items are of type hb_buffer_t, copy <size> bytes from
2746 * the list to <dst>. What's copied is removed from the list.
2747 * The variable pointed by <pts> is set to the PTS of the buffer the
2748 * first byte has been got from.
2749 * The variable pointed by <pos> is set to the position of that byte
2750 * in that buffer.
2751 *********************************************************************/
2752 void hb_list_getbytes( hb_list_t * l, uint8_t * dst, int size,
2753 uint64_t * pts, uint64_t * pos )
2754 {
2755 hb_buffer_t * buf;
2756 int copied;
2757 int copying;
2758 uint8_t has_pts;
2759
2760 /* So we won't have to deal with NULL pointers */
2761 uint64_t dummy1, dummy2;
2762
2763 if( !pts ) pts = &dummy1;
2764 if( !pos ) pos = &dummy2;
2765
2766 for( copied = 0, has_pts = 0; copied < size; )
2767 {
2768 buf = hb_list_item( l, 0 );
2769 copying = MIN( buf->size - buf->offset, size - copied );
2770 memcpy( &dst[copied], &buf->data[buf->offset], copying );
2771
2772 if( !has_pts )
2773 {
2774 *pts = buf->s.start;
2775 *pos = buf->offset;
2776 has_pts = 1;
2777 }
2778
2779 buf->offset += copying;
2780 if( buf->offset >= buf->size )
2781 {
2782 hb_list_rem( l, buf );
2783 hb_buffer_close( &buf );
2784 }
2785
2786 copied += copying;
2787 }
2788 }
2789
2790 /**********************************************************************
2791 * hb_list_empty
2792 **********************************************************************
2793 * Assuming all items are of type hb_buffer_t, close them all and
2794 * close the list.
2795 *********************************************************************/
2796 void hb_list_empty( hb_list_t ** _l )
2797 {
2798 hb_list_t * l = *_l;
2799 hb_buffer_t * b;
2800
2801 while( ( b = hb_list_item( l, 0 ) ) )
2802 {
2803 hb_list_rem( l, b );
2804 hb_buffer_close( &b );
2805 }
2806
2807 hb_list_close( _l );
2808 }
2809
2810 /**********************************************************************
2811 * hb_list_close
2812 **********************************************************************
2813 * Free memory allocated by hb_list_init. Does NOT free contents of
2814 * items still in the list.
2815 *********************************************************************/
2816 void hb_list_close( hb_list_t ** _l )
2817 {
2818 hb_list_t * l = *_l;
2819
2820 if (l == NULL)
2821 return;
2822
2823 free( l->items );
2824 free( l );
2825
2826 *_l = NULL;
2827 }
2828
2829 int global_verbosity_level; //Necessary for hb_deep_log
2830 /**********************************************************************
2831 * hb_valog
2832 **********************************************************************
2833 * If verbose mode is one, print message with timestamp. Messages
2834 * longer than 180 characters are stripped ;p
2835 *********************************************************************/
2836 void hb_valog( hb_debug_level_t level, const char * prefix, const char * log, va_list args)
2837 {
2838 char * string;
2839 time_t _now;
2840 struct tm * now;
2841 char preamble[362];
2842
2843 if( global_verbosity_level < level )
2844 {
2845 /* Hiding message */
2846 return;
2847 }
2848
2849 /* Get the time */
2850 _now = time( NULL );
2851 now = localtime( &_now );
2852 if ( prefix && *prefix )
2853 {
2854 // limit the prefix length
2855 snprintf( preamble, 361, "[%02d:%02d:%02d] %s %s\n",
2856 now->tm_hour, now->tm_min, now->tm_sec, prefix, log );
2857 }
2858 else
2859 {
2860 snprintf( preamble, 361, "[%02d:%02d:%02d] %s\n",
2861 now->tm_hour, now->tm_min, now->tm_sec, log );
2862 }
2863
2864 string = hb_strdup_vaprintf(preamble, args);
2865
2866 #ifdef SYS_MINGW
2867 wchar_t *wstring; /* 360 chars + \n + \0 */
2868 int len;
2869
2870 len = strlen(string) + 1;
2871 wstring = malloc(2 * len);
2872
2873 // Convert internal utf8 to "console output code page".
2874 //
2875 // This is just bizarre windows behavior. You would expect that
2876 // printf would automatically convert a wide character string to
2877 // the current "console output code page" when using the "%ls" format
2878 // specifier. But it doesn't... so we must do it.
2879 if (!MultiByteToWideChar(CP_UTF8, 0, string, -1, wstring, len))
2880 {
2881 free(string);
2882 free(wstring);
2883 return;
2884 }
2885 free(string);
2886 string = malloc(2 * len);
2887 if (!WideCharToMultiByte(GetConsoleOutputCP(), 0, wstring, -1, string, len,
2888 NULL, NULL))
2889 {
2890 free(string);
2891 free(wstring);
2892 return;
2893 }
2894 free(wstring);
2895 #endif
2896
2897 /* Print it */
2898 fprintf( stderr, "%s", string );
2899 free(string);
2900 }
2901
2902 /**********************************************************************
2903 * hb_log
2904 **********************************************************************
2905 * If verbose mode is one, print message with timestamp. Messages
2906 * longer than 180 characters are stripped ;p
2907 *********************************************************************/
2908 void hb_log( char * log, ... )
2909 {
2910 va_list args;
2911
2912 va_start( args, log );
2913 hb_valog( 0, NULL, log, args );
2914 va_end( args );
2915 }
2916
2917 /**********************************************************************
2918 * hb_deep_log
2919 **********************************************************************
2920 * If verbose mode is >= level, print message with timestamp. Messages
2921 * longer than 360 characters are stripped ;p
2922 *********************************************************************/
2923 void hb_deep_log( hb_debug_level_t level, char * log, ... )
2924 {
2925 va_list args;
2926
2927 va_start( args, log );
2928 hb_valog( level, NULL, log, args );
2929 va_end( args );
2930 }
2931
2932 /**********************************************************************
2933 * hb_error
2934 **********************************************************************
2935 * Using whatever output is available display this error.
2936 *********************************************************************/
2937 void hb_error( char * log, ... )
2938 {
2939 char string[181]; /* 180 chars + \0 */
2940 char rep_string[181];
2941 static char last_string[181];
2942 static int last_error_count = 0;
2943 static uint64_t last_series_error_time = 0;
2944 static hb_lock_t *mutex = 0;
2945 va_list args;
2946 uint64_t time_now;
2947
2948 /* Convert the message to a string */
2949 va_start( args, log );
2950 vsnprintf( string, 180, log, args );
2951 va_end( args );
2952
2953 if( !mutex )
2954 {
2955 mutex = hb_lock_init();
2956 }
2957
2958 hb_lock( mutex );
2959
2960 time_now = hb_get_date();
2961
2962 if( strcmp( string, last_string) == 0 )
2963 {
2964 /*
2965 * The last error and this one are the same, don't log it
2966 * just count it instead, unless it was more than one second
2967 * ago.
2968 */
2969 last_error_count++;
2970 if( last_series_error_time + ( 1000 * 1 ) > time_now )
2971 {
2972 hb_unlock( mutex );
2973 return;
2974 }
2975 }
2976
2977 /*
2978 * A new error, or the same one more than 10sec since the last one
2979 * did we have any of the same counted up?
2980 */
2981 if( last_error_count > 0 )
2982 {
2983 /*
2984 * Print out the last error to ensure context for the last
2985 * repeated message.
2986 */
2987 if( error_handler )
2988 {
2989 error_handler( last_string );
2990 } else {
2991 hb_log( "%s", last_string );
2992 }
2993
2994 if( last_error_count > 1 )
2995 {
2996 /*
2997 * Only print out the repeat message for more than 2 of the
2998 * same, since we just printed out two of them already.
2999 */
3000 snprintf( rep_string, 180, "Last error repeated %d times",
3001 last_error_count - 1 );
3002
3003 if( error_handler )
3004 {
3005 error_handler( rep_string );
3006 } else {
3007 hb_log( "%s", rep_string );
3008 }
3009 }
3010
3011 last_error_count = 0;
3012 }
3013
3014 last_series_error_time = time_now;
3015
3016 strcpy( last_string, string );
3017
3018 /*
3019 * Got the error in a single string, send it off to be dispatched.
3020 */
3021 if( error_handler )
3022 {
3023 error_handler( string );
3024 } else {
3025 hb_log( "%s", string );
3026 }
3027
3028 hb_unlock( mutex );
3029 }
3030
3031 void hb_register_error_handler( hb_error_handler_t * handler )
3032 {
3033 error_handler = handler;
3034 }
3035
3036 static void hb_update_str( char **dst, const char *src )
3037 {
3038 if ( dst )
3039 {
3040 free( *dst );
3041 *dst = NULL;
3042 if ( src )
3043 {
3044 *dst = strdup( src );
3045 }
3046 }
3047 }
3048
3049 /**********************************************************************
3050 * hb_title_init
3051 **********************************************************************
3052 *
3053 *********************************************************************/
3054 hb_title_t * hb_title_init( char * path, int index )
3055 {
3056 hb_title_t * t;
3057
3058 t = calloc( sizeof( hb_title_t ), 1 );
3059
3060 t->index = index;
3061 t->playlist = -1;
3062 t->list_audio = hb_list_init();
3063 t->list_chapter = hb_list_init();
3064 t->list_subtitle = hb_list_init();
3065 t->list_attachment = hb_list_init();
3066 t->metadata = hb_metadata_init();
3067 strncat(t->path, path, sizeof(t->path) - 1);
3068 // default to decoding mpeg2
3069 t->video_id = 0xE0;
3070 t->video_codec = WORK_DECAVCODECV;
3071 t->video_codec_param = AV_CODEC_ID_MPEG2VIDEO;
3072 t->angle_count = 1;
3073 t->geometry.par.num = 1;
3074 t->geometry.par.den = 1;
3075
3076 return t;
3077 }
3078
3079 /**********************************************************************
3080 * hb_title_close
3081 **********************************************************************
3082 *
3083 *********************************************************************/
3084 void hb_title_close( hb_title_t ** _t )
3085 {
3086 hb_title_t * t = *_t;
3087 hb_audio_t * audio;
3088 hb_chapter_t * chapter;
3089 hb_subtitle_t * subtitle;
3090 hb_attachment_t * attachment;
3091
3092 while( ( chapter = hb_list_item( t->list_chapter, 0 ) ) )
3093 {
3094 hb_list_rem( t->list_chapter, chapter );
3095 hb_chapter_close( &chapter );
3096 }
3097 hb_list_close( &t->list_chapter );
3098
3099 while( ( audio = hb_list_item( t->list_audio, 0 ) ) )
3100 {
3101 hb_list_rem( t->list_audio, audio );
3102 hb_audio_close( &audio );
3103 }
3104 hb_list_close( &t->list_audio );
3105
3106 while( ( subtitle = hb_list_item( t->list_subtitle, 0 ) ) )
3107 {
3108 hb_list_rem( t->list_subtitle, subtitle );
3109 hb_subtitle_close( &subtitle );
3110 }
3111 hb_list_close( &t->list_subtitle );
3112
3113 while( ( attachment = hb_list_item( t->list_attachment, 0 ) ) )
3114 {
3115 hb_list_rem( t->list_attachment, attachment );
3116 hb_attachment_close( &attachment );
3117 }
3118 hb_list_close( &t->list_attachment );
3119
3120 hb_metadata_close( &t->metadata );
3121
3122 free( t->video_codec_name );
3123 free(t->container_name);
3124
3125 free( t );
3126 *_t = NULL;
3127 }
3128
3129 static void job_setup(hb_job_t * job, hb_title_t * title)
3130 {
3131 if ( job == NULL || title == NULL )
3132 return;
3133
3134 job->title = title;
3135
3136 /* Set defaults settings */
3137 job->chapter_start = 1;
3138 job->chapter_end = hb_list_count( title->list_chapter );
3139 job->list_chapter = hb_chapter_list_copy( title->list_chapter );
3140
3141 /* Autocrop by default. Gnark gnark */
3142 memcpy( job->crop, title->crop, 4 * sizeof( int ) );
3143
3144
3145 hb_geometry_t resultGeo, srcGeo;
3146 hb_geometry_settings_t uiGeo;
3147
3148 srcGeo = title->geometry;
3149
3150 memset(&uiGeo, 0, sizeof(uiGeo));
3151 memcpy(uiGeo.crop, title->crop, 4 * sizeof( int ));
3152 uiGeo.geometry.width = srcGeo.width - uiGeo.crop[2] - uiGeo.crop[3];
3153 uiGeo.geometry.height = srcGeo.height - uiGeo.crop[0] - uiGeo.crop[1];
3154 uiGeo.mode = HB_ANAMORPHIC_NONE;
3155 uiGeo.keep = HB_KEEP_DISPLAY_ASPECT;
3156
3157 hb_set_anamorphic_size2(&srcGeo, &uiGeo, &resultGeo);
3158 job->width = resultGeo.width;
3159 job->height = resultGeo.height;
3160 job->par = resultGeo.par;
3161
3162 job->vcodec = HB_VCODEC_FFMPEG_MPEG4;
3163 job->vquality = -1.0;
3164 job->vbitrate = 1000;
3165 job->twopass = 0;
3166 job->pass_id = HB_PASS_ENCODE;
3167 job->vrate = title->vrate;
3168
3169 job->mux = HB_MUX_MP4;
3170
3171 job->list_audio = hb_list_init();
3172 job->list_subtitle = hb_list_init();
3173 job->list_filter = hb_list_init();
3174
3175 job->list_attachment = hb_attachment_list_copy( title->list_attachment );
3176 job->metadata = hb_metadata_copy( title->metadata );
3177
3178 #ifdef USE_QSV
3179 job->qsv.enc_info.is_init_done = 0;
3180 job->qsv.async_depth = AV_QSV_ASYNC_DEPTH_DEFAULT;
3181 job->qsv.decode = !!(title->video_decode_support &
3182 HB_DECODE_SUPPORT_QSV);
3183 #endif
3184 }
3185
3186 static void job_clean( hb_job_t * job )
3187 {
3188 if (job)
3189 {
3190 hb_chapter_t *chapter;
3191 hb_audio_t *audio;
3192 hb_subtitle_t *subtitle;
3193 hb_filter_object_t *filter;
3194 hb_attachment_t *attachment;
3195
3196 free((void*)job->json);
3197 job->json = NULL;
3198 free(job->encoder_preset);
3199 job->encoder_preset = NULL;
3200 free(job->encoder_tune);
3201 job->encoder_tune = NULL;
3202 free(job->encoder_options);
3203 job->encoder_options = NULL;
3204 free(job->encoder_profile);
3205 job->encoder_profile = NULL;
3206 free(job->encoder_level);
3207 job->encoder_level = NULL;
3208 free(job->file);
3209 job->file = NULL;
3210
3211 // clean up chapter list
3212 while( ( chapter = hb_list_item( job->list_chapter, 0 ) ) )
3213 {
3214 hb_list_rem( job->list_chapter, chapter );
3215 hb_chapter_close( &chapter );
3216 }
3217 hb_list_close( &job->list_chapter );
3218
3219 // clean up audio list
3220 while( ( audio = hb_list_item( job->list_audio, 0 ) ) )
3221 {
3222 hb_list_rem( job->list_audio, audio );
3223 hb_audio_close( &audio );
3224 }
3225 hb_list_close( &job->list_audio );
3226
3227 // clean up subtitle list
3228 while( ( subtitle = hb_list_item( job->list_subtitle, 0 ) ) )
3229 {
3230 hb_list_rem( job->list_subtitle, subtitle );
3231 hb_subtitle_close( &subtitle );
3232 }
3233 hb_list_close( &job->list_subtitle );
3234
3235 // clean up filter list
3236 while( ( filter = hb_list_item( job->list_filter, 0 ) ) )
3237 {
3238 hb_list_rem( job->list_filter, filter );
3239 hb_filter_close( &filter );
3240 }
3241 hb_list_close( &job->list_filter );
3242
3243 // clean up attachment list
3244 while( ( attachment = hb_list_item( job->list_attachment, 0 ) ) )
3245 {
3246 hb_list_rem( job->list_attachment, attachment );
3247 hb_attachment_close( &attachment );
3248 }
3249 hb_list_close( &job->list_attachment );
3250
3251 // clean up metadata
3252 hb_metadata_close( &job->metadata );
3253 }
3254 }
3255
3256 hb_title_t * hb_find_title_by_index( hb_handle_t *h, int title_index )
3257 {
3258 hb_title_set_t *title_set = hb_get_title_set( h );
3259 int ii;
3260
3261 for (ii = 0; ii < hb_list_count(title_set->list_title); ii++)
3262 {
3263 hb_title_t *title = hb_list_item(title_set->list_title, ii);
3264 if (title_index == title->index)
3265 {
3266 return title;
3267 }
3268 }
3269 return NULL;
3270 }
3271
3272 /*
3273 * Create a pristine job structure from a title
3274 * title_index is 1 based
3275 */
3276 hb_job_t * hb_job_init_by_index( hb_handle_t * h, int title_index )
3277 {
3278 hb_title_t * title = hb_find_title_by_index(h, title_index);
3279 if (title == NULL)
3280 return NULL;
3281 return hb_job_init(title);
3282 }
3283
3284 hb_job_t * hb_job_init( hb_title_t * title )
3285 {
3286 hb_job_t * job;
3287
3288 if ( title == NULL )
3289 return NULL;
3290
3291 job = calloc( sizeof( hb_job_t ), 1 );
3292 job_setup(job, title);
3293
3294 return job;
3295 }
3296
3297 /**********************************************************************
3298 * hb_job_close
3299 **********************************************************************
3300 *
3301 *********************************************************************/
3302 void hb_job_close( hb_job_t ** _j )
3303 {
3304 if (_j && *_j)
3305 {
3306 job_clean(*_j);
3307 free( *_j );
3308 _j = NULL;
3309 }
3310 }
3311
3312 void hb_job_set_encoder_preset(hb_job_t *job, const char *preset)
3313 {
3314 if (job != NULL)
3315 {
3316 if (preset == NULL || preset[0] == 0)
3317 {
3318 preset = NULL;
3319 }
3320 hb_update_str(&job->encoder_preset, preset);
3321 }
3322 }
3323
3324 void hb_job_set_encoder_tune(hb_job_t *job, const char *tune)
3325 {
3326 if (job != NULL)
3327 {
3328 if (tune == NULL || tune[0] == 0)
3329 {
3330 tune = NULL;
3331 }
3332 hb_update_str(&job->encoder_tune, tune);
3333 }
3334 }
3335
3336 void hb_job_set_encoder_options(hb_job_t *job, const char *options)
3337 {
3338 if (job != NULL)
3339 {
3340 if (options == NULL || options[0] == 0)
3341 {
3342 options = NULL;
3343 }
3344 hb_update_str(&job->encoder_options, options);
3345 }
3346 }
3347
3348 void hb_job_set_encoder_profile(hb_job_t *job, const char *profile)
3349 {
3350 if (job != NULL)
3351 {
3352 if (profile == NULL || profile[0] == 0)
3353 {
3354 profile = NULL;
3355 }
3356 hb_update_str(&job->encoder_profile, profile);
3357 }
3358 }
3359
3360 void hb_job_set_encoder_level(hb_job_t *job, const char *level)
3361 {
3362 if (job != NULL)
3363 {
3364 if (level == NULL || level[0] == 0)
3365 {
3366 level = NULL;
3367 }
3368 hb_update_str(&job->encoder_level, level);
3369 }
3370 }
3371
3372 void hb_job_set_file(hb_job_t *job, const char *file)
3373 {
3374 if (job != NULL)
3375 {
3376 hb_update_str(&job->file, file);
3377 }
3378 }
3379
3380 hb_filter_object_t * hb_filter_copy( hb_filter_object_t * filter )
3381 {
3382 if( filter == NULL )
3383 return NULL;
3384
3385 hb_filter_object_t * filter_copy = malloc( sizeof( hb_filter_object_t ) );
3386 memcpy( filter_copy, filter, sizeof( hb_filter_object_t ) );
3387 if( filter->settings )
3388 filter_copy->settings = strdup( filter->settings );
3389 return filter_copy;
3390 }
3391
3392 /**********************************************************************
3393 * hb_filter_list_copy
3394 **********************************************************************
3395 *
3396 *********************************************************************/
3397 hb_list_t *hb_filter_list_copy(const hb_list_t *src)
3398 {
3399 hb_list_t *list = hb_list_init();
3400 hb_filter_object_t *filter = NULL;
3401 int i;
3402
3403 if( src )
3404 {
3405 for( i = 0; i < hb_list_count(src); i++ )
3406 {
3407 if( ( filter = hb_list_item( src, i ) ) )
3408 {
3409 hb_list_add( list, hb_filter_copy(filter) );
3410 }
3411 }
3412 }
3413 return list;
3414 }
3415
3416 /**
3417 * Gets a filter object with the given type
3418 * @param filter_id The type of filter to get.
3419 * @returns The requested filter object.
3420 */
3421 hb_filter_object_t * hb_filter_init( int filter_id )
3422 {
3423 hb_filter_object_t * filter;
3424 switch( filter_id )
3425 {
3426 case HB_FILTER_DETELECINE:
3427 filter = &hb_filter_detelecine;
3428 break;
3429
3430 case HB_FILTER_DECOMB:
3431 filter = &hb_filter_decomb;
3432 break;
3433
3434 case HB_FILTER_DEINTERLACE:
3435 filter = &hb_filter_deinterlace;
3436 break;
3437
3438 case HB_FILTER_VFR:
3439 filter = &hb_filter_vfr;
3440 break;
3441
3442 case HB_FILTER_DEBLOCK:
3443 filter = &hb_filter_deblock;
3444 break;
3445
3446 case HB_FILTER_DENOISE:
3447 filter = &hb_filter_denoise;
3448 break;
3449
3450 case HB_FILTER_NLMEANS:
3451 filter = &hb_filter_nlmeans;
3452 break;
3453
3454 case HB_FILTER_RENDER_SUB:
3455 filter = &hb_filter_render_sub;
3456 break;
3457
3458 case HB_FILTER_CROP_SCALE:
3459 filter = &hb_filter_crop_scale;
3460 break;
3461
3462 case HB_FILTER_ROTATE:
3463 filter = &hb_filter_rotate;
3464 break;
3465
3466 #ifdef USE_QSV
3467 case HB_FILTER_QSV:
3468 filter = &hb_filter_qsv;
3469 break;
3470
3471 case HB_FILTER_QSV_PRE:
3472 filter = &hb_filter_qsv_pre;
3473 break;
3474
3475 case HB_FILTER_QSV_POST:
3476 filter = &hb_filter_qsv_post;
3477 break;
3478 #endif
3479
3480 default:
3481 filter = NULL;
3482 break;
3483 }
3484 return hb_filter_copy( filter );
3485 }
3486
3487 /**********************************************************************
3488 * hb_filter_close
3489 **********************************************************************
3490 *
3491 *********************************************************************/
3492 void hb_filter_close( hb_filter_object_t ** _f )
3493 {
3494 hb_filter_object_t * f = *_f;
3495
3496 if( f->settings )
3497 free( f->settings );
3498
3499 free( f );
3500 *_f = NULL;
3501 }
3502
3503 /**********************************************************************
3504 * hb_chapter_copy
3505 **********************************************************************
3506 *
3507 *********************************************************************/
3508 hb_chapter_t *hb_chapter_copy(const hb_chapter_t *src)
3509 {
3510 hb_chapter_t *chap = NULL;
3511
3512 if ( src )
3513 {
3514 chap = calloc( 1, sizeof(*chap) );
3515 memcpy( chap, src, sizeof(*chap) );
3516 if ( src->title )
3517 {
3518 chap->title = strdup( src->title );
3519 }
3520 }
3521 return chap;
3522 }
3523
3524 /**********************************************************************
3525 * hb_chapter_list_copy
3526 **********************************************************************
3527 *
3528 *********************************************************************/
3529 hb_list_t *hb_chapter_list_copy(const hb_list_t *src)
3530 {
3531 hb_list_t *list = hb_list_init();
3532 hb_chapter_t *chapter = NULL;
3533 int i;
3534
3535 if( src )
3536 {
3537 for( i = 0; i < hb_list_count(src); i++ )
3538 {
3539 if( ( chapter = hb_list_item( src, i ) ) )
3540 {
3541 hb_list_add( list, hb_chapter_copy(chapter) );
3542 }
3543 }
3544 }
3545 return list;
3546 }
3547
3548 /**********************************************************************
3549 * hb_chapter_close
3550 **********************************************************************
3551 *
3552 *********************************************************************/
3553 void hb_chapter_close(hb_chapter_t **chap)
3554 {
3555 if ( chap && *chap )
3556 {
3557 free((*chap)->title);
3558 free(*chap);
3559 *chap = NULL;
3560 }
3561 }
3562
3563 /**********************************************************************
3564 * hb_chapter_set_title
3565 **********************************************************************
3566 *
3567 *********************************************************************/
3568 void hb_chapter_set_title( hb_chapter_t *chapter, const char *title )
3569 {
3570 if ( chapter )
3571 {
3572 hb_update_str( &chapter->title, title );
3573 }
3574 }
3575
3576 /**********************************************************************
3577 * hb_chapter_set_title_by_index
3578 **********************************************************************
3579 * Applies information from the given job to the official job instance.
3580 * @param job Handle to hb_job_t.
3581 * @param chapter The chapter to apply the name to (1-based).
3582 * @param titel to apply.
3583 *********************************************************************/
3584 void hb_chapter_set_title_by_index( hb_job_t * job, int chapter_index, const char * title )
3585 {
3586 hb_chapter_t * chapter = hb_list_item( job->list_chapter, chapter_index - 1 );
3587 hb_chapter_set_title( chapter, title );
3588 }
3589
3590 /**********************************************************************
3591 * hb_audio_copy
3592 **********************************************************************
3593 *
3594 *********************************************************************/
3595 hb_audio_t *hb_audio_copy(const hb_audio_t *src)
3596 {
3597 hb_audio_t *audio = NULL;
3598
3599 if( src )
3600 {
3601 audio = calloc(1, sizeof(*audio));
3602 memcpy(audio, src, sizeof(*audio));
3603 if ( src->config.out.name )
3604 {
3605 audio->config.out.name = strdup(src->config.out.name);
3606 }
3607 }
3608 return audio;
3609 }
3610
3611 /**********************************************************************
3612 * hb_audio_list_copy
3613 **********************************************************************
3614 *
3615 *********************************************************************/
3616 hb_list_t *hb_audio_list_copy(const hb_list_t *src)
3617 {
3618 hb_list_t *list = hb_list_init();
3619 hb_audio_t *audio = NULL;
3620 int i;
3621
3622 if( src )
3623 {
3624 for( i = 0; i < hb_list_count(src); i++ )
3625 {
3626 if( ( audio = hb_list_item( src, i ) ) )
3627 {
3628 hb_list_add( list, hb_audio_copy(audio) );
3629 }
3630 }
3631 }
3632 return list;
3633 }
3634
3635 /**********************************************************************
3636 * hb_audio_close
3637 **********************************************************************
3638 *
3639 *********************************************************************/
3640 void hb_audio_close( hb_audio_t **audio )
3641 {
3642 if ( audio && *audio )
3643 {
3644 free((*audio)->config.out.name);
3645 free(*audio);
3646 *audio = NULL;
3647 }
3648 }
3649
3650 /**********************************************************************
3651 * hb_audio_new
3652 **********************************************************************
3653 *
3654 *********************************************************************/
3655 void hb_audio_config_init(hb_audio_config_t * audiocfg)
3656 {
3657 /* Set read-only paramaters to invalid values */
3658 audiocfg->in.codec = 0;
3659 audiocfg->in.codec_param = 0;
3660 audiocfg->in.reg_desc = 0;
3661 audiocfg->in.stream_type = 0;
3662 audiocfg->in.substream_type = 0;
3663 audiocfg->in.version = 0;
3664 audiocfg->in.flags = 0;
3665 audiocfg->in.mode = 0;
3666 audiocfg->in.samplerate = -1;
3667 audiocfg->in.sample_bit_depth = 0;
3668 audiocfg->in.samples_per_frame = -1;
3669 audiocfg->in.bitrate = -1;
3670 audiocfg->in.matrix_encoding = AV_MATRIX_ENCODING_NONE;
3671 audiocfg->in.channel_layout = 0;
3672 audiocfg->in.channel_map = NULL;
3673 audiocfg->lang.description[0] = 0;
3674 audiocfg->lang.simple[0] = 0;
3675 audiocfg->lang.iso639_2[0] = 0;
3676
3677 /* Initalize some sensible defaults */
3678 audiocfg->in.track = audiocfg->out.track = 0;
3679 audiocfg->out.codec = hb_audio_encoder_get_default(HB_MUX_MP4); // default container
3680 audiocfg->out.samplerate = -1;
3681 audiocfg->out.samples_per_frame = -1;
3682 audiocfg->out.bitrate = -1;
3683 audiocfg->out.quality = HB_INVALID_AUDIO_QUALITY;
3684 audiocfg->out.compression_level = -1;
3685 audiocfg->out.mixdown = HB_INVALID_AMIXDOWN;
3686 audiocfg->out.dynamic_range_compression = 0;
3687 audiocfg->out.gain = 0;
3688 audiocfg->out.normalize_mix_level = 0;
3689 audiocfg->out.dither_method = hb_audio_dither_get_default();
3690 audiocfg->out.name = NULL;
3691 }
3692
3693 /**********************************************************************
3694 * hb_audio_add
3695 **********************************************************************
3696 *
3697 *********************************************************************/
3698 int hb_audio_add(const hb_job_t * job, const hb_audio_config_t * audiocfg)
3699 {
3700 hb_title_t *title = job->title;
3701 hb_audio_t *audio;
3702
3703 audio = hb_audio_copy( hb_list_item( title->list_audio, audiocfg->in.track ) );
3704 if( audio == NULL )
3705 {
3706 /* We fail! */
3707 return 0;
3708 }
3709
3710 if( (audiocfg->in.bitrate != -1) && (audiocfg->in.codec != 0xDEADBEEF) )
3711 {
3712 /* This most likely means the client didn't call hb_audio_config_init
3713 * so bail. */
3714 return 0;
3715 }
3716
3717 /* Set the job's "in track" to the value passed in audiocfg.
3718 * HandBrakeCLI assumes this value is preserved in the jobs
3719 * audio list, but in.track in the title's audio list is not
3720 * required to be the same. */
3721 // "track" in title->list_audio is an index into the source's tracks.
3722 // "track" in job->list_audio is an index into title->list_audio
3723 audio->config.in.track = audiocfg->in.track;
3724
3725 /* Really shouldn't ignore the passed out track, but there is currently no
3726 * way to handle duplicates or out-of-order track numbers. */
3727 audio->config.out.track = hb_list_count(job->list_audio) + 1;
3728 audio->config.out.codec = audiocfg->out.codec;
3729 if((audiocfg->out.codec & HB_ACODEC_PASS_FLAG) &&
3730 ((audiocfg->out.codec == HB_ACODEC_AUTO_PASS) ||
3731 (audiocfg->out.codec & audio->config.in.codec & HB_ACODEC_PASS_MASK)))
3732 {
3733 /* Pass-through, copy from input. */
3734 audio->config.out.samplerate = audio->config.in.samplerate;
3735 audio->config.out.bitrate = audio->config.in.bitrate;
3736 audio->config.out.mixdown = HB_AMIXDOWN_NONE;
3737 audio->config.out.dynamic_range_compression = 0;
3738 audio->config.out.gain = 0;
3739 audio->config.out.normalize_mix_level = 0;
3740 audio->config.out.compression_level = -1;
3741 audio->config.out.quality = HB_INVALID_AUDIO_QUALITY;
3742 audio->config.out.dither_method = hb_audio_dither_get_default();
3743 }
3744 else
3745 {
3746 /* Non pass-through, use what is given. */
3747 audio->config.out.codec &= ~HB_ACODEC_PASS_FLAG;
3748 audio->config.out.samplerate = audiocfg->out.samplerate;
3749 audio->config.out.bitrate = audiocfg->out.bitrate;
3750 audio->config.out.compression_level = audiocfg->out.compression_level;
3751 audio->config.out.quality = audiocfg->out.quality;
3752 audio->config.out.dynamic_range_compression = audiocfg->out.dynamic_range_compression;
3753 audio->config.out.mixdown = audiocfg->out.mixdown;
3754 audio->config.out.gain = audiocfg->out.gain;
3755 audio->config.out.normalize_mix_level = audiocfg->out.normalize_mix_level;
3756 audio->config.out.dither_method = audiocfg->out.dither_method;
3757 }
3758 if (audiocfg->out.name && *audiocfg->out.name)
3759 {
3760 audio->config.out.name = strdup(audiocfg->out.name);
3761 }
3762
3763 hb_list_add(job->list_audio, audio);
3764 return 1;
3765 }
3766
3767 hb_audio_config_t * hb_list_audio_config_item(hb_list_t * list, int i)
3768 {
3769 hb_audio_t *audio = NULL;
3770
3771 if( (audio = hb_list_item(list, i)) )
3772 return &(audio->config);
3773
3774 return NULL;
3775 }
3776
3777 /**********************************************************************
3778 * hb_subtitle_copy
3779 **********************************************************************
3780 *
3781 *********************************************************************/
3782 hb_subtitle_t *hb_subtitle_copy(const hb_subtitle_t *src)
3783 {
3784 hb_subtitle_t *subtitle = NULL;
3785
3786 if( src )
3787 {
3788 subtitle = calloc(1, sizeof(*subtitle));
3789 memcpy(subtitle, src, sizeof(*subtitle));
3790 if ( src->extradata )
3791 {
3792 subtitle->extradata = malloc( src->extradata_size );
3793 memcpy( subtitle->extradata, src->extradata, src->extradata_size );
3794 }
3795 }
3796 return subtitle;
3797 }
3798
3799 /**********************************************************************
3800 * hb_subtitle_list_copy
3801 **********************************************************************
3802 *
3803 *********************************************************************/
3804 hb_list_t *hb_subtitle_list_copy(const hb_list_t *src)
3805 {
3806 hb_list_t *list = hb_list_init();
3807 hb_subtitle_t *subtitle = NULL;
3808 int i;
3809
3810 if( src )
3811 {
3812 for( i = 0; i < hb_list_count(src); i++ )
3813 {
3814 if( ( subtitle = hb_list_item( src, i ) ) )
3815 {
3816 hb_list_add( list, hb_subtitle_copy(subtitle) );
3817 }
3818 }
3819 }
3820 return list;
3821 }
3822
3823 /**********************************************************************
3824 * hb_subtitle_close
3825 **********************************************************************
3826 *
3827 *********************************************************************/
3828 void hb_subtitle_close( hb_subtitle_t **sub )
3829 {
3830 if ( sub && *sub )
3831 {
3832 free ((*sub)->extradata);
3833 free(*sub);
3834 *sub = NULL;
3835 }
3836 }
3837
3838 /**********************************************************************
3839 * hb_subtitle_add
3840 **********************************************************************
3841 *
3842 *********************************************************************/
3843 int hb_subtitle_add_ssa_header(hb_subtitle_t *subtitle, const char *font,
3844 int fs, int w, int h)
3845 {
3846 // Free any pre-existing extradata
3847 free(subtitle->extradata);
3848
3849 // SRT subtitles are represented internally as SSA
3850 // Create an SSA header
3851 const char * ssa_header =
3852 "[Script Info]\r\n"
3853 "ScriptType: v4.00+\r\n"
3854 "Collisions: Normal\r\n"
3855 "PlayResX: %d\r\n"
3856 "PlayResY: %d\r\n"
3857 "Timer: 100.0\r\n"
3858 "WrapStyle: 0\r\n"
3859 "\r\n"
3860 "[V4+ Styles]\r\n"
3861 "Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\r\n"
3862 "Style: Default,%s,%d,&H00FFFFFF,&H00FFFFFF,&H000F0F0F,&H000F0F0F,0,0,0,0,100,100,0,0.00,1,2,3,2,20,20,20,0\r\n";
3863
3864 subtitle->extradata = (uint8_t*)hb_strdup_printf(ssa_header, w, h, font, fs);
3865 if (subtitle->extradata == NULL)
3866 {
3867 hb_error("hb_subtitle_add_ssa_header: malloc failed");
3868 return 0;
3869 }
3870 subtitle->extradata_size = strlen((char*)subtitle->extradata) + 1;
3871
3872 return 1;
3873 }
3874
3875 int hb_subtitle_add(const hb_job_t * job, const hb_subtitle_config_t * subtitlecfg, int track)
3876 {
3877 hb_title_t *title = job->title;
3878 hb_subtitle_t *subtitle;
3879
3880 subtitle = hb_subtitle_copy( hb_list_item( title->list_subtitle, track ) );
3881 if( subtitle == NULL )
3882 {
3883 /* We fail! */
3884 return 0;
3885 }
3886
3887 // "track" in title->list_audio is an index into the source's tracks.
3888 // "track" in job->list_audio is an index into title->list_audio
3889 subtitle->track = track;
3890 subtitle->config = *subtitlecfg;
3891 subtitle->out_track = hb_list_count(job->list_subtitle) + 1;
3892 hb_list_add(job->list_subtitle, subtitle);
3893 return 1;
3894 }
3895
3896 int hb_srt_add( const hb_job_t * job,
3897 const hb_subtitle_config_t * subtitlecfg,
3898 const char *lang )
3899 {
3900 hb_subtitle_t *subtitle;
3901 iso639_lang_t *language = NULL;
3902
3903 subtitle = calloc( 1, sizeof( *subtitle ) );
3904 if (subtitle == NULL)
3905 {
3906 hb_error("hb_srt_add: malloc failed");
3907 return 0;
3908 }
3909
3910 subtitle->id = (hb_list_count(job->list_subtitle) << 8) | 0xFF;
3911 subtitle->format = TEXTSUB;
3912 subtitle->source = SRTSUB;
3913 subtitle->codec = WORK_DECSRTSUB;
3914
3915 language = lang_for_code2(lang);
3916 if (language == NULL)
3917 {
3918 hb_log("hb_srt_add: unknown language code (%s)", lang);
3919 language = lang_for_code2("und");
3920 }
3921 strcpy(subtitle->lang, language->eng_name);
3922 strcpy(subtitle->iso639_2, language->iso639_2);
3923
3924 subtitle->config = *subtitlecfg;
3925 hb_list_add(job->list_subtitle, subtitle);
3926
3927 return 1;
3928 }
3929
3930 int hb_subtitle_can_force( int source )
3931 {
3932 return source == VOBSUB || source == PGSSUB;
3933 }
3934
3935 int hb_subtitle_can_burn( int source )
3936 {
3937 return source == VOBSUB || source == PGSSUB || source == SSASUB ||
3938 source == SRTSUB || source == CC608SUB || source == UTF8SUB ||
3939 source == TX3GSUB;
3940 }
3941
3942 int hb_subtitle_can_pass( int source, int mux )
3943 {
3944 switch (mux)
3945 {
3946 case HB_MUX_AV_MKV:
3947 switch( source )
3948 {
3949 case PGSSUB:
3950 case VOBSUB:
3951 case SSASUB:
3952 case SRTSUB:
3953 case UTF8SUB:
3954 case TX3GSUB:
3955 case CC608SUB:
3956 case CC708SUB:
3957 return 1;
3958
3959 default:
3960 return 0;
3961 } break;
3962
3963 case HB_MUX_AV_MP4:
3964 switch( source )
3965 {
3966 case VOBSUB:
3967 case SSASUB:
3968 case SRTSUB:
3969 case UTF8SUB:
3970 case TX3GSUB:
3971 case CC608SUB:
3972 case CC708SUB:
3973 return 1;
3974
3975 default:
3976 return 0;
3977 } break;
3978
3979 default:
3980 // Internal error. Should never get here.
3981 hb_error("internel error. Bad mux %d\n", mux);
3982 return 0;
3983 }
3984 }
3985
3986 int hb_audio_can_apply_drc(uint32_t codec, uint32_t codec_param, int encoder)
3987 {
3988 if (encoder & HB_ACODEC_PASS_FLAG)
3989 {
3990 // can't apply DRC to passthrough audio
3991 return 0;
3992 }
3993 else if (codec & HB_ACODEC_FF_MASK)
3994 {
3995 return (codec_param == AV_CODEC_ID_AC3 ||
3996 codec_param == AV_CODEC_ID_EAC3);
3997 }
3998 else if (codec == HB_ACODEC_AC3)
3999 {
4000 return 1;
4001 }
4002 else
4003 {
4004 return 0;
4005 }
4006 }
4007
4008 int hb_audio_can_apply_drc2(hb_handle_t *h, int title_idx, int audio_idx, int encoder)
4009 {
4010 hb_title_t *title = hb_find_title_by_index(h, title_idx);
4011 if (title == NULL)
4012 return 0;
4013
4014 hb_audio_t *audio = hb_list_item(title->list_audio, audio_idx);
4015 if (audio == NULL)
4016 return 0;
4017
4018 return hb_audio_can_apply_drc(audio->config.in.codec,
4019 audio->config.in.codec_param, encoder);
4020 }
4021
4022 /**********************************************************************
4023 * hb_metadata_init
4024 **********************************************************************
4025 *
4026 *********************************************************************/
4027 hb_metadata_t *hb_metadata_init()
4028 {
4029 hb_metadata_t *metadata = calloc( 1, sizeof(*metadata) );
4030 return metadata;
4031 }
4032
4033 /**********************************************************************
4034 * hb_metadata_copy
4035 **********************************************************************
4036 *
4037 *********************************************************************/
4038 hb_metadata_t *hb_metadata_copy( const hb_metadata_t *src )
4039 {
4040 hb_metadata_t *metadata = NULL;
4041
4042 if ( src )
4043 {
4044 metadata = calloc( 1, sizeof(*metadata) );
4045 if ( src->name )
4046 {
4047 metadata->name = strdup(src->name);
4048 }
4049 if ( src->artist )
4050 {
4051 metadata->artist = strdup(src->artist);
4052 }
4053 if ( src->album_artist )
4054 {
4055 metadata->album_artist = strdup(src->album_artist);
4056 }
4057 if ( src->composer )
4058 {
4059 metadata->composer = strdup(src->composer);
4060 }
4061 if ( src->release_date )
4062 {
4063 metadata->release_date = strdup(src->release_date);
4064 }
4065 if ( src->comment )
4066 {
4067 metadata->comment = strdup(src->comment);
4068 }
4069 if ( src->album )
4070 {
4071 metadata->album = strdup(src->album);
4072 }
4073 if ( src->genre )
4074 {
4075 metadata->genre = strdup(src->genre);
4076 }
4077 if ( src->description )
4078 {
4079 metadata->description = strdup(src->description);
4080 }
4081 if ( src->long_description )
4082 {
4083 metadata->long_description = strdup(src->long_description);
4084 }
4085 if ( src->list_coverart )
4086 {
4087 int ii;
4088 for ( ii = 0; ii < hb_list_count( src->list_coverart ); ii++ )
4089 {
4090 hb_coverart_t *art = hb_list_item( src->list_coverart, ii );
4091 hb_metadata_add_coverart(
4092 metadata, art->data, art->size, art->type );
4093 }
4094 }
4095 }
4096 return metadata;
4097 }
4098
4099 /**********************************************************************
4100 * hb_metadata_close
4101 **********************************************************************
4102 *
4103 *********************************************************************/
4104 void hb_metadata_close( hb_metadata_t **_m )
4105 {
4106 if ( _m && *_m )
4107 {
4108 hb_metadata_t *m = *_m;
4109 hb_coverart_t *art;
4110
4111 free( m->name );
4112 free( m->artist );
4113 free( m->composer );
4114 free( m->release_date );
4115 free( m->comment );
4116 free( m->album );
4117 free( m->album_artist );
4118 free( m->genre );
4119 free( m->description );
4120 free( m->long_description );
4121
4122 if ( m->list_coverart )
4123 {
4124 while( ( art = hb_list_item( m->list_coverart, 0 ) ) )
4125 {
4126 hb_list_rem( m->list_coverart, art );
4127 free( art->data );
4128 free( art );
4129 }
4130 hb_list_close( &m->list_coverart );
4131 }
4132
4133 free( m );
4134 *_m = NULL;
4135 }
4136 }
4137
4138 /**********************************************************************
4139 * hb_metadata_set_*
4140 **********************************************************************
4141 *
4142 *********************************************************************/
4143 void hb_metadata_set_name( hb_metadata_t *metadata, const char *name )
4144 {
4145 if ( metadata )
4146 {
4147 hb_update_str( &metadata->name, name );
4148 }
4149 }
4150
4151 void hb_metadata_set_artist( hb_metadata_t *metadata, const char *artist )
4152 {
4153 if ( metadata )
4154 {
4155 hb_update_str( &metadata->artist, artist );
4156 }
4157 }
4158
4159 void hb_metadata_set_composer( hb_metadata_t *metadata, const char *composer )
4160 {
4161 if ( metadata )
4162 {
4163 hb_update_str( &metadata->composer, composer );
4164 }
4165 }
4166
4167 void hb_metadata_set_release_date( hb_metadata_t *metadata, const char *release_date )
4168 {
4169 if ( metadata )
4170 {
4171 hb_update_str( &metadata->release_date, release_date );
4172 }
4173 }
4174
4175 void hb_metadata_set_comment( hb_metadata_t *metadata, const char *comment )
4176 {
4177 if ( metadata )
4178 {
4179 hb_update_str( &metadata->comment, comment );
4180 }
4181 }
4182
4183 void hb_metadata_set_genre( hb_metadata_t *metadata, const char *genre )
4184 {
4185 if ( metadata )
4186 {
4187 hb_update_str( &metadata->genre, genre );
4188 }
4189 }
4190
4191 void hb_metadata_set_album( hb_metadata_t *metadata, const char *album )
4192 {
4193 if ( metadata )
4194 {
4195 hb_update_str( &metadata->album, album );
4196 }
4197 }
4198
4199 void hb_metadata_set_album_artist( hb_metadata_t *metadata, const char *album_artist )
4200 {
4201 if ( metadata )
4202 {
4203 hb_update_str( &metadata->album_artist, album_artist );
4204 }
4205 }
4206
4207 void hb_metadata_set_description( hb_metadata_t *metadata, const char *description )
4208 {
4209 if ( metadata )
4210 {
4211 hb_update_str( &metadata->description, description );
4212 }
4213 }
4214
4215 void hb_metadata_set_long_description( hb_metadata_t *metadata, const char *long_description )
4216 {
4217 if ( metadata )
4218 {
4219 hb_update_str( &metadata->long_description, long_description );
4220 }
4221 }
4222
4223 void hb_metadata_add_coverart( hb_metadata_t *metadata, const uint8_t *data, int size, int type )
4224 {
4225 if ( metadata )
4226 {
4227 if ( metadata->list_coverart == NULL )
4228 {
4229 metadata->list_coverart = hb_list_init();
4230 }
4231 hb_coverart_t *art = calloc( 1, sizeof(hb_coverart_t) );
4232 art->data = malloc( size );
4233 memcpy( art->data, data, size );
4234 art->size = size;
4235 art->type = type;
4236 hb_list_add( metadata->list_coverart, art );
4237 }
4238 }
4239
4240 void hb_metadata_rem_coverart( hb_metadata_t *metadata, int idx )
4241 {
4242 if ( metadata )
4243 {
4244 hb_coverart_t *art = hb_list_item( metadata->list_coverart, idx );
4245 if ( art )
4246 {
4247 hb_list_rem( metadata->list_coverart, art );
4248 free( art->data );
4249 free( art );
4250 }
4251 }
4252 }
4253
4254 char * hb_strdup_vaprintf( const char * fmt, va_list args )
4255 {
4256 int len;
4257 int size = 256;
4258 char * str;
4259 char * tmp;
4260 va_list copy;
4261
4262 str = malloc( size );
4263 if ( str == NULL )
4264 return NULL;
4265
4266 while (1)
4267 {
4268 // vsnprintf modifies it's va_list. Since we may need to do this
4269 // more than once, use a copy of the va_list.
4270 va_copy(copy, args);
4271
4272 /* Try to print in the allocated space. */
4273 len = vsnprintf( str, size, fmt, copy );
4274
4275 /* If that worked, return the string. */
4276 if ( len > -1 && len < size )
4277 {
4278 return str;
4279 }
4280
4281 /* Else try again with more space. */
4282 if ( len > -1 ) /* glibc 2.1 */
4283 size = len + 1; /* precisely what is needed */
4284 else /* glibc 2.0 */
4285 size *= 2; /* twice the old size */
4286 tmp = realloc( str, size );
4287 if ( tmp == NULL )
4288 {
4289 free( str );
4290 return NULL;
4291 }
4292 else
4293 str = tmp;
4294 }
4295
4296 return str;
4297 }
4298
4299 char * hb_strdup_printf( const char * fmt, ... )
4300 {
4301 char * str;
4302 va_list args;
4303
4304 va_start( args, fmt );
4305 str = hb_strdup_vaprintf( fmt, args );
4306 va_end( args );
4307
4308 return str;
4309 }
4310
4311 char * hb_strncat_dup( const char * s1, const char * s2, size_t n )
4312 {
4313 size_t len;
4314 char * str;
4315
4316 len = 0;
4317 if( s1 )
4318 len += strlen( s1 );
4319 if( s2 )
4320 len += MAX( strlen( s2 ), n );
4321 if( !len )
4322 return NULL;
4323
4324 str = malloc( len + 1 );
4325 if( !str )
4326 return NULL;
4327
4328 if( s1 )
4329 strcpy( str, s1 );
4330 else
4331 strcpy( str, "" );
4332 strncat( str, s2, n );
4333 return str;
4334 }
4335
4336 /**********************************************************************
4337 * hb_attachment_copy
4338 **********************************************************************
4339 *
4340 *********************************************************************/
4341 hb_attachment_t *hb_attachment_copy(const hb_attachment_t *src)
4342 {
4343 hb_attachment_t *attachment = NULL;
4344
4345 if( src )
4346 {
4347 attachment = calloc(1, sizeof(*attachment));
4348 memcpy(attachment, src, sizeof(*attachment));
4349 if ( src->name )
4350 {
4351 attachment->name = strdup( src->name );
4352 }
4353 if ( src->data )
4354 {
4355 attachment->data = malloc( src->size );
4356 memcpy( attachment->data, src->data, src->size );
4357 }
4358 }
4359 return attachment;
4360 }
4361
4362 /**********************************************************************
4363 * hb_attachment_list_copy
4364 **********************************************************************
4365 *
4366 *********************************************************************/
4367 hb_list_t *hb_attachment_list_copy(const hb_list_t *src)
4368 {
4369 hb_list_t *list = hb_list_init();
4370 hb_attachment_t *attachment = NULL;
4371 int i;
4372
4373 if( src )
4374 {
4375 for( i = 0; i < hb_list_count(src); i++ )
4376 {
4377 if( ( attachment = hb_list_item( src, i ) ) )
4378 {
4379 hb_list_add( list, hb_attachment_copy(attachment) );
4380 }
4381 }
4382 }
4383 return list;
4384 }
4385
4386 /**********************************************************************
4387 * hb_attachment_close
4388 **********************************************************************
4389 *
4390 *********************************************************************/
4391 void hb_attachment_close( hb_attachment_t **attachment )
4392 {
4393 if ( attachment && *attachment )
4394 {
4395 free((*attachment)->data);
4396 free((*attachment)->name);
4397 free(*attachment);
4398 *attachment = NULL;
4399 }
4400 }
4401
4402 /**********************************************************************
4403 * hb_yuv2rgb
4404 **********************************************************************
4405 * Converts a YCrCb pixel to an RGB pixel.
4406 *
4407 * This conversion is lossy (due to rounding and clamping).
4408 *
4409 * Algorithm:
4410 * http://en.wikipedia.org/w/index.php?title=YCbCr&oldid=361987695#Technical_details
4411 *********************************************************************/
4412 int hb_yuv2rgb(int yuv)
4413 {
4414 double y, Cr, Cb;
4415 int r, g, b;
4416
4417 y = (yuv >> 16) & 0xff;
4418 Cr = (yuv >> 8) & 0xff;
4419 Cb = (yuv ) & 0xff;
4420
4421 r = 1.164 * (y - 16) + 1.596 * (Cr - 128);
4422 g = 1.164 * (y - 16) - 0.392 * (Cb - 128) - 0.813 * (Cr - 128);
4423 b = 1.164 * (y - 16) + 2.017 * (Cb - 128);
4424
4425 r = (r < 0) ? 0 : r;
4426 g = (g < 0) ? 0 : g;
4427 b = (b < 0) ? 0 : b;
4428
4429 r = (r > 255) ? 255 : r;
4430 g = (g > 255) ? 255 : g;
4431 b = (b > 255) ? 255 : b;
4432
4433 return (r << 16) | (g << 8) | b;
4434 }
4435
4436 /**********************************************************************
4437 * hb_rgb2yuv
4438 **********************************************************************
4439 * Converts an RGB pixel to a YCrCb pixel.
4440 *
4441 * This conversion is lossy (due to rounding and clamping).
4442 *
4443 * Algorithm:
4444 * http://en.wikipedia.org/w/index.php?title=YCbCr&oldid=361987695#Technical_details
4445 *********************************************************************/
4446 int hb_rgb2yuv(int rgb)
4447 {
4448 double r, g, b;
4449 int y, Cr, Cb;
4450
4451 r = (rgb >> 16) & 0xff;
4452 g = (rgb >> 8) & 0xff;
4453 b = (rgb ) & 0xff;
4454
4455 y = 16. + ( 0.257 * r) + (0.504 * g) + (0.098 * b);
4456 Cb = 128. + (-0.148 * r) - (0.291 * g) + (0.439 * b);
4457 Cr = 128. + ( 0.439 * r) - (0.368 * g) - (0.071 * b);
4458
4459 y = (y < 0) ? 0 : y;
4460 Cb = (Cb < 0) ? 0 : Cb;
4461 Cr = (Cr < 0) ? 0 : Cr;
4462
4463 y = (y > 255) ? 255 : y;
4464 Cb = (Cb > 255) ? 255 : Cb;
4465 Cr = (Cr > 255) ? 255 : Cr;
4466
4467 return (y << 16) | (Cr << 8) | Cb;
4468 }
4469
4470 const char * hb_subsource_name( int source )
4471 {
4472 switch (source)
4473 {
4474 case VOBSUB:
4475 return "VOBSUB";
4476 case SRTSUB:
4477 return "SRT";
4478 case CC608SUB:
4479 return "CC";
4480 case CC708SUB:
4481 return "CC";
4482 case UTF8SUB:
4483 return "UTF-8";
4484 case TX3GSUB:
4485 return "TX3G";
4486 case SSASUB:
4487 return "SSA";
4488 case PGSSUB:
4489 return "PGS";
4490 default:
4491 return "Unknown";
4492 }
4493 }
4494
4495 void hb_hexdump( hb_debug_level_t level, const char * label, const uint8_t * data, int len )
4496 {
4497 int ii;
4498 char line[80], ascii[19], *p;
4499
4500 ascii[18] = 0;
4501 ascii[0] = '|';
4502 ascii[17] = '|';
4503 memset(&ascii[1], '.', 16);
4504 p = line;
4505 if( label )
4506 hb_deep_log(level, "++++ %s ++++", label);
4507 else
4508 hb_deep_log(level, "++++++++++++");
4509 for( ii = 0; ii < len; ii++ )
4510 {
4511 if( ( ii & 0x0f ) == 0x0f )
4512 {
4513 p += sprintf( p, "%02x", data[ii] );
4514 hb_deep_log( level, " %-50s%20s", line, ascii );
4515 memset(&ascii[1], '.', 16);
4516 p = line;
4517 }
4518 else if( ( ii & 0x07 ) == 0x07 )
4519 {
4520 p += sprintf( p, "%02x ", data[ii] );
4521 }
4522 else
4523 {
4524 p += sprintf( p, "%02x ", data[ii] );
4525 }
4526 if( isgraph( data[ii] ) )
4527 ascii[(ii & 0x0f) + 1] = data[ii];
4528 else
4529 ascii[(ii & 0x0f) + 1] = '.';
4530 }
4531 if( p != line )
4532 {
4533 hb_deep_log( level, " %-50s%20s", line, ascii );
4534 }
4535 }
GIT mirror of HandBrake SVN. Along with unofficial development branches.