GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
|||
2 |
/* |
||
3 |
* ffmpeg option parsing |
||
4 |
* |
||
5 |
* This file is part of FFmpeg. |
||
6 |
* |
||
7 |
* FFmpeg is free software; you can redistribute it and/or |
||
8 |
* modify it under the terms of the GNU Lesser General Public |
||
9 |
* License as published by the Free Software Foundation; either |
||
10 |
* version 2.1 of the License, or (at your option) any later version. |
||
11 |
* |
||
12 |
* FFmpeg is distributed in the hope that it will be useful, |
||
13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
15 |
* Lesser General Public License for more details. |
||
16 |
* |
||
17 |
* You should have received a copy of the GNU Lesser General Public |
||
18 |
* License along with FFmpeg; if not, write to the Free Software |
||
19 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
20 |
*/ |
||
21 |
|||
22 |
#include <stdint.h> |
||
23 |
|||
24 |
#include "ffmpeg.h" |
||
25 |
#include "cmdutils.h" |
||
26 |
|||
27 |
#include "libavformat/avformat.h" |
||
28 |
|||
29 |
#include "libavcodec/avcodec.h" |
||
30 |
|||
31 |
#include "libavfilter/avfilter.h" |
||
32 |
|||
33 |
#include "libavutil/avassert.h" |
||
34 |
#include "libavutil/avstring.h" |
||
35 |
#include "libavutil/avutil.h" |
||
36 |
#include "libavutil/channel_layout.h" |
||
37 |
#include "libavutil/intreadwrite.h" |
||
38 |
#include "libavutil/fifo.h" |
||
39 |
#include "libavutil/mathematics.h" |
||
40 |
#include "libavutil/opt.h" |
||
41 |
#include "libavutil/parseutils.h" |
||
42 |
#include "libavutil/pixdesc.h" |
||
43 |
#include "libavutil/pixfmt.h" |
||
44 |
|||
45 |
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass" |
||
46 |
|||
47 |
#define SPECIFIER_OPT_FMT_str "%s" |
||
48 |
#define SPECIFIER_OPT_FMT_i "%i" |
||
49 |
#define SPECIFIER_OPT_FMT_i64 "%"PRId64 |
||
50 |
#define SPECIFIER_OPT_FMT_ui64 "%"PRIu64 |
||
51 |
#define SPECIFIER_OPT_FMT_f "%f" |
||
52 |
#define SPECIFIER_OPT_FMT_dbl "%lf" |
||
53 |
|||
54 |
static const char *const opt_name_codec_names[] = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL}; |
||
55 |
static const char *const opt_name_audio_channels[] = {"ac", NULL}; |
||
56 |
static const char *const opt_name_audio_sample_rate[] = {"ar", NULL}; |
||
57 |
static const char *const opt_name_frame_rates[] = {"r", NULL}; |
||
58 |
static const char *const opt_name_max_frame_rates[] = {"fpsmax", NULL}; |
||
59 |
static const char *const opt_name_frame_sizes[] = {"s", NULL}; |
||
60 |
static const char *const opt_name_frame_pix_fmts[] = {"pix_fmt", NULL}; |
||
61 |
static const char *const opt_name_ts_scale[] = {"itsscale", NULL}; |
||
62 |
static const char *const opt_name_hwaccels[] = {"hwaccel", NULL}; |
||
63 |
static const char *const opt_name_hwaccel_devices[] = {"hwaccel_device", NULL}; |
||
64 |
static const char *const opt_name_hwaccel_output_formats[] = {"hwaccel_output_format", NULL}; |
||
65 |
static const char *const opt_name_autorotate[] = {"autorotate", NULL}; |
||
66 |
static const char *const opt_name_autoscale[] = {"autoscale", NULL}; |
||
67 |
static const char *const opt_name_max_frames[] = {"frames", "aframes", "vframes", "dframes", NULL}; |
||
68 |
static const char *const opt_name_bitstream_filters[] = {"bsf", "absf", "vbsf", NULL}; |
||
69 |
static const char *const opt_name_codec_tags[] = {"tag", "atag", "vtag", "stag", NULL}; |
||
70 |
static const char *const opt_name_sample_fmts[] = {"sample_fmt", NULL}; |
||
71 |
static const char *const opt_name_qscale[] = {"q", "qscale", NULL}; |
||
72 |
static const char *const opt_name_forced_key_frames[] = {"forced_key_frames", NULL}; |
||
73 |
static const char *const opt_name_force_fps[] = {"force_fps", NULL}; |
||
74 |
static const char *const opt_name_frame_aspect_ratios[] = {"aspect", NULL}; |
||
75 |
static const char *const opt_name_rc_overrides[] = {"rc_override", NULL}; |
||
76 |
static const char *const opt_name_intra_matrices[] = {"intra_matrix", NULL}; |
||
77 |
static const char *const opt_name_inter_matrices[] = {"inter_matrix", NULL}; |
||
78 |
static const char *const opt_name_chroma_intra_matrices[] = {"chroma_intra_matrix", NULL}; |
||
79 |
static const char *const opt_name_top_field_first[] = {"top", NULL}; |
||
80 |
static const char *const opt_name_presets[] = {"pre", "apre", "vpre", "spre", NULL}; |
||
81 |
static const char *const opt_name_copy_initial_nonkeyframes[] = {"copyinkfr", NULL}; |
||
82 |
static const char *const opt_name_copy_prior_start[] = {"copypriorss", NULL}; |
||
83 |
static const char *const opt_name_filters[] = {"filter", "af", "vf", NULL}; |
||
84 |
static const char *const opt_name_filter_scripts[] = {"filter_script", NULL}; |
||
85 |
static const char *const opt_name_reinit_filters[] = {"reinit_filter", NULL}; |
||
86 |
static const char *const opt_name_fix_sub_duration[] = {"fix_sub_duration", NULL}; |
||
87 |
static const char *const opt_name_canvas_sizes[] = {"canvas_size", NULL}; |
||
88 |
static const char *const opt_name_pass[] = {"pass", NULL}; |
||
89 |
static const char *const opt_name_passlogfiles[] = {"passlogfile", NULL}; |
||
90 |
static const char *const opt_name_max_muxing_queue_size[] = {"max_muxing_queue_size", NULL}; |
||
91 |
static const char *const opt_name_muxing_queue_data_threshold[] = {"muxing_queue_data_threshold", NULL}; |
||
92 |
static const char *const opt_name_guess_layout_max[] = {"guess_layout_max", NULL}; |
||
93 |
static const char *const opt_name_apad[] = {"apad", NULL}; |
||
94 |
static const char *const opt_name_discard[] = {"discard", NULL}; |
||
95 |
static const char *const opt_name_disposition[] = {"disposition", NULL}; |
||
96 |
static const char *const opt_name_time_bases[] = {"time_base", NULL}; |
||
97 |
static const char *const opt_name_enc_time_bases[] = {"enc_time_base", NULL}; |
||
98 |
|||
99 |
#define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\ |
||
100 |
{\ |
||
101 |
char namestr[128] = "";\ |
||
102 |
const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\ |
||
103 |
for (i = 0; opt_name_##name[i]; i++)\ |
||
104 |
av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\ |
||
105 |
av_log(NULL, AV_LOG_WARNING, "Multiple %s options specified for stream %d, only the last option '-%s%s%s "SPECIFIER_OPT_FMT_##type"' will be used.\n",\ |
||
106 |
namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\ |
||
107 |
} |
||
108 |
|||
109 |
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\ |
||
110 |
{\ |
||
111 |
int i, ret, matches = 0;\ |
||
112 |
SpecifierOpt *so;\ |
||
113 |
for (i = 0; i < o->nb_ ## name; i++) {\ |
||
114 |
char *spec = o->name[i].specifier;\ |
||
115 |
if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\ |
||
116 |
outvar = o->name[i].u.type;\ |
||
117 |
so = &o->name[i];\ |
||
118 |
matches++;\ |
||
119 |
} else if (ret < 0)\ |
||
120 |
exit_program(1);\ |
||
121 |
}\ |
||
122 |
if (matches > 1)\ |
||
123 |
WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\ |
||
124 |
} |
||
125 |
|||
126 |
#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\ |
||
127 |
{\ |
||
128 |
int i;\ |
||
129 |
for (i = 0; i < o->nb_ ## name; i++) {\ |
||
130 |
char *spec = o->name[i].specifier;\ |
||
131 |
if (!strcmp(spec, mediatype))\ |
||
132 |
outvar = o->name[i].u.type;\ |
||
133 |
}\ |
||
134 |
} |
||
135 |
|||
136 |
const HWAccel hwaccels[] = { |
||
137 |
#if CONFIG_VIDEOTOOLBOX |
||
138 |
{ "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX }, |
||
139 |
#endif |
||
140 |
#if CONFIG_LIBMFX |
||
141 |
{ "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV }, |
||
142 |
#endif |
||
143 |
{ 0 }, |
||
144 |
}; |
||
145 |
HWDevice *filter_hw_device; |
||
146 |
|||
147 |
char *vstats_filename; |
||
148 |
char *sdp_filename; |
||
149 |
|||
150 |
float audio_drift_threshold = 0.1; |
||
151 |
float dts_delta_threshold = 10; |
||
152 |
float dts_error_threshold = 3600*30; |
||
153 |
|||
154 |
int audio_volume = 256; |
||
155 |
int audio_sync_method = 0; |
||
156 |
int video_sync_method = VSYNC_AUTO; |
||
157 |
float frame_drop_threshold = 0; |
||
158 |
int do_deinterlace = 0; |
||
159 |
int do_benchmark = 0; |
||
160 |
int do_benchmark_all = 0; |
||
161 |
int do_hex_dump = 0; |
||
162 |
int do_pkt_dump = 0; |
||
163 |
int copy_ts = 0; |
||
164 |
int start_at_zero = 0; |
||
165 |
int copy_tb = -1; |
||
166 |
int debug_ts = 0; |
||
167 |
int exit_on_error = 0; |
||
168 |
int abort_on_flags = 0; |
||
169 |
int print_stats = -1; |
||
170 |
int qp_hist = 0; |
||
171 |
int stdin_interaction = 1; |
||
172 |
int frame_bits_per_raw_sample = 0; |
||
173 |
float max_error_rate = 2.0/3; |
||
174 |
int filter_nbthreads = 0; |
||
175 |
int filter_complex_nbthreads = 0; |
||
176 |
int vstats_version = 2; |
||
177 |
int auto_conversion_filters = 1; |
||
178 |
int64_t stats_period = 500000; |
||
179 |
|||
180 |
|||
181 |
static int intra_only = 0; |
||
182 |
static int file_overwrite = 0; |
||
183 |
static int no_file_overwrite = 0; |
||
184 |
static int do_psnr = 0; |
||
185 |
static int input_sync; |
||
186 |
static int input_stream_potentially_available = 0; |
||
187 |
static int ignore_unknown_streams = 0; |
||
188 |
static int copy_unknown_streams = 0; |
||
189 |
static int find_stream_info = 1; |
||
190 |
|||
191 |
12049 |
static void uninit_options(OptionsContext *o) |
|
192 |
{ |
||
193 |
12049 |
const OptionDef *po = options; |
|
194 |
int i; |
||
195 |
|||
196 |
/* all OPT_SPEC and OPT_STRING can be freed in generic way */ |
||
197 |
✓✓ | 2204967 |
while (po->name) { |
198 |
2192918 |
void *dst = (uint8_t*)o + po->u.off; |
|
199 |
|||
200 |
✓✓ | 2192918 |
if (po->flags & OPT_SPEC) { |
201 |
590401 |
SpecifierOpt **so = dst; |
|
202 |
590401 |
int i, *count = (int*)(so + 1); |
|
203 |
✓✓ | 615108 |
for (i = 0; i < *count; i++) { |
204 |
24707 |
av_freep(&(*so)[i].specifier); |
|
205 |
✓✓ | 24707 |
if (po->flags & OPT_STRING) |
206 |
20061 |
av_freep(&(*so)[i].u.str); |
|
207 |
} |
||
208 |
590401 |
av_freep(so); |
|
209 |
590401 |
*count = 0; |
|
210 |
✓✓✓✓ |
1602517 |
} else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING) |
211 |
12049 |
av_freep(dst); |
|
212 |
2192918 |
po++; |
|
213 |
} |
||
214 |
|||
215 |
✓✓ | 12186 |
for (i = 0; i < o->nb_stream_maps; i++) |
216 |
137 |
av_freep(&o->stream_maps[i].linklabel); |
|
217 |
12049 |
av_freep(&o->stream_maps); |
|
218 |
12049 |
av_freep(&o->audio_channel_maps); |
|
219 |
12049 |
av_freep(&o->streamid_map); |
|
220 |
12049 |
av_freep(&o->attachments); |
|
221 |
12049 |
} |
|
222 |
|||
223 |
12050 |
static void init_options(OptionsContext *o) |
|
224 |
{ |
||
225 |
12050 |
memset(o, 0, sizeof(*o)); |
|
226 |
|||
227 |
12050 |
o->stop_time = INT64_MAX; |
|
228 |
12050 |
o->mux_max_delay = 0.7; |
|
229 |
12050 |
o->start_time = AV_NOPTS_VALUE; |
|
230 |
12050 |
o->start_time_eof = AV_NOPTS_VALUE; |
|
231 |
12050 |
o->recording_time = INT64_MAX; |
|
232 |
12050 |
o->limit_filesize = UINT64_MAX; |
|
233 |
12050 |
o->chapters_input_file = INT_MAX; |
|
234 |
12050 |
o->accurate_seek = 1; |
|
235 |
12050 |
o->thread_queue_size = -1; |
|
236 |
12050 |
} |
|
237 |
|||
238 |
static int show_hwaccels(void *optctx, const char *opt, const char *arg) |
||
239 |
{ |
||
240 |
enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE; |
||
241 |
|||
242 |
printf("Hardware acceleration methods:\n"); |
||
243 |
while ((type = av_hwdevice_iterate_types(type)) != |
||
244 |
AV_HWDEVICE_TYPE_NONE) |
||
245 |
printf("%s\n", av_hwdevice_get_type_name(type)); |
||
246 |
printf("\n"); |
||
247 |
return 0; |
||
248 |
} |
||
249 |
|||
250 |
/* return a copy of the input with the stream specifiers removed from the keys */ |
||
251 |
12049 |
static AVDictionary *strip_specifiers(AVDictionary *dict) |
|
252 |
{ |
||
253 |
12049 |
AVDictionaryEntry *e = NULL; |
|
254 |
12049 |
AVDictionary *ret = NULL; |
|
255 |
|||
256 |
✓✓ | 45400 |
while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) { |
257 |
33351 |
char *p = strchr(e->key, ':'); |
|
258 |
|||
259 |
✓✓ | 33351 |
if (p) |
260 |
209 |
*p = 0; |
|
261 |
33351 |
av_dict_set(&ret, e->key, e->value, 0); |
|
262 |
✓✓ | 33351 |
if (p) |
263 |
209 |
*p = ':'; |
|
264 |
} |
||
265 |
12049 |
return ret; |
|
266 |
} |
||
267 |
|||
268 |
static int opt_abort_on(void *optctx, const char *opt, const char *arg) |
||
269 |
{ |
||
270 |
static const AVOption opts[] = { |
||
271 |
{ "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" }, |
||
272 |
{ "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" }, |
||
273 |
{ "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" }, |
||
274 |
{ NULL }, |
||
275 |
}; |
||
276 |
static const AVClass class = { |
||
277 |
.class_name = "", |
||
278 |
.item_name = av_default_item_name, |
||
279 |
.option = opts, |
||
280 |
.version = LIBAVUTIL_VERSION_INT, |
||
281 |
}; |
||
282 |
const AVClass *pclass = &class; |
||
283 |
|||
284 |
return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags); |
||
285 |
} |
||
286 |
|||
287 |
static int opt_stats_period(void *optctx, const char *opt, const char *arg) |
||
288 |
{ |
||
289 |
int64_t user_stats_period = parse_time_or_die(opt, arg, 1); |
||
290 |
|||
291 |
if (user_stats_period <= 0) { |
||
292 |
av_log(NULL, AV_LOG_ERROR, "stats_period %s must be positive.\n", arg); |
||
293 |
return AVERROR(EINVAL); |
||
294 |
} |
||
295 |
|||
296 |
stats_period = user_stats_period; |
||
297 |
av_log(NULL, AV_LOG_INFO, "ffmpeg stats and -progress period set to %s.\n", arg); |
||
298 |
|||
299 |
return 0; |
||
300 |
} |
||
301 |
|||
302 |
static int opt_sameq(void *optctx, const char *opt, const char *arg) |
||
303 |
{ |
||
304 |
av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. " |
||
305 |
"If you are looking for an option to preserve the quality (which is not " |
||
306 |
"what -%s was for), use -qscale 0 or an equivalent quality factor option.\n", |
||
307 |
opt, opt); |
||
308 |
return AVERROR(EINVAL); |
||
309 |
} |
||
310 |
|||
311 |
static int opt_video_channel(void *optctx, const char *opt, const char *arg) |
||
312 |
{ |
||
313 |
av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n"); |
||
314 |
return opt_default(optctx, "channel", arg); |
||
315 |
} |
||
316 |
|||
317 |
static int opt_video_standard(void *optctx, const char *opt, const char *arg) |
||
318 |
{ |
||
319 |
av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n"); |
||
320 |
return opt_default(optctx, "standard", arg); |
||
321 |
} |
||
322 |
|||
323 |
14 |
static int opt_audio_codec(void *optctx, const char *opt, const char *arg) |
|
324 |
{ |
||
325 |
14 |
OptionsContext *o = optctx; |
|
326 |
14 |
return parse_option(o, "codec:a", arg, options); |
|
327 |
} |
||
328 |
|||
329 |
4183 |
static int opt_video_codec(void *optctx, const char *opt, const char *arg) |
|
330 |
{ |
||
331 |
4183 |
OptionsContext *o = optctx; |
|
332 |
4183 |
return parse_option(o, "codec:v", arg, options); |
|
333 |
} |
||
334 |
|||
335 |
2 |
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg) |
|
336 |
{ |
||
337 |
2 |
OptionsContext *o = optctx; |
|
338 |
2 |
return parse_option(o, "codec:s", arg, options); |
|
339 |
} |
||
340 |
|||
341 |
static int opt_data_codec(void *optctx, const char *opt, const char *arg) |
||
342 |
{ |
||
343 |
OptionsContext *o = optctx; |
||
344 |
return parse_option(o, "codec:d", arg, options); |
||
345 |
} |
||
346 |
|||
347 |
102 |
static int opt_map(void *optctx, const char *opt, const char *arg) |
|
348 |
{ |
||
349 |
102 |
OptionsContext *o = optctx; |
|
350 |
102 |
StreamMap *m = NULL; |
|
351 |
102 |
int i, negative = 0, file_idx, disabled = 0; |
|
352 |
102 |
int sync_file_idx = -1, sync_stream_idx = 0; |
|
353 |
char *p, *sync; |
||
354 |
char *map; |
||
355 |
char *allow_unused; |
||
356 |
|||
357 |
✗✓ | 102 |
if (*arg == '-') { |
358 |
negative = 1; |
||
359 |
arg++; |
||
360 |
} |
||
361 |
102 |
map = av_strdup(arg); |
|
362 |
✗✓ | 102 |
if (!map) |
363 |
return AVERROR(ENOMEM); |
||
364 |
|||
365 |
/* parse sync stream first, just pick first matching stream */ |
||
366 |
✗✓ | 102 |
if (sync = strchr(map, ',')) { |
367 |
*sync = 0; |
||
368 |
sync_file_idx = strtol(sync + 1, &sync, 0); |
||
369 |
if (sync_file_idx >= nb_input_files || sync_file_idx < 0) { |
||
370 |
av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx); |
||
371 |
exit_program(1); |
||
372 |
} |
||
373 |
if (*sync) |
||
374 |
sync++; |
||
375 |
for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++) |
||
376 |
if (check_stream_specifier(input_files[sync_file_idx]->ctx, |
||
377 |
input_files[sync_file_idx]->ctx->streams[i], sync) == 1) { |
||
378 |
sync_stream_idx = i; |
||
379 |
break; |
||
380 |
} |
||
381 |
if (i == input_files[sync_file_idx]->nb_streams) { |
||
382 |
av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not " |
||
383 |
"match any streams.\n", arg); |
||
384 |
exit_program(1); |
||
385 |
} |
||
386 |
if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) { |
||
387 |
av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input " |
||
388 |
"stream.\n", arg); |
||
389 |
exit_program(1); |
||
390 |
} |
||
391 |
} |
||
392 |
|||
393 |
|||
394 |
✓✓ | 102 |
if (map[0] == '[') { |
395 |
/* this mapping refers to lavfi output */ |
||
396 |
3 |
const char *c = map + 1; |
|
397 |
3 |
GROW_ARRAY(o->stream_maps, o->nb_stream_maps); |
|
398 |
3 |
m = &o->stream_maps[o->nb_stream_maps - 1]; |
|
399 |
3 |
m->linklabel = av_get_token(&c, "]"); |
|
400 |
✗✓ | 3 |
if (!m->linklabel) { |
401 |
av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map); |
||
402 |
exit_program(1); |
||
403 |
} |
||
404 |
} else { |
||
405 |
✗✓ | 99 |
if (allow_unused = strchr(map, '?')) |
406 |
*allow_unused = 0; |
||
407 |
99 |
file_idx = strtol(map, &p, 0); |
|
408 |
✓✗✗✓ |
99 |
if (file_idx >= nb_input_files || file_idx < 0) { |
409 |
av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx); |
||
410 |
exit_program(1); |
||
411 |
} |
||
412 |
✗✓ | 99 |
if (negative) |
413 |
/* disable some already defined maps */ |
||
414 |
for (i = 0; i < o->nb_stream_maps; i++) { |
||
415 |
m = &o->stream_maps[i]; |
||
416 |
if (file_idx == m->file_index && |
||
417 |
check_stream_specifier(input_files[m->file_index]->ctx, |
||
418 |
input_files[m->file_index]->ctx->streams[m->stream_index], |
||
419 |
*p == ':' ? p + 1 : p) > 0) |
||
420 |
m->disabled = 1; |
||
421 |
} |
||
422 |
else |
||
423 |
✓✓ | 312 |
for (i = 0; i < input_files[file_idx]->nb_streams; i++) { |
424 |
✓✓ | 213 |
if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i], |
425 |
✓✓ | 213 |
*p == ':' ? p + 1 : p) <= 0) |
426 |
79 |
continue; |
|
427 |
✗✓ | 134 |
if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) { |
428 |
disabled = 1; |
||
429 |
continue; |
||
430 |
} |
||
431 |
134 |
GROW_ARRAY(o->stream_maps, o->nb_stream_maps); |
|
432 |
134 |
m = &o->stream_maps[o->nb_stream_maps - 1]; |
|
433 |
|||
434 |
134 |
m->file_index = file_idx; |
|
435 |
134 |
m->stream_index = i; |
|
436 |
|||
437 |
✗✓ | 134 |
if (sync_file_idx >= 0) { |
438 |
m->sync_file_index = sync_file_idx; |
||
439 |
m->sync_stream_index = sync_stream_idx; |
||
440 |
} else { |
||
441 |
134 |
m->sync_file_index = file_idx; |
|
442 |
134 |
m->sync_stream_index = i; |
|
443 |
} |
||
444 |
} |
||
445 |
} |
||
446 |
|||
447 |
✗✓ | 102 |
if (!m) { |
448 |
if (allow_unused) { |
||
449 |
av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg); |
||
450 |
} else if (disabled) { |
||
451 |
av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n" |
||
452 |
"To ignore this, add a trailing '?' to the map.\n", arg); |
||
453 |
exit_program(1); |
||
454 |
} else { |
||
455 |
av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n" |
||
456 |
"To ignore this, add a trailing '?' to the map.\n", arg); |
||
457 |
exit_program(1); |
||
458 |
} |
||
459 |
} |
||
460 |
|||
461 |
102 |
av_freep(&map); |
|
462 |
102 |
return 0; |
|
463 |
} |
||
464 |
|||
465 |
1 |
static int opt_attach(void *optctx, const char *opt, const char *arg) |
|
466 |
{ |
||
467 |
1 |
OptionsContext *o = optctx; |
|
468 |
1 |
GROW_ARRAY(o->attachments, o->nb_attachments); |
|
469 |
1 |
o->attachments[o->nb_attachments - 1] = arg; |
|
470 |
1 |
return 0; |
|
471 |
} |
||
472 |
|||
473 |
10 |
static int opt_map_channel(void *optctx, const char *opt, const char *arg) |
|
474 |
{ |
||
475 |
10 |
OptionsContext *o = optctx; |
|
476 |
int n; |
||
477 |
AVStream *st; |
||
478 |
AudioChannelMap *m; |
||
479 |
char *allow_unused; |
||
480 |
char *mapchan; |
||
481 |
10 |
mapchan = av_strdup(arg); |
|
482 |
✗✓ | 10 |
if (!mapchan) |
483 |
return AVERROR(ENOMEM); |
||
484 |
|||
485 |
10 |
GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps); |
|
486 |
10 |
m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1]; |
|
487 |
|||
488 |
/* muted channel syntax */ |
||
489 |
10 |
n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx); |
|
490 |
✗✓✗✗ ✓✓ |
10 |
if ((n == 1 || n == 3) && m->channel_idx == -1) { |
491 |
1 |
m->file_idx = m->stream_idx = -1; |
|
492 |
✓✗ | 1 |
if (n == 1) |
493 |
1 |
m->ofile_idx = m->ostream_idx = -1; |
|
494 |
1 |
av_free(mapchan); |
|
495 |
1 |
return 0; |
|
496 |
} |
||
497 |
|||
498 |
/* normal syntax */ |
||
499 |
9 |
n = sscanf(arg, "%d.%d.%d:%d.%d", |
|
500 |
&m->file_idx, &m->stream_idx, &m->channel_idx, |
||
501 |
&m->ofile_idx, &m->ostream_idx); |
||
502 |
|||
503 |
✗✓✗✗ |
9 |
if (n != 3 && n != 5) { |
504 |
av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: " |
||
505 |
"[file.stream.channel|-1][:syncfile:syncstream]\n"); |
||
506 |
exit_program(1); |
||
507 |
} |
||
508 |
|||
509 |
✓✗ | 9 |
if (n != 5) // only file.stream.channel specified |
510 |
9 |
m->ofile_idx = m->ostream_idx = -1; |
|
511 |
|||
512 |
/* check input */ |
||
513 |
✓✗✗✓ |
9 |
if (m->file_idx < 0 || m->file_idx >= nb_input_files) { |
514 |
av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n", |
||
515 |
m->file_idx); |
||
516 |
exit_program(1); |
||
517 |
} |
||
518 |
✓✗ | 9 |
if (m->stream_idx < 0 || |
519 |
✗✓ | 9 |
m->stream_idx >= input_files[m->file_idx]->nb_streams) { |
520 |
av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n", |
||
521 |
m->file_idx, m->stream_idx); |
||
522 |
exit_program(1); |
||
523 |
} |
||
524 |
9 |
st = input_files[m->file_idx]->ctx->streams[m->stream_idx]; |
|
525 |
✗✓ | 9 |
if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) { |
526 |
av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n", |
||
527 |
m->file_idx, m->stream_idx); |
||
528 |
exit_program(1); |
||
529 |
} |
||
530 |
/* allow trailing ? to map_channel */ |
||
531 |
✓✓ | 9 |
if (allow_unused = strchr(mapchan, '?')) |
532 |
2 |
*allow_unused = 0; |
|
533 |
✓✗✓✓ |
9 |
if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels || |
534 |
✗✓ | 8 |
input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) { |
535 |
✓✗ | 1 |
if (allow_unused) { |
536 |
1 |
av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n", |
|
537 |
m->file_idx, m->stream_idx, m->channel_idx); |
||
538 |
} else { |
||
539 |
av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n" |
||
540 |
"To ignore this, add a trailing '?' to the map_channel.\n", |
||
541 |
m->file_idx, m->stream_idx, m->channel_idx); |
||
542 |
exit_program(1); |
||
543 |
} |
||
544 |
|||
545 |
} |
||
546 |
9 |
av_free(mapchan); |
|
547 |
9 |
return 0; |
|
548 |
} |
||
549 |
|||
550 |
static int opt_sdp_file(void *optctx, const char *opt, const char *arg) |
||
551 |
{ |
||
552 |
av_free(sdp_filename); |
||
553 |
sdp_filename = av_strdup(arg); |
||
554 |
return 0; |
||
555 |
} |
||
556 |
|||
557 |
#if CONFIG_VAAPI |
||
558 |
static int opt_vaapi_device(void *optctx, const char *opt, const char *arg) |
||
559 |
{ |
||
560 |
const char *prefix = "vaapi:"; |
||
561 |
char *tmp; |
||
562 |
int err; |
||
563 |
tmp = av_asprintf("%s%s", prefix, arg); |
||
564 |
if (!tmp) |
||
565 |
return AVERROR(ENOMEM); |
||
566 |
err = hw_device_init_from_string(tmp, NULL); |
||
567 |
av_free(tmp); |
||
568 |
return err; |
||
569 |
} |
||
570 |
#endif |
||
571 |
|||
572 |
static int opt_init_hw_device(void *optctx, const char *opt, const char *arg) |
||
573 |
{ |
||
574 |
if (!strcmp(arg, "list")) { |
||
575 |
enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE; |
||
576 |
printf("Supported hardware device types:\n"); |
||
577 |
while ((type = av_hwdevice_iterate_types(type)) != |
||
578 |
AV_HWDEVICE_TYPE_NONE) |
||
579 |
printf("%s\n", av_hwdevice_get_type_name(type)); |
||
580 |
printf("\n"); |
||
581 |
exit_program(0); |
||
582 |
} else { |
||
583 |
return hw_device_init_from_string(arg, NULL); |
||
584 |
} |
||
585 |
} |
||
586 |
|||
587 |
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg) |
||
588 |
{ |
||
589 |
if (filter_hw_device) { |
||
590 |
av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n"); |
||
591 |
return AVERROR(EINVAL); |
||
592 |
} |
||
593 |
filter_hw_device = hw_device_get_by_name(arg); |
||
594 |
if (!filter_hw_device) { |
||
595 |
av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg); |
||
596 |
return AVERROR(EINVAL); |
||
597 |
} |
||
598 |
return 0; |
||
599 |
} |
||
600 |
|||
601 |
/** |
||
602 |
* Parse a metadata specifier passed as 'arg' parameter. |
||
603 |
* @param arg metadata string to parse |
||
604 |
* @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram) |
||
605 |
* @param index for type c/p, chapter/program index is written here |
||
606 |
* @param stream_spec for type s, the stream specifier is written here |
||
607 |
*/ |
||
608 |
171 |
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec) |
|
609 |
{ |
||
610 |
✓✓ | 171 |
if (*arg) { |
611 |
44 |
*type = *arg; |
|
612 |
✓✓✓✗ |
44 |
switch (*arg) { |
613 |
18 |
case 'g': |
|
614 |
18 |
break; |
|
615 |
22 |
case 's': |
|
616 |
✓✗✗✓ |
22 |
if (*(++arg) && *arg != ':') { |
617 |
av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg); |
||
618 |
exit_program(1); |
||
619 |
} |
||
620 |
✓✗ | 22 |
*stream_spec = *arg == ':' ? arg + 1 : ""; |
621 |
22 |
break; |
|
622 |
4 |
case 'c': |
|
623 |
case 'p': |
||
624 |
✓✓ | 4 |
if (*(++arg) == ':') |
625 |
3 |
*index = strtol(++arg, NULL, 0); |
|
626 |
4 |
break; |
|
627 |
default: |
||
628 |
av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg); |
||
629 |
exit_program(1); |
||
630 |
} |
||
631 |
} else |
||
632 |
127 |
*type = 'g'; |
|
633 |
171 |
} |
|
634 |
|||
635 |
5 |
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o) |
|
636 |
{ |
||
637 |
5 |
AVDictionary **meta_in = NULL; |
|
638 |
5 |
AVDictionary **meta_out = NULL; |
|
639 |
5 |
int i, ret = 0; |
|
640 |
char type_in, type_out; |
||
641 |
5 |
const char *istream_spec = NULL, *ostream_spec = NULL; |
|
642 |
5 |
int idx_in = 0, idx_out = 0; |
|
643 |
|||
644 |
5 |
parse_meta_type(inspec, &type_in, &idx_in, &istream_spec); |
|
645 |
5 |
parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec); |
|
646 |
|||
647 |
✓✓ | 5 |
if (!ic) { |
648 |
✗✓✗✗ |
2 |
if (type_out == 'g' || !*outspec) |
649 |
2 |
o->metadata_global_manual = 1; |
|
650 |
✓✗✗✓ |
2 |
if (type_out == 's' || !*outspec) |
651 |
o->metadata_streams_manual = 1; |
||
652 |
✓✗✗✓ |
2 |
if (type_out == 'c' || !*outspec) |
653 |
o->metadata_chapters_manual = 1; |
||
654 |
2 |
return 0; |
|
655 |
} |
||
656 |
|||
657 |
✓✓✗✓ |
3 |
if (type_in == 'g' || type_out == 'g') |
658 |
1 |
o->metadata_global_manual = 1; |
|
659 |
✓✓✗✓ |
3 |
if (type_in == 's' || type_out == 's') |
660 |
2 |
o->metadata_streams_manual = 1; |
|
661 |
✓✗✗✓ |
3 |
if (type_in == 'c' || type_out == 'c') |
662 |
o->metadata_chapters_manual = 1; |
||
663 |
|||
664 |
/* ic is NULL when just disabling automatic mappings */ |
||
665 |
✗✓ | 3 |
if (!ic) |
666 |
return 0; |
||
667 |
|||
668 |
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\ |
||
669 |
if ((index) < 0 || (index) >= (nb_elems)) {\ |
||
670 |
av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\ |
||
671 |
(desc), (index));\ |
||
672 |
exit_program(1);\ |
||
673 |
} |
||
674 |
|||
675 |
#define SET_DICT(type, meta, context, index)\ |
||
676 |
switch (type) {\ |
||
677 |
case 'g':\ |
||
678 |
meta = &context->metadata;\ |
||
679 |
break;\ |
||
680 |
case 'c':\ |
||
681 |
METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\ |
||
682 |
meta = &context->chapters[index]->metadata;\ |
||
683 |
break;\ |
||
684 |
case 'p':\ |
||
685 |
METADATA_CHECK_INDEX(index, context->nb_programs, "program")\ |
||
686 |
meta = &context->programs[index]->metadata;\ |
||
687 |
break;\ |
||
688 |
case 's':\ |
||
689 |
break; /* handled separately below */ \ |
||
690 |
default: av_assert0(0);\ |
||
691 |
}\ |
||
692 |
|||
693 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗ |
3 |
SET_DICT(type_in, meta_in, ic, idx_in); |
694 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗ |
3 |
SET_DICT(type_out, meta_out, oc, idx_out); |
695 |
|||
696 |
/* for input streams choose first matching stream */ |
||
697 |
✓✓ | 3 |
if (type_in == 's') { |
698 |
✓✗ | 3 |
for (i = 0; i < ic->nb_streams; i++) { |
699 |
✓✓ | 3 |
if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) { |
700 |
2 |
meta_in = &ic->streams[i]->metadata; |
|
701 |
2 |
break; |
|
702 |
✗✓ | 1 |
} else if (ret < 0) |
703 |
exit_program(1); |
||
704 |
} |
||
705 |
✗✓ | 2 |
if (!meta_in) { |
706 |
av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec); |
||
707 |
exit_program(1); |
||
708 |
} |
||
709 |
} |
||
710 |
|||
711 |
✓✓ | 3 |
if (type_out == 's') { |
712 |
✓✓ | 8 |
for (i = 0; i < oc->nb_streams; i++) { |
713 |
✓✓ | 6 |
if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) { |
714 |
2 |
meta_out = &oc->streams[i]->metadata; |
|
715 |
2 |
av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE); |
|
716 |
✗✓ | 4 |
} else if (ret < 0) |
717 |
exit_program(1); |
||
718 |
} |
||
719 |
} else |
||
720 |
1 |
av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE); |
|
721 |
|||
722 |
3 |
return 0; |
|
723 |
} |
||
724 |
|||
725 |
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg) |
||
726 |
{ |
||
727 |
OptionsContext *o = optctx; |
||
728 |
char buf[128]; |
||
729 |
int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6; |
||
730 |
struct tm time = *gmtime((time_t*)&recording_timestamp); |
||
731 |
if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time)) |
||
732 |
return -1; |
||
733 |
parse_option(o, "metadata", buf, options); |
||
734 |
|||
735 |
av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata " |
||
736 |
"tag instead.\n", opt); |
||
737 |
return 0; |
||
738 |
} |
||
739 |
|||
740 |
10492 |
static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder) |
|
741 |
{ |
||
742 |
const AVCodecDescriptor *desc; |
||
743 |
✓✓ | 10492 |
const char *codec_string = encoder ? "encoder" : "decoder"; |
744 |
AVCodec *codec; |
||
745 |
|||
746 |
10492 |
codec = encoder ? |
|
747 |
✓✓ | 10492 |
avcodec_find_encoder_by_name(name) : |
748 |
7303 |
avcodec_find_decoder_by_name(name); |
|
749 |
|||
750 |
✓✓✓✗ |
10492 |
if (!codec && (desc = avcodec_descriptor_get_by_name(name))) { |
751 |
✓✗ | 1 |
codec = encoder ? avcodec_find_encoder(desc->id) : |
752 |
avcodec_find_decoder(desc->id); |
||
753 |
✓✗ | 1 |
if (codec) |
754 |
1 |
av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n", |
|
755 |
codec_string, codec->name, desc->name); |
||
756 |
} |
||
757 |
|||
758 |
✗✓ | 10492 |
if (!codec) { |
759 |
av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name); |
||
760 |
exit_program(1); |
||
761 |
} |
||
762 |
✗✓ | 10492 |
if (codec->type != type) { |
763 |
av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name); |
||
764 |
exit_program(1); |
||
765 |
} |
||
766 |
10492 |
return codec; |
|
767 |
} |
||
768 |
|||
769 |
12708 |
static const AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st) |
|
770 |
{ |
||
771 |
12708 |
char *codec_name = NULL; |
|
772 |
|||
773 |
✓✓✗✓ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
17594 |
MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st); |
774 |
✓✓ | 12708 |
if (codec_name) { |
775 |
4880 |
const AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0); |
|
776 |
4880 |
st->codecpar->codec_id = codec->id; |
|
777 |
4880 |
return codec; |
|
778 |
} else |
||
779 |
7828 |
return avcodec_find_decoder(st->codecpar->codec_id); |
|
780 |
} |
||
781 |
|||
782 |
/* Add all the streams from the given input file to the global |
||
783 |
* list of input streams. */ |
||
784 |
6038 |
static void add_input_streams(OptionsContext *o, AVFormatContext *ic) |
|
785 |
{ |
||
786 |
int i, ret; |
||
787 |
|||
788 |
✓✓ | 12442 |
for (i = 0; i < ic->nb_streams; i++) { |
789 |
6404 |
AVStream *st = ic->streams[i]; |
|
790 |
6404 |
AVCodecParameters *par = st->codecpar; |
|
791 |
6404 |
InputStream *ist = av_mallocz(sizeof(*ist)); |
|
792 |
6404 |
char *framerate = NULL, *hwaccel_device = NULL; |
|
793 |
6404 |
const char *hwaccel = NULL; |
|
794 |
6404 |
char *hwaccel_output_format = NULL; |
|
795 |
6404 |
char *codec_tag = NULL; |
|
796 |
char *next; |
||
797 |
6404 |
char *discard_str = NULL; |
|
798 |
6404 |
const AVClass *cc = avcodec_get_class(); |
|
799 |
6404 |
const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0); |
|
800 |
|||
801 |
✗✓ | 6404 |
if (!ist) |
802 |
exit_program(1); |
||
803 |
|||
804 |
6404 |
GROW_ARRAY(input_streams, nb_input_streams); |
|
805 |
6404 |
input_streams[nb_input_streams - 1] = ist; |
|
806 |
|||
807 |
6404 |
ist->st = st; |
|
808 |
6404 |
ist->file_index = nb_input_files; |
|
809 |
6404 |
ist->discard = 1; |
|
810 |
6404 |
st->discard = AVDISCARD_ALL; |
|
811 |
6404 |
ist->nb_samples = 0; |
|
812 |
6404 |
ist->min_pts = INT64_MAX; |
|
813 |
6404 |
ist->max_pts = INT64_MIN; |
|
814 |
|||
815 |
6404 |
ist->ts_scale = 1.0; |
|
816 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6404 |
MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st); |
817 |
|||
818 |
6404 |
ist->autorotate = 1; |
|
819 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6404 |
MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st); |
820 |
|||
821 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6406 |
MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st); |
822 |
✓✓ | 6404 |
if (codec_tag) { |
823 |
2 |
uint32_t tag = strtol(codec_tag, &next, 0); |
|
824 |
✓✗ | 2 |
if (*next) |
825 |
2 |
tag = AV_RL32(codec_tag); |
|
826 |
2 |
st->codecpar->codec_tag = tag; |
|
827 |
} |
||
828 |
|||
829 |
6404 |
ist->dec = choose_decoder(o, ic, st); |
|
830 |
6404 |
ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec); |
|
831 |
|||
832 |
6404 |
ist->reinit_filters = -1; |
|
833 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6404 |
MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st); |
834 |
|||
835 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6404 |
MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st); |
836 |
6404 |
ist->user_set_discard = AVDISCARD_NONE; |
|
837 |
|||
838 |
✗✓✗✗ |
6404 |
if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) || |
839 |
✗✓✗✗ |
6404 |
(o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) || |
840 |
✗✓✗✗ |
6404 |
(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) || |
841 |
✗✓✗✗ |
6404 |
(o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)) |
842 |
ist->user_set_discard = AVDISCARD_ALL; |
||
843 |
|||
844 |
✗✓✗✗ |
6404 |
if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) { |
845 |
av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n", |
||
846 |
discard_str); |
||
847 |
exit_program(1); |
||
848 |
} |
||
849 |
|||
850 |
6404 |
ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE; |
|
851 |
|||
852 |
6404 |
ist->dec_ctx = avcodec_alloc_context3(ist->dec); |
|
853 |
✗✓ | 6404 |
if (!ist->dec_ctx) { |
854 |
av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n"); |
||
855 |
exit_program(1); |
||
856 |
} |
||
857 |
|||
858 |
6404 |
ret = avcodec_parameters_to_context(ist->dec_ctx, par); |
|
859 |
✗✓ | 6404 |
if (ret < 0) { |
860 |
av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n"); |
||
861 |
exit_program(1); |
||
862 |
} |
||
863 |
|||
864 |
✓✓ | 6404 |
if (o->bitexact) |
865 |
85 |
ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT; |
|
866 |
|||
867 |
✓✓✓✓ ✗ |
6404 |
switch (par->codec_type) { |
868 |
4891 |
case AVMEDIA_TYPE_VIDEO: |
|
869 |
✗✓ | 4891 |
if(!ist->dec) |
870 |
ist->dec = avcodec_find_decoder(par->codec_id); |
||
871 |
|||
872 |
// avformat_find_stream_info() doesn't set this for us anymore. |
||
873 |
4891 |
ist->dec_ctx->framerate = st->avg_frame_rate; |
|
874 |
|||
875 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4915 |
MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st); |
876 |
✓✓✗✓ |
4891 |
if (framerate && av_parse_video_rate(&ist->framerate, |
877 |
framerate) < 0) { |
||
878 |
av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n", |
||
879 |
framerate); |
||
880 |
exit_program(1); |
||
881 |
} |
||
882 |
|||
883 |
4891 |
ist->top_field_first = -1; |
|
884 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4891 |
MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st); |
885 |
|||
886 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
9541 |
MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st); |
887 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4891 |
MATCH_PER_STREAM_OPT(hwaccel_output_formats, str, |
888 |
hwaccel_output_format, ic, st); |
||
889 |
|||
890 |
✓✗✓✓ ✗✓ |
4891 |
if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) { |
891 |
av_log(NULL, AV_LOG_WARNING, |
||
892 |
"WARNING: defaulting hwaccel_output_format to cuda for compatibility " |
||
893 |
"with old commandlines. This behaviour is DEPRECATED and will be removed " |
||
894 |
"in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n"); |
||
895 |
ist->hwaccel_output_format = AV_PIX_FMT_CUDA; |
||
896 |
✗✓ | 4891 |
} else if (hwaccel_output_format) { |
897 |
ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format); |
||
898 |
if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) { |
||
899 |
av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output " |
||
900 |
"format: %s", hwaccel_output_format); |
||
901 |
} |
||
902 |
} else { |
||
903 |
4891 |
ist->hwaccel_output_format = AV_PIX_FMT_NONE; |
|
904 |
} |
||
905 |
|||
906 |
✓✓ | 4891 |
if (hwaccel) { |
907 |
// The NVDEC hwaccels use a CUDA device, so remap the name here. |
||
908 |
✓✗✗✓ |
4650 |
if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid")) |
909 |
hwaccel = "cuda"; |
||
910 |
|||
911 |
✓✗ | 4650 |
if (!strcmp(hwaccel, "none")) |
912 |
4650 |
ist->hwaccel_id = HWACCEL_NONE; |
|
913 |
else if (!strcmp(hwaccel, "auto")) |
||
914 |
ist->hwaccel_id = HWACCEL_AUTO; |
||
915 |
else { |
||
916 |
enum AVHWDeviceType type; |
||
917 |
int i; |
||
918 |
for (i = 0; hwaccels[i].name; i++) { |
||
919 |
if (!strcmp(hwaccels[i].name, hwaccel)) { |
||
920 |
ist->hwaccel_id = hwaccels[i].id; |
||
921 |
break; |
||
922 |
} |
||
923 |
} |
||
924 |
|||
925 |
if (!ist->hwaccel_id) { |
||
926 |
type = av_hwdevice_find_type_by_name(hwaccel); |
||
927 |
if (type != AV_HWDEVICE_TYPE_NONE) { |
||
928 |
ist->hwaccel_id = HWACCEL_GENERIC; |
||
929 |
ist->hwaccel_device_type = type; |
||
930 |
} |
||
931 |
} |
||
932 |
|||
933 |
if (!ist->hwaccel_id) { |
||
934 |
av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n", |
||
935 |
hwaccel); |
||
936 |
av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: "); |
||
937 |
type = AV_HWDEVICE_TYPE_NONE; |
||
938 |
while ((type = av_hwdevice_iterate_types(type)) != |
||
939 |
AV_HWDEVICE_TYPE_NONE) |
||
940 |
av_log(NULL, AV_LOG_FATAL, "%s ", |
||
941 |
av_hwdevice_get_type_name(type)); |
||
942 |
av_log(NULL, AV_LOG_FATAL, "\n"); |
||
943 |
exit_program(1); |
||
944 |
} |
||
945 |
} |
||
946 |
} |
||
947 |
|||
948 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4891 |
MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st); |
949 |
✗✓ | 4891 |
if (hwaccel_device) { |
950 |
ist->hwaccel_device = av_strdup(hwaccel_device); |
||
951 |
if (!ist->hwaccel_device) |
||
952 |
exit_program(1); |
||
953 |
} |
||
954 |
|||
955 |
4891 |
ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE; |
|
956 |
|||
957 |
4891 |
break; |
|
958 |
1408 |
case AVMEDIA_TYPE_AUDIO: |
|
959 |
1408 |
ist->guess_layout_max = INT_MAX; |
|
960 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1412 |
MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st); |
961 |
1408 |
guess_input_channel_layout(ist); |
|
962 |
1408 |
break; |
|
963 |
104 |
case AVMEDIA_TYPE_DATA: |
|
964 |
case AVMEDIA_TYPE_SUBTITLE: { |
||
965 |
104 |
char *canvas_size = NULL; |
|
966 |
✓✓ | 104 |
if(!ist->dec) |
967 |
50 |
ist->dec = avcodec_find_decoder(par->codec_id); |
|
968 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
104 |
MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st); |
969 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
104 |
MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st); |
970 |
✗✓✗✗ |
104 |
if (canvas_size && |
971 |
av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) { |
||
972 |
av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size); |
||
973 |
exit_program(1); |
||
974 |
} |
||
975 |
104 |
break; |
|
976 |
} |
||
977 |
1 |
case AVMEDIA_TYPE_ATTACHMENT: |
|
978 |
case AVMEDIA_TYPE_UNKNOWN: |
||
979 |
1 |
break; |
|
980 |
default: |
||
981 |
abort(); |
||
982 |
} |
||
983 |
|||
984 |
6404 |
ret = avcodec_parameters_from_context(par, ist->dec_ctx); |
|
985 |
✗✓ | 6404 |
if (ret < 0) { |
986 |
av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n"); |
||
987 |
exit_program(1); |
||
988 |
} |
||
989 |
} |
||
990 |
6038 |
} |
|
991 |
|||
992 |
5957 |
static void assert_file_overwrite(const char *filename) |
|
993 |
{ |
||
994 |
5957 |
const char *proto_name = avio_find_protocol_name(filename); |
|
995 |
|||
996 |
✓✓✗✓ |
5957 |
if (file_overwrite && no_file_overwrite) { |
997 |
fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n"); |
||
998 |
exit_program(1); |
||
999 |
} |
||
1000 |
|||
1001 |
✓✓ | 5957 |
if (!file_overwrite) { |
1002 |
✓✗✗✓ ✗✗ |
4337 |
if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) { |
1003 |
if (stdin_interaction && !no_file_overwrite) { |
||
1004 |
fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename); |
||
1005 |
fflush(stderr); |
||
1006 |
term_exit(); |
||
1007 |
signal(SIGINT, SIG_DFL); |
||
1008 |
if (!read_yesno()) { |
||
1009 |
av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n"); |
||
1010 |
exit_program(1); |
||
1011 |
} |
||
1012 |
term_init(); |
||
1013 |
} |
||
1014 |
else { |
||
1015 |
av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename); |
||
1016 |
exit_program(1); |
||
1017 |
} |
||
1018 |
} |
||
1019 |
} |
||
1020 |
|||
1021 |
✓✗✓✓ |
5957 |
if (proto_name && !strcmp(proto_name, "file")) { |
1022 |
✓✓ | 3281 |
for (int i = 0; i < nb_input_files; i++) { |
1023 |
1661 |
InputFile *file = input_files[i]; |
|
1024 |
✓✓ | 1661 |
if (file->ctx->iformat->flags & AVFMT_NOFILE) |
1025 |
108 |
continue; |
|
1026 |
✗✓ | 1553 |
if (!strcmp(filename, file->ctx->url)) { |
1027 |
av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i); |
||
1028 |
av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n"); |
||
1029 |
exit_program(1); |
||
1030 |
} |
||
1031 |
} |
||
1032 |
} |
||
1033 |
5957 |
} |
|
1034 |
|||
1035 |
static void dump_attachment(AVStream *st, const char *filename) |
||
1036 |
{ |
||
1037 |
int ret; |
||
1038 |
AVIOContext *out = NULL; |
||
1039 |
AVDictionaryEntry *e; |
||
1040 |
|||
1041 |
if (!st->codecpar->extradata_size) { |
||
1042 |
av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n", |
||
1043 |
nb_input_files - 1, st->index); |
||
1044 |
return; |
||
1045 |
} |
||
1046 |
if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0))) |
||
1047 |
filename = e->value; |
||
1048 |
if (!*filename) { |
||
1049 |
av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag" |
||
1050 |
"in stream #%d:%d.\n", nb_input_files - 1, st->index); |
||
1051 |
exit_program(1); |
||
1052 |
} |
||
1053 |
|||
1054 |
assert_file_overwrite(filename); |
||
1055 |
|||
1056 |
if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) { |
||
1057 |
av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n", |
||
1058 |
filename); |
||
1059 |
exit_program(1); |
||
1060 |
} |
||
1061 |
|||
1062 |
avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size); |
||
1063 |
avio_flush(out); |
||
1064 |
avio_close(out); |
||
1065 |
} |
||
1066 |
|||
1067 |
6039 |
static int open_input_file(OptionsContext *o, const char *filename) |
|
1068 |
{ |
||
1069 |
InputFile *f; |
||
1070 |
AVFormatContext *ic; |
||
1071 |
6039 |
AVInputFormat *file_iformat = NULL; |
|
1072 |
int err, i, ret; |
||
1073 |
int64_t timestamp; |
||
1074 |
6039 |
AVDictionary *unused_opts = NULL; |
|
1075 |
6039 |
AVDictionaryEntry *e = NULL; |
|
1076 |
6039 |
char * video_codec_name = NULL; |
|
1077 |
6039 |
char * audio_codec_name = NULL; |
|
1078 |
6039 |
char *subtitle_codec_name = NULL; |
|
1079 |
6039 |
char * data_codec_name = NULL; |
|
1080 |
6039 |
int scan_all_pmts_set = 0; |
|
1081 |
|||
1082 |
✗✓✗✗ |
6039 |
if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) { |
1083 |
o->stop_time = INT64_MAX; |
||
1084 |
av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n"); |
||
1085 |
} |
||
1086 |
|||
1087 |
✗✓✗✗ |
6039 |
if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) { |
1088 |
int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time; |
||
1089 |
if (o->stop_time <= start_time) { |
||
1090 |
av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n"); |
||
1091 |
exit_program(1); |
||
1092 |
} else { |
||
1093 |
o->recording_time = o->stop_time - start_time; |
||
1094 |
} |
||
1095 |
} |
||
1096 |
|||
1097 |
✓✓ | 6039 |
if (o->format) { |
1098 |
✗✓ | 2889 |
if (!(file_iformat = av_find_input_format(o->format))) { |
1099 |
av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format); |
||
1100 |
exit_program(1); |
||
1101 |
} |
||
1102 |
} |
||
1103 |
|||
1104 |
✗✓ | 6039 |
if (!strcmp(filename, "-")) |
1105 |
filename = "pipe:"; |
||
1106 |
|||
1107 |
✓✗ | 12078 |
stdin_interaction &= strncmp(filename, "pipe:", 5) && |
1108 |
✓✗ | 6039 |
strcmp(filename, "/dev/stdin"); |
1109 |
|||
1110 |
/* get default parameters from command line */ |
||
1111 |
6039 |
ic = avformat_alloc_context(); |
|
1112 |
✗✓ | 6039 |
if (!ic) { |
1113 |
print_error(filename, AVERROR(ENOMEM)); |
||
1114 |
exit_program(1); |
||
1115 |
} |
||
1116 |
✓✓ | 6039 |
if (o->nb_audio_sample_rate) { |
1117 |
63 |
av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0); |
|
1118 |
} |
||
1119 |
✓✓ | 6039 |
if (o->nb_audio_channels) { |
1120 |
/* because we set audio_channels based on both the "ac" and |
||
1121 |
* "channel_layout" options, we need to check that the specified |
||
1122 |
* demuxer actually has the "channels" option before setting it */ |
||
1123 |
✓✗✓✗ ✓✗ |
18 |
if (file_iformat && file_iformat->priv_class && |
1124 |
9 |
av_opt_find(&file_iformat->priv_class, "channels", NULL, 0, |
|
1125 |
AV_OPT_SEARCH_FAKE_OBJ)) { |
||
1126 |
9 |
av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0); |
|
1127 |
} |
||
1128 |
} |
||
1129 |
✓✓ | 6039 |
if (o->nb_frame_rates) { |
1130 |
/* set the format-level framerate option; |
||
1131 |
* this is important for video grabbers, e.g. x11 */ |
||
1132 |
✓✗✓✗ ✓✗ |
48 |
if (file_iformat && file_iformat->priv_class && |
1133 |
24 |
av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0, |
|
1134 |
AV_OPT_SEARCH_FAKE_OBJ)) { |
||
1135 |
24 |
av_dict_set(&o->g->format_opts, "framerate", |
|
1136 |
24 |
o->frame_rates[o->nb_frame_rates - 1].u.str, 0); |
|
1137 |
} |
||
1138 |
} |
||
1139 |
✓✓ | 6039 |
if (o->nb_frame_sizes) { |
1140 |
492 |
av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0); |
|
1141 |
} |
||
1142 |
✓✓ | 6039 |
if (o->nb_frame_pix_fmts) |
1143 |
497 |
av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0); |
|
1144 |
|||
1145 |
✓✓✓✓ |
8479 |
MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v"); |
1146 |
✓✓✓✓ |
8479 |
MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a"); |
1147 |
✗✓✓✓ |
8479 |
MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s"); |
1148 |
✗✓✓✓ |
8479 |
MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d"); |
1149 |
|||
1150 |
✓✓ | 6039 |
if (video_codec_name) |
1151 |
2407 |
ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0); |
|
1152 |
✓✓ | 6039 |
if (audio_codec_name) |
1153 |
16 |
ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0); |
|
1154 |
✗✓ | 6039 |
if (subtitle_codec_name) |
1155 |
ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0); |
||
1156 |
✗✓ | 6039 |
if (data_codec_name) |
1157 |
ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0); |
||
1158 |
|||
1159 |
✓✓ | 6039 |
ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE; |
1160 |
✓✓ | 6039 |
ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE; |
1161 |
✗✓ | 6039 |
ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE; |
1162 |
✗✓ | 6039 |
ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE; |
1163 |
|||
1164 |
6039 |
ic->flags |= AVFMT_FLAG_NONBLOCK; |
|
1165 |
✓✓ | 6039 |
if (o->bitexact) |
1166 |
76 |
ic->flags |= AVFMT_FLAG_BITEXACT; |
|
1167 |
6039 |
ic->interrupt_callback = int_cb; |
|
1168 |
|||
1169 |
✓✗ | 6039 |
if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) { |
1170 |
6039 |
av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE); |
|
1171 |
6039 |
scan_all_pmts_set = 1; |
|
1172 |
} |
||
1173 |
/* open the input file with generic avformat function */ |
||
1174 |
6039 |
err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts); |
|
1175 |
✓✓ | 6039 |
if (err < 0) { |
1176 |
1 |
print_error(filename, err); |
|
1177 |
✗✓ | 1 |
if (err == AVERROR_PROTOCOL_NOT_FOUND) |
1178 |
av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename); |
||
1179 |
1 |
exit_program(1); |
|
1180 |
} |
||
1181 |
✓✗ | 6038 |
if (scan_all_pmts_set) |
1182 |
6038 |
av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE); |
|
1183 |
6038 |
remove_avoptions(&o->g->format_opts, o->g->codec_opts); |
|
1184 |
6038 |
assert_avoptions(o->g->format_opts); |
|
1185 |
|||
1186 |
/* apply forced codec ids */ |
||
1187 |
✓✓ | 12342 |
for (i = 0; i < ic->nb_streams; i++) |
1188 |
6304 |
choose_decoder(o, ic, ic->streams[i]); |
|
1189 |
|||
1190 |
✓✗ | 6038 |
if (find_stream_info) { |
1191 |
6038 |
AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts); |
|
1192 |
6038 |
int orig_nb_streams = ic->nb_streams; |
|
1193 |
|||
1194 |
/* If not enough info to get the stream parameters, we decode the |
||
1195 |
first frames to get it. (used in mpeg case for example) */ |
||
1196 |
6038 |
ret = avformat_find_stream_info(ic, opts); |
|
1197 |
|||
1198 |
✓✓ | 12342 |
for (i = 0; i < orig_nb_streams; i++) |
1199 |
6304 |
av_dict_free(&opts[i]); |
|
1200 |
6038 |
av_freep(&opts); |
|
1201 |
|||
1202 |
✗✓ | 6038 |
if (ret < 0) { |
1203 |
av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename); |
||
1204 |
if (ic->nb_streams == 0) { |
||
1205 |
avformat_close_input(&ic); |
||
1206 |
exit_program(1); |
||
1207 |
} |
||
1208 |
} |
||
1209 |
} |
||
1210 |
|||
1211 |
✓✓✗✓ |
6038 |
if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) { |
1212 |
av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename); |
||
1213 |
o->start_time_eof = AV_NOPTS_VALUE; |
||
1214 |
} |
||
1215 |
|||
1216 |
✗✓ | 6038 |
if (o->start_time_eof != AV_NOPTS_VALUE) { |
1217 |
if (o->start_time_eof >= 0) { |
||
1218 |
av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n"); |
||
1219 |
exit_program(1); |
||
1220 |
} |
||
1221 |
if (ic->duration > 0) { |
||
1222 |
o->start_time = o->start_time_eof + ic->duration; |
||
1223 |
if (o->start_time < 0) { |
||
1224 |
av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename); |
||
1225 |
o->start_time = AV_NOPTS_VALUE; |
||
1226 |
} |
||
1227 |
} else |
||
1228 |
av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename); |
||
1229 |
} |
||
1230 |
✓✓ | 6038 |
timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time; |
1231 |
/* add the stream start time */ |
||
1232 |
✓✓✓✓ |
6038 |
if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE) |
1233 |
4548 |
timestamp += ic->start_time; |
|
1234 |
|||
1235 |
/* if seeking requested, we execute it */ |
||
1236 |
✓✓ | 6038 |
if (o->start_time != AV_NOPTS_VALUE) { |
1237 |
21 |
int64_t seek_timestamp = timestamp; |
|
1238 |
|||
1239 |
✓✗ | 21 |
if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) { |
1240 |
21 |
int dts_heuristic = 0; |
|
1241 |
✓✓ | 42 |
for (i=0; i<ic->nb_streams; i++) { |
1242 |
21 |
const AVCodecParameters *par = ic->streams[i]->codecpar; |
|
1243 |
✗✓ | 21 |
if (par->video_delay) { |
1244 |
dts_heuristic = 1; |
||
1245 |
break; |
||
1246 |
} |
||
1247 |
} |
||
1248 |
✗✓ | 21 |
if (dts_heuristic) { |
1249 |
seek_timestamp -= 3*AV_TIME_BASE / 23; |
||
1250 |
} |
||
1251 |
} |
||
1252 |
21 |
ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0); |
|
1253 |
✓✓ | 21 |
if (ret < 0) { |
1254 |
1 |
av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n", |
|
1255 |
1 |
filename, (double)timestamp / AV_TIME_BASE); |
|
1256 |
} |
||
1257 |
} |
||
1258 |
|||
1259 |
/* update the current parameters so that they match the one of the input stream */ |
||
1260 |
6038 |
add_input_streams(o, ic); |
|
1261 |
|||
1262 |
/* dump the file content */ |
||
1263 |
6038 |
av_dump_format(ic, nb_input_files, filename, 0); |
|
1264 |
|||
1265 |
6038 |
GROW_ARRAY(input_files, nb_input_files); |
|
1266 |
6038 |
f = av_mallocz(sizeof(*f)); |
|
1267 |
✗✓ | 6038 |
if (!f) |
1268 |
exit_program(1); |
||
1269 |
6038 |
input_files[nb_input_files - 1] = f; |
|
1270 |
|||
1271 |
6038 |
f->ctx = ic; |
|
1272 |
6038 |
f->ist_index = nb_input_streams - ic->nb_streams; |
|
1273 |
6038 |
f->start_time = o->start_time; |
|
1274 |
6038 |
f->recording_time = o->recording_time; |
|
1275 |
6038 |
f->input_ts_offset = o->input_ts_offset; |
|
1276 |
✓✓✗✓ ✗✗ |
6038 |
f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp); |
1277 |
6038 |
f->nb_streams = ic->nb_streams; |
|
1278 |
6038 |
f->rate_emu = o->rate_emu; |
|
1279 |
6038 |
f->accurate_seek = o->accurate_seek; |
|
1280 |
6038 |
f->loop = o->loop; |
|
1281 |
6038 |
f->duration = 0; |
|
1282 |
6038 |
f->time_base = (AVRational){ 1, 1 }; |
|
1283 |
6038 |
f->pkt = av_packet_alloc(); |
|
1284 |
✗✓ | 6038 |
if (!f->pkt) |
1285 |
exit_program(1); |
||
1286 |
#if HAVE_THREADS |
||
1287 |
6038 |
f->thread_queue_size = o->thread_queue_size; |
|
1288 |
#endif |
||
1289 |
|||
1290 |
/* check if all codec options have been used */ |
||
1291 |
6038 |
unused_opts = strip_specifiers(o->g->codec_opts); |
|
1292 |
✓✓ | 12442 |
for (i = f->ist_index; i < nb_input_streams; i++) { |
1293 |
6404 |
e = NULL; |
|
1294 |
✓✓ | 26027 |
while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e, |
1295 |
AV_DICT_IGNORE_SUFFIX))) |
||
1296 |
19623 |
av_dict_set(&unused_opts, e->key, NULL, 0); |
|
1297 |
} |
||
1298 |
|||
1299 |
6038 |
e = NULL; |
|
1300 |
✓✓ | 6327 |
while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) { |
1301 |
289 |
const AVClass *class = avcodec_get_class(); |
|
1302 |
289 |
const AVOption *option = av_opt_find(&class, e->key, NULL, 0, |
|
1303 |
AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ); |
||
1304 |
289 |
const AVClass *fclass = avformat_get_class(); |
|
1305 |
289 |
const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0, |
|
1306 |
AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ); |
||
1307 |
✓✗✗✓ |
289 |
if (!option || foption) |
1308 |
continue; |
||
1309 |
|||
1310 |
|||
1311 |
✗✓ | 289 |
if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) { |
1312 |
av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for " |
||
1313 |
"input file #%d (%s) is not a decoding option.\n", e->key, |
||
1314 |
option->help ? option->help : "", nb_input_files - 1, |
||
1315 |
filename); |
||
1316 |
exit_program(1); |
||
1317 |
} |
||
1318 |
|||
1319 |
289 |
av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for " |
|
1320 |
"input file #%d (%s) has not been used for any stream. The most " |
||
1321 |
"likely reason is either wrong type (e.g. a video option with " |
||
1322 |
"no video streams) or that it is a private option of some decoder " |
||
1323 |
"which was not actually used for any stream.\n", e->key, |
||
1324 |
✓✗ | 289 |
option->help ? option->help : "", nb_input_files - 1, filename); |
1325 |
} |
||
1326 |
6038 |
av_dict_free(&unused_opts); |
|
1327 |
|||
1328 |
✗✓ | 6038 |
for (i = 0; i < o->nb_dump_attachment; i++) { |
1329 |
int j; |
||
1330 |
|||
1331 |
for (j = 0; j < ic->nb_streams; j++) { |
||
1332 |
AVStream *st = ic->streams[j]; |
||
1333 |
|||
1334 |
if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1) |
||
1335 |
dump_attachment(st, o->dump_attachment[i].u.str); |
||
1336 |
} |
||
1337 |
} |
||
1338 |
|||
1339 |
6038 |
input_stream_potentially_available = 1; |
|
1340 |
|||
1341 |
6038 |
return 0; |
|
1342 |
} |
||
1343 |
|||
1344 |
static uint8_t *get_line(AVIOContext *s) |
||
1345 |
{ |
||
1346 |
AVIOContext *line; |
||
1347 |
uint8_t *buf; |
||
1348 |
char c; |
||
1349 |
|||
1350 |
if (avio_open_dyn_buf(&line) < 0) { |
||
1351 |
av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n"); |
||
1352 |
exit_program(1); |
||
1353 |
} |
||
1354 |
|||
1355 |
while ((c = avio_r8(s)) && c != '\n') |
||
1356 |
avio_w8(line, c); |
||
1357 |
avio_w8(line, 0); |
||
1358 |
avio_close_dyn_buf(line, &buf); |
||
1359 |
|||
1360 |
return buf; |
||
1361 |
} |
||
1362 |
|||
1363 |
static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s) |
||
1364 |
{ |
||
1365 |
int i, ret = -1; |
||
1366 |
char filename[1000]; |
||
1367 |
const char *base[3] = { getenv("AVCONV_DATADIR"), |
||
1368 |
getenv("HOME"), |
||
1369 |
AVCONV_DATADIR, |
||
1370 |
}; |
||
1371 |
|||
1372 |
for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) { |
||
1373 |
if (!base[i]) |
||
1374 |
continue; |
||
1375 |
if (codec_name) { |
||
1376 |
snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i], |
||
1377 |
i != 1 ? "" : "/.avconv", codec_name, preset_name); |
||
1378 |
ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL); |
||
1379 |
} |
||
1380 |
if (ret < 0) { |
||
1381 |
snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i], |
||
1382 |
i != 1 ? "" : "/.avconv", preset_name); |
||
1383 |
ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL); |
||
1384 |
} |
||
1385 |
} |
||
1386 |
return ret; |
||
1387 |
} |
||
1388 |
|||
1389 |
6193 |
static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost) |
|
1390 |
{ |
||
1391 |
6193 |
enum AVMediaType type = ost->st->codecpar->codec_type; |
|
1392 |
6193 |
char *codec_name = NULL; |
|
1393 |
|||
1394 |
✓✓✓✓ ✓✓ |
6193 |
if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) { |
1395 |
✓✓✗✓ ✓✓✓✓ ✓✗✓✗ ✓✓✓✓ ✓✓✓✗ |
10260 |
MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st); |
1396 |
✓✓ | 6182 |
if (!codec_name) { |
1397 |
5314 |
ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url, |
|
1398 |
2657 |
NULL, ost->st->codecpar->codec_type); |
|
1399 |
2657 |
ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id); |
|
1400 |
✗✓ | 2657 |
if (!ost->enc) { |
1401 |
av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for " |
||
1402 |
"output stream #%d:%d. Default encoder for format %s (codec %s) is " |
||
1403 |
"probably disabled. Please choose an encoder manually.\n", |
||
1404 |
ost->file_index, ost->index, s->oformat->name, |
||
1405 |
avcodec_get_name(ost->st->codecpar->codec_id)); |
||
1406 |
return AVERROR_ENCODER_NOT_FOUND; |
||
1407 |
} |
||
1408 |
✓✓ | 3525 |
} else if (!strcmp(codec_name, "copy")) |
1409 |
336 |
ost->stream_copy = 1; |
|
1410 |
else { |
||
1411 |
3189 |
ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1); |
|
1412 |
3189 |
ost->st->codecpar->codec_id = ost->enc->id; |
|
1413 |
} |
||
1414 |
6182 |
ost->encoding_needed = !ost->stream_copy; |
|
1415 |
} else { |
||
1416 |
/* no encoding supported for other media types */ |
||
1417 |
11 |
ost->stream_copy = 1; |
|
1418 |
11 |
ost->encoding_needed = 0; |
|
1419 |
} |
||
1420 |
|||
1421 |
6193 |
return 0; |
|
1422 |
} |
||
1423 |
|||
1424 |
6193 |
static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index) |
|
1425 |
{ |
||
1426 |
OutputStream *ost; |
||
1427 |
6193 |
AVStream *st = avformat_new_stream(oc, NULL); |
|
1428 |
6193 |
int idx = oc->nb_streams - 1, ret = 0; |
|
1429 |
6193 |
const char *bsfs = NULL, *time_base = NULL; |
|
1430 |
6193 |
char *next, *codec_tag = NULL; |
|
1431 |
6193 |
double qscale = -1; |
|
1432 |
int i; |
||
1433 |
|||
1434 |
✗✓ | 6193 |
if (!st) { |
1435 |
av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n"); |
||
1436 |
exit_program(1); |
||
1437 |
} |
||
1438 |
|||
1439 |
✗✓ | 6193 |
if (oc->nb_streams - 1 < o->nb_streamid_map) |
1440 |
st->id = o->streamid_map[oc->nb_streams - 1]; |
||
1441 |
|||
1442 |
6193 |
GROW_ARRAY(output_streams, nb_output_streams); |
|
1443 |
✗✓ | 6193 |
if (!(ost = av_mallocz(sizeof(*ost)))) |
1444 |
exit_program(1); |
||
1445 |
6193 |
output_streams[nb_output_streams - 1] = ost; |
|
1446 |
|||
1447 |
6193 |
ost->file_index = nb_output_files - 1; |
|
1448 |
6193 |
ost->index = idx; |
|
1449 |
6193 |
ost->st = st; |
|
1450 |
6193 |
ost->forced_kf_ref_pts = AV_NOPTS_VALUE; |
|
1451 |
6193 |
st->codecpar->codec_type = type; |
|
1452 |
|||
1453 |
6193 |
ret = choose_encoder(o, oc, ost); |
|
1454 |
✗✓ | 6193 |
if (ret < 0) { |
1455 |
av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream " |
||
1456 |
"%d:%d\n", ost->file_index, ost->index); |
||
1457 |
exit_program(1); |
||
1458 |
} |
||
1459 |
|||
1460 |
6193 |
ost->enc_ctx = avcodec_alloc_context3(ost->enc); |
|
1461 |
✗✓ | 6193 |
if (!ost->enc_ctx) { |
1462 |
av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n"); |
||
1463 |
exit_program(1); |
||
1464 |
} |
||
1465 |
6193 |
ost->enc_ctx->codec_type = type; |
|
1466 |
|||
1467 |
6193 |
ost->ref_par = avcodec_parameters_alloc(); |
|
1468 |
✗✓ | 6193 |
if (!ost->ref_par) { |
1469 |
av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n"); |
||
1470 |
exit_program(1); |
||
1471 |
} |
||
1472 |
|||
1473 |
✓✓ | 6193 |
if (ost->enc) { |
1474 |
5846 |
AVIOContext *s = NULL; |
|
1475 |
5846 |
char *buf = NULL, *arg = NULL, *preset = NULL; |
|
1476 |
|||
1477 |
5846 |
ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc); |
|
1478 |
|||
1479 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
5846 |
MATCH_PER_STREAM_OPT(presets, str, preset, oc, st); |
1480 |
5846 |
ost->autoscale = 1; |
|
1481 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
5846 |
MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st); |
1482 |
✗✓✗✗ |
5846 |
if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) { |
1483 |
do { |
||
1484 |
buf = get_line(s); |
||
1485 |
if (!buf[0] || buf[0] == '#') { |
||
1486 |
av_free(buf); |
||
1487 |
continue; |
||
1488 |
} |
||
1489 |
if (!(arg = strchr(buf, '='))) { |
||
1490 |
av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n"); |
||
1491 |
exit_program(1); |
||
1492 |
} |
||
1493 |
*arg++ = 0; |
||
1494 |
av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE); |
||
1495 |
av_free(buf); |
||
1496 |
} while (!s->eof_reached); |
||
1497 |
avio_closep(&s); |
||
1498 |
} |
||
1499 |
✗✓ | 5846 |
if (ret) { |
1500 |
av_log(NULL, AV_LOG_FATAL, |
||
1501 |
"Preset %s specified for stream %d:%d, but could not be opened.\n", |
||
1502 |
preset, ost->file_index, ost->index); |
||
1503 |
exit_program(1); |
||
1504 |
} |
||
1505 |
} else { |
||
1506 |
347 |
ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL); |
|
1507 |
} |
||
1508 |
|||
1509 |
|||
1510 |
✓✓ | 6193 |
if (o->bitexact) |
1511 |
1696 |
ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT; |
|
1512 |
|||
1513 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6194 |
MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st); |
1514 |
✓✓ | 6193 |
if (time_base) { |
1515 |
AVRational q; |
||
1516 |
✓✗ | 1 |
if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 || |
1517 |
✓✗✗✓ |
1 |
q.num <= 0 || q.den <= 0) { |
1518 |
av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base); |
||
1519 |
exit_program(1); |
||
1520 |
} |
||
1521 |
1 |
st->time_base = q; |
|
1522 |
} |
||
1523 |
|||
1524 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6193 |
MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st); |
1525 |
✓✓ | 6193 |
if (time_base) { |
1526 |
AVRational q; |
||
1527 |
✓✗ | 1 |
if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 || |
1528 |
✗✓ | 1 |
q.den <= 0) { |
1529 |
av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base); |
||
1530 |
exit_program(1); |
||
1531 |
} |
||
1532 |
1 |
ost->enc_timebase = q; |
|
1533 |
} |
||
1534 |
|||
1535 |
6193 |
ost->max_frames = INT64_MAX; |
|
1536 |
✓✓✗✓ ✓✓✓✓ ✓✗✓✗ ✓✓✓✓ ✓✓✓✗ |
18078 |
MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st); |
1537 |
✓✓ | 10460 |
for (i = 0; i<o->nb_max_frames; i++) { |
1538 |
4273 |
char *p = o->max_frames[i].specifier; |
|
1539 |
✓✓✓✓ |
4273 |
if (!*p && type != AVMEDIA_TYPE_VIDEO) { |
1540 |
6 |
av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n"); |
|
1541 |
6 |
break; |
|
1542 |
} |
||
1543 |
} |
||
1544 |
|||
1545 |
6193 |
ost->copy_prior_start = -1; |
|
1546 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6193 |
MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st); |
1547 |
|||
1548 |
✓✓✗✓ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6290 |
MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st); |
1549 |
✓✓✓✗ |
6193 |
if (bsfs && *bsfs) { |
1550 |
88 |
ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx); |
|
1551 |
✗✓ | 88 |
if (ret < 0) { |
1552 |
av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret)); |
||
1553 |
exit_program(1); |
||
1554 |
} |
||
1555 |
} |
||
1556 |
|||
1557 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6199 |
MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st); |
1558 |
✓✓ | 6193 |
if (codec_tag) { |
1559 |
6 |
uint32_t tag = strtol(codec_tag, &next, 0); |
|
1560 |
✓✗ | 6 |
if (*next) |
1561 |
6 |
tag = AV_RL32(codec_tag); |
|
1562 |
6 |
ost->st->codecpar->codec_tag = |
|
1563 |
6 |
ost->enc_ctx->codec_tag = tag; |
|
1564 |
} |
||
1565 |
|||
1566 |
✓✓✗✓ ✓✓✓✓ ✓✗✓✗ ✓✓✗✓ ✓✓✓✗ |
6479 |
MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st); |
1567 |
✓✓ | 6193 |
if (qscale >= 0) { |
1568 |
232 |
ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE; |
|
1569 |
232 |
ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale; |
|
1570 |
} |
||
1571 |
|||
1572 |
✓✓✗✓ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6228 |
MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st); |
1573 |
6193 |
ost->disposition = av_strdup(ost->disposition); |
|
1574 |
|||
1575 |
6193 |
ost->max_muxing_queue_size = 128; |
|
1576 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6195 |
MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st); |
1577 |
6193 |
ost->max_muxing_queue_size *= sizeof(ost->pkt); |
|
1578 |
|||
1579 |
6193 |
ost->muxing_queue_data_size = 0; |
|
1580 |
|||
1581 |
6193 |
ost->muxing_queue_data_threshold = 50*1024*1024; |
|
1582 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6193 |
MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st); |
1583 |
|||
1584 |
✓✓ | 6193 |
if (oc->oformat->flags & AVFMT_GLOBALHEADER) |
1585 |
2365 |
ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER; |
|
1586 |
|||
1587 |
6193 |
av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0); |
|
1588 |
|||
1589 |
6193 |
av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0); |
|
1590 |
✓✓✓✓ |
6193 |
if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24) |
1591 |
52 |
av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0); |
|
1592 |
|||
1593 |
6193 |
av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0); |
|
1594 |
|||
1595 |
6193 |
ost->source_index = source_index; |
|
1596 |
✓✓ | 6193 |
if (source_index >= 0) { |
1597 |
6109 |
ost->sync_ist = input_streams[source_index]; |
|
1598 |
6109 |
input_streams[source_index]->discard = 0; |
|
1599 |
6109 |
input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard; |
|
1600 |
} |
||
1601 |
6193 |
ost->last_mux_dts = AV_NOPTS_VALUE; |
|
1602 |
|||
1603 |
6193 |
ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket)); |
|
1604 |
✗✓ | 6193 |
if (!ost->muxing_queue) |
1605 |
exit_program(1); |
||
1606 |
|||
1607 |
6193 |
return ost; |
|
1608 |
} |
||
1609 |
|||
1610 |
static void parse_matrix_coeffs(uint16_t *dest, const char *str) |
||
1611 |
{ |
||
1612 |
int i; |
||
1613 |
const char *p = str; |
||
1614 |
for (i = 0;; i++) { |
||
1615 |
dest[i] = atoi(p); |
||
1616 |
if (i == 63) |
||
1617 |
break; |
||
1618 |
p = strchr(p, ','); |
||
1619 |
if (!p) { |
||
1620 |
av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i); |
||
1621 |
exit_program(1); |
||
1622 |
} |
||
1623 |
p++; |
||
1624 |
} |
||
1625 |
} |
||
1626 |
|||
1627 |
/* read file contents into a string */ |
||
1628 |
28 |
static uint8_t *read_file(const char *filename) |
|
1629 |
{ |
||
1630 |
28 |
AVIOContext *pb = NULL; |
|
1631 |
28 |
AVIOContext *dyn_buf = NULL; |
|
1632 |
28 |
int ret = avio_open(&pb, filename, AVIO_FLAG_READ); |
|
1633 |
uint8_t buf[1024], *str; |
||
1634 |
|||
1635 |
✗✓ | 28 |
if (ret < 0) { |
1636 |
av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename); |
||
1637 |
return NULL; |
||
1638 |
} |
||
1639 |
|||
1640 |
28 |
ret = avio_open_dyn_buf(&dyn_buf); |
|
1641 |
✗✓ | 28 |
if (ret < 0) { |
1642 |
avio_closep(&pb); |
||
1643 |
return NULL; |
||
1644 |
} |
||
1645 |
✓✓ | 56 |
while ((ret = avio_read(pb, buf, sizeof(buf))) > 0) |
1646 |
28 |
avio_write(dyn_buf, buf, ret); |
|
1647 |
28 |
avio_w8(dyn_buf, 0); |
|
1648 |
28 |
avio_closep(&pb); |
|
1649 |
|||
1650 |
28 |
ret = avio_close_dyn_buf(dyn_buf, &str); |
|
1651 |
✗✓ | 28 |
if (ret < 0) |
1652 |
return NULL; |
||
1653 |
28 |
return str; |
|
1654 |
} |
||
1655 |
|||
1656 |
5814 |
static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc, |
|
1657 |
OutputStream *ost) |
||
1658 |
{ |
||
1659 |
5814 |
AVStream *st = ost->st; |
|
1660 |
|||
1661 |
✓✓✗✓ |
5814 |
if (ost->filters_script && ost->filters) { |
1662 |
av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for " |
||
1663 |
"output stream #%d:%d.\n", nb_output_files, st->index); |
||
1664 |
exit_program(1); |
||
1665 |
} |
||
1666 |
|||
1667 |
✓✓ | 5814 |
if (ost->filters_script) |
1668 |
4 |
return read_file(ost->filters_script); |
|
1669 |
✓✓ | 5810 |
else if (ost->filters) |
1670 |
3091 |
return av_strdup(ost->filters); |
|
1671 |
|||
1672 |
✓✓ | 2719 |
return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ? |
1673 |
"null" : "anull"); |
||
1674 |
} |
||
1675 |
|||
1676 |
321 |
static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc, |
|
1677 |
const OutputStream *ost, enum AVMediaType type) |
||
1678 |
{ |
||
1679 |
✓✗✗✓ |
321 |
if (ost->filters_script || ost->filters) { |
1680 |
av_log(NULL, AV_LOG_ERROR, |
||
1681 |
"%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n" |
||
1682 |
"Filtering and streamcopy cannot be used together.\n", |
||
1683 |
ost->filters ? "Filtergraph" : "Filtergraph script", |
||
1684 |
ost->filters ? ost->filters : ost->filters_script, |
||
1685 |
av_get_media_type_string(type), ost->file_index, ost->index); |
||
1686 |
exit_program(1); |
||
1687 |
} |
||
1688 |
321 |
} |
|
1689 |
|||
1690 |
4881 |
static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index) |
|
1691 |
{ |
||
1692 |
AVStream *st; |
||
1693 |
OutputStream *ost; |
||
1694 |
AVCodecContext *video_enc; |
||
1695 |
4881 |
char *frame_rate = NULL, *max_frame_rate = NULL, *frame_aspect_ratio = NULL; |
|
1696 |
|||
1697 |
4881 |
ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index); |
|
1698 |
4881 |
st = ost->st; |
|
1699 |
4881 |
video_enc = ost->enc_ctx; |
|
1700 |
|||
1701 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4902 |
MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st); |
1702 |
✓✓✗✓ |
4881 |
if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) { |
1703 |
av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate); |
||
1704 |
exit_program(1); |
||
1705 |
} |
||
1706 |
|||
1707 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4881 |
MATCH_PER_STREAM_OPT(max_frame_rates, str, max_frame_rate, oc, st); |
1708 |
✗✓✗✗ |
4881 |
if (max_frame_rate && av_parse_video_rate(&ost->max_frame_rate, max_frame_rate) < 0) { |
1709 |
av_log(NULL, AV_LOG_FATAL, "Invalid maximum framerate value: %s\n", max_frame_rate); |
||
1710 |
exit_program(1); |
||
1711 |
} |
||
1712 |
|||
1713 |
✓✓✗✓ |
4881 |
if (frame_rate && max_frame_rate) { |
1714 |
av_log(NULL, AV_LOG_ERROR, "Only one of -fpsmax and -r can be set for a stream.\n"); |
||
1715 |
exit_program(1); |
||
1716 |
} |
||
1717 |
|||
1718 |
✓✓✗✓ |
4881 |
if ((frame_rate || max_frame_rate) && |
1719 |
✗✓ | 21 |
video_sync_method == VSYNC_PASSTHROUGH) |
1720 |
av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r/-fpsmax can produce invalid output files\n"); |
||
1721 |
|||
1722 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4881 |
MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st); |
1723 |
✗✓ | 4881 |
if (frame_aspect_ratio) { |
1724 |
AVRational q; |
||
1725 |
if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 || |
||
1726 |
q.num <= 0 || q.den <= 0) { |
||
1727 |
av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio); |
||
1728 |
exit_program(1); |
||
1729 |
} |
||
1730 |
ost->frame_aspect_ratio = q; |
||
1731 |
} |
||
1732 |
|||
1733 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4884 |
MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st); |
1734 |
✓✓✗✓ ✓✓✓✓ ✓✗✓✗ ✓✓✓✓ ✓✓✓✗ |
7453 |
MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st); |
1735 |
|||
1736 |
✓✓ | 4881 |
if (!ost->stream_copy) { |
1737 |
4686 |
const char *p = NULL; |
|
1738 |
4686 |
char *frame_size = NULL; |
|
1739 |
4686 |
char *frame_pix_fmt = NULL; |
|
1740 |
4686 |
char *intra_matrix = NULL, *inter_matrix = NULL; |
|
1741 |
4686 |
char *chroma_intra_matrix = NULL; |
|
1742 |
4686 |
int do_pass = 0; |
|
1743 |
int i; |
||
1744 |
|||
1745 |
✓✗✗✗ ✓✓✓✓ ✓✗✗✓ ✗✓✗✗ ✓✓✗✓ |
5301 |
MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st); |
1746 |
✓✓✗✓ |
4686 |
if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) { |
1747 |
av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size); |
||
1748 |
exit_program(1); |
||
1749 |
} |
||
1750 |
|||
1751 |
4686 |
video_enc->bits_per_raw_sample = frame_bits_per_raw_sample; |
|
1752 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
8051 |
MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st); |
1753 |
✓✓✗✓ |
4686 |
if (frame_pix_fmt && *frame_pix_fmt == '+') { |
1754 |
ost->keep_pix_fmt = 1; |
||
1755 |
if (!*++frame_pix_fmt) |
||
1756 |
frame_pix_fmt = NULL; |
||
1757 |
} |
||
1758 |
✓✓✗✓ |
4686 |
if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) { |
1759 |
av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt); |
||
1760 |
exit_program(1); |
||
1761 |
} |
||
1762 |
4686 |
st->sample_aspect_ratio = video_enc->sample_aspect_ratio; |
|
1763 |
|||
1764 |
✗✓ | 4686 |
if (intra_only) |
1765 |
video_enc->gop_size = 0; |
||
1766 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4686 |
MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st); |
1767 |
✗✓ | 4686 |
if (intra_matrix) { |
1768 |
if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) { |
||
1769 |
av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n"); |
||
1770 |
exit_program(1); |
||
1771 |
} |
||
1772 |
parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix); |
||
1773 |
} |
||
1774 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4686 |
MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st); |
1775 |
✗✓ | 4686 |
if (chroma_intra_matrix) { |
1776 |
uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64); |
||
1777 |
if (!p) { |
||
1778 |
av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n"); |
||
1779 |
exit_program(1); |
||
1780 |
} |
||
1781 |
video_enc->chroma_intra_matrix = p; |
||
1782 |
parse_matrix_coeffs(p, chroma_intra_matrix); |
||
1783 |
} |
||
1784 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4686 |
MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st); |
1785 |
✗✓ | 4686 |
if (inter_matrix) { |
1786 |
if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) { |
||
1787 |
av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n"); |
||
1788 |
exit_program(1); |
||
1789 |
} |
||
1790 |
parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix); |
||
1791 |
} |
||
1792 |
|||
1793 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4686 |
MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st); |
1794 |
✗✓ | 4686 |
for (i = 0; p; i++) { |
1795 |
int start, end, q; |
||
1796 |
int e = sscanf(p, "%d,%d,%d", &start, &end, &q); |
||
1797 |
if (e != 3) { |
||
1798 |
av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n"); |
||
1799 |
exit_program(1); |
||
1800 |
} |
||
1801 |
video_enc->rc_override = |
||
1802 |
av_realloc_array(video_enc->rc_override, |
||
1803 |
i + 1, sizeof(RcOverride)); |
||
1804 |
if (!video_enc->rc_override) { |
||
1805 |
av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n"); |
||
1806 |
exit_program(1); |
||
1807 |
} |
||
1808 |
video_enc->rc_override[i].start_frame = start; |
||
1809 |
video_enc->rc_override[i].end_frame = end; |
||
1810 |
if (q > 0) { |
||
1811 |
video_enc->rc_override[i].qscale = q; |
||
1812 |
video_enc->rc_override[i].quality_factor = 1.0; |
||
1813 |
} |
||
1814 |
else { |
||
1815 |
video_enc->rc_override[i].qscale = 0; |
||
1816 |
video_enc->rc_override[i].quality_factor = -q/100.0; |
||
1817 |
} |
||
1818 |
p = strchr(p, '/'); |
||
1819 |
if (p) p++; |
||
1820 |
} |
||
1821 |
4686 |
video_enc->rc_override_count = i; |
|
1822 |
|||
1823 |
✗✓ | 4686 |
if (do_psnr) |
1824 |
video_enc->flags|= AV_CODEC_FLAG_PSNR; |
||
1825 |
|||
1826 |
/* two pass mode */ |
||
1827 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4686 |
MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st); |
1828 |
✗✓ | 4686 |
if (do_pass) { |
1829 |
if (do_pass & 1) { |
||
1830 |
video_enc->flags |= AV_CODEC_FLAG_PASS1; |
||
1831 |
av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND); |
||
1832 |
} |
||
1833 |
if (do_pass & 2) { |
||
1834 |
video_enc->flags |= AV_CODEC_FLAG_PASS2; |
||
1835 |
av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND); |
||
1836 |
} |
||
1837 |
} |
||
1838 |
|||
1839 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4686 |
MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st); |
1840 |
✗✓ | 4686 |
if (ost->logfile_prefix && |
1841 |
!(ost->logfile_prefix = av_strdup(ost->logfile_prefix))) |
||
1842 |
exit_program(1); |
||
1843 |
|||
1844 |
✗✓ | 4686 |
if (do_pass) { |
1845 |
char logfilename[1024]; |
||
1846 |
FILE *f; |
||
1847 |
|||
1848 |
snprintf(logfilename, sizeof(logfilename), "%s-%d.log", |
||
1849 |
ost->logfile_prefix ? ost->logfile_prefix : |
||
1850 |
DEFAULT_PASS_LOGFILENAME_PREFIX, |
||
1851 |
i); |
||
1852 |
if (!strcmp(ost->enc->name, "libx264")) { |
||
1853 |
av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE); |
||
1854 |
} else { |
||
1855 |
if (video_enc->flags & AV_CODEC_FLAG_PASS2) { |
||
1856 |
char *logbuffer = read_file(logfilename); |
||
1857 |
|||
1858 |
if (!logbuffer) { |
||
1859 |
av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n", |
||
1860 |
logfilename); |
||
1861 |
exit_program(1); |
||
1862 |
} |
||
1863 |
video_enc->stats_in = logbuffer; |
||
1864 |
} |
||
1865 |
if (video_enc->flags & AV_CODEC_FLAG_PASS1) { |
||
1866 |
f = av_fopen_utf8(logfilename, "wb"); |
||
1867 |
if (!f) { |
||
1868 |
av_log(NULL, AV_LOG_FATAL, |
||
1869 |
"Cannot write log file '%s' for pass-1 encoding: %s\n", |
||
1870 |
logfilename, strerror(errno)); |
||
1871 |
exit_program(1); |
||
1872 |
} |
||
1873 |
ost->logfile = f; |
||
1874 |
} |
||
1875 |
} |
||
1876 |
} |
||
1877 |
|||
1878 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4687 |
MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st); |
1879 |
✓✓ | 4686 |
if (ost->forced_keyframes) |
1880 |
1 |
ost->forced_keyframes = av_strdup(ost->forced_keyframes); |
|
1881 |
|||
1882 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4686 |
MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st); |
1883 |
|||
1884 |
4686 |
ost->top_field_first = -1; |
|
1885 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
4689 |
MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st); |
1886 |
|||
1887 |
|||
1888 |
4686 |
ost->avfilter = get_ost_filters(o, oc, ost); |
|
1889 |
✗✓ | 4686 |
if (!ost->avfilter) |
1890 |
exit_program(1); |
||
1891 |
} else { |
||
1892 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
195 |
MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st); |
1893 |
} |
||
1894 |
|||
1895 |
✓✓ | 4881 |
if (ost->stream_copy) |
1896 |
195 |
check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO); |
|
1897 |
|||
1898 |
4881 |
return ost; |
|
1899 |
} |
||
1900 |
|||
1901 |
1254 |
static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index) |
|
1902 |
{ |
||
1903 |
int n; |
||
1904 |
AVStream *st; |
||
1905 |
OutputStream *ost; |
||
1906 |
AVCodecContext *audio_enc; |
||
1907 |
|||
1908 |
1254 |
ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index); |
|
1909 |
1254 |
st = ost->st; |
|
1910 |
|||
1911 |
1254 |
audio_enc = ost->enc_ctx; |
|
1912 |
1254 |
audio_enc->codec_type = AVMEDIA_TYPE_AUDIO; |
|
1913 |
|||
1914 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1255 |
MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st); |
1915 |
✓✓✗✓ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1843 |
MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st); |
1916 |
|||
1917 |
✓✓ | 1254 |
if (!ost->stream_copy) { |
1918 |
1128 |
char *sample_fmt = NULL; |
|
1919 |
|||
1920 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1140 |
MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st); |
1921 |
|||
1922 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1128 |
MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st); |
1923 |
✗✓ | 1128 |
if (sample_fmt && |
1924 |
(audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) { |
||
1925 |
av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt); |
||
1926 |
exit_program(1); |
||
1927 |
} |
||
1928 |
|||
1929 |
✓✗✗✗ ✓✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1153 |
MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st); |
1930 |
|||
1931 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1128 |
MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st); |
1932 |
1128 |
ost->apad = av_strdup(ost->apad); |
|
1933 |
|||
1934 |
1128 |
ost->avfilter = get_ost_filters(o, oc, ost); |
|
1935 |
✗✓ | 1128 |
if (!ost->avfilter) |
1936 |
exit_program(1); |
||
1937 |
|||
1938 |
/* check for channel mapping for this audio stream */ |
||
1939 |
✓✓ | 1138 |
for (n = 0; n < o->nb_audio_channel_maps; n++) { |
1940 |
10 |
AudioChannelMap *map = &o->audio_channel_maps[n]; |
|
1941 |
✗✓✗✗ |
10 |
if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) && |
1942 |
✗✓✗✗ |
10 |
(map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) { |
1943 |
InputStream *ist; |
||
1944 |
|||
1945 |
✓✓ | 10 |
if (map->channel_idx == -1) { |
1946 |
1 |
ist = NULL; |
|
1947 |
✗✓ | 9 |
} else if (ost->source_index < 0) { |
1948 |
av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n", |
||
1949 |
ost->file_index, ost->st->index); |
||
1950 |
continue; |
||
1951 |
} else { |
||
1952 |
9 |
ist = input_streams[ost->source_index]; |
|
1953 |
} |
||
1954 |
|||
1955 |
✓✓✓✗ ✓✗ |
10 |
if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) { |
1956 |
✗✓ | 10 |
if (av_reallocp_array(&ost->audio_channels_map, |
1957 |
10 |
ost->audio_channels_mapped + 1, |
|
1958 |
sizeof(*ost->audio_channels_map) |
||
1959 |
) < 0 ) |
||
1960 |
exit_program(1); |
||
1961 |
|||
1962 |
10 |
ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx; |
|
1963 |
} |
||
1964 |
} |
||
1965 |
} |
||
1966 |
} |
||
1967 |
|||
1968 |
✓✓ | 1254 |
if (ost->stream_copy) |
1969 |
126 |
check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO); |
|
1970 |
|||
1971 |
1254 |
return ost; |
|
1972 |
} |
||
1973 |
|||
1974 |
10 |
static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index) |
|
1975 |
{ |
||
1976 |
OutputStream *ost; |
||
1977 |
|||
1978 |
10 |
ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index); |
|
1979 |
✗✓ | 10 |
if (!ost->stream_copy) { |
1980 |
av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n"); |
||
1981 |
exit_program(1); |
||
1982 |
} |
||
1983 |
|||
1984 |
10 |
return ost; |
|
1985 |
} |
||
1986 |
|||
1987 |
static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index) |
||
1988 |
{ |
||
1989 |
OutputStream *ost; |
||
1990 |
|||
1991 |
ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index); |
||
1992 |
if (!ost->stream_copy) { |
||
1993 |
av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n"); |
||
1994 |
exit_program(1); |
||
1995 |
} |
||
1996 |
|||
1997 |
return ost; |
||
1998 |
} |
||
1999 |
|||
2000 |
1 |
static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index) |
|
2001 |
{ |
||
2002 |
1 |
OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index); |
|
2003 |
1 |
ost->stream_copy = 1; |
|
2004 |
1 |
ost->finished = 1; |
|
2005 |
1 |
return ost; |
|
2006 |
} |
||
2007 |
|||
2008 |
47 |
static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index) |
|
2009 |
{ |
||
2010 |
AVStream *st; |
||
2011 |
OutputStream *ost; |
||
2012 |
AVCodecContext *subtitle_enc; |
||
2013 |
|||
2014 |
47 |
ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index); |
|
2015 |
47 |
st = ost->st; |
|
2016 |
47 |
subtitle_enc = ost->enc_ctx; |
|
2017 |
|||
2018 |
47 |
subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE; |
|
2019 |
|||
2020 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
47 |
MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st); |
2021 |
|||
2022 |
✓✓ | 47 |
if (!ost->stream_copy) { |
2023 |
32 |
char *frame_size = NULL; |
|
2024 |
|||
2025 |
✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
32 |
MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st); |
2026 |
✗✓✗✗ |
32 |
if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) { |
2027 |
av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size); |
||
2028 |
exit_program(1); |
||
2029 |
} |
||
2030 |
} |
||
2031 |
|||
2032 |
47 |
return ost; |
|
2033 |
} |
||
2034 |
|||
2035 |
/* arg format is "output-stream-index:streamid-value". */ |
||
2036 |
static int opt_streamid(void *optctx, const char *opt, const char *arg) |
||
2037 |
{ |
||
2038 |
OptionsContext *o = optctx; |
||
2039 |
int idx; |
||
2040 |
char *p; |
||
2041 |
char idx_str[16]; |
||
2042 |
|||
2043 |
av_strlcpy(idx_str, arg, sizeof(idx_str)); |
||
2044 |
p = strchr(idx_str, ':'); |
||
2045 |
if (!p) { |
||
2046 |
av_log(NULL, AV_LOG_FATAL, |
||
2047 |
"Invalid value '%s' for option '%s', required syntax is 'index:value'\n", |
||
2048 |
arg, opt); |
||
2049 |
exit_program(1); |
||
2050 |
} |
||
2051 |
*p++ = '\0'; |
||
2052 |
idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1); |
||
2053 |
o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1); |
||
2054 |
o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX); |
||
2055 |
return 0; |
||
2056 |
} |
||
2057 |
|||
2058 |
15 |
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata) |
|
2059 |
{ |
||
2060 |
15 |
AVFormatContext *is = ifile->ctx; |
|
2061 |
15 |
AVFormatContext *os = ofile->ctx; |
|
2062 |
AVChapter **tmp; |
||
2063 |
int i; |
||
2064 |
|||
2065 |
15 |
tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters)); |
|
2066 |
✗✓ | 15 |
if (!tmp) |
2067 |
return AVERROR(ENOMEM); |
||
2068 |
15 |
os->chapters = tmp; |
|
2069 |
|||
2070 |
✓✓ | 37 |
for (i = 0; i < is->nb_chapters; i++) { |
2071 |
24 |
AVChapter *in_ch = is->chapters[i], *out_ch; |
|
2072 |
✗✓ | 24 |
int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time; |
2073 |
24 |
int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset, |
|
2074 |
24 |
AV_TIME_BASE_Q, in_ch->time_base); |
|
2075 |
✓✓ | 24 |
int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX : |
2076 |
3 |
av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base); |
|
2077 |
|||
2078 |
|||
2079 |
✗✓ | 24 |
if (in_ch->end < ts_off) |
2080 |
continue; |
||
2081 |
✓✓✓✓ |
24 |
if (rt != INT64_MAX && in_ch->start > rt + ts_off) |
2082 |
2 |
break; |
|
2083 |
|||
2084 |
22 |
out_ch = av_mallocz(sizeof(AVChapter)); |
|
2085 |
✗✓ | 22 |
if (!out_ch) |
2086 |
return AVERROR(ENOMEM); |
||
2087 |
|||
2088 |
22 |
out_ch->id = in_ch->id; |
|
2089 |
22 |
out_ch->time_base = in_ch->time_base; |
|
2090 |
22 |
out_ch->start = FFMAX(0, in_ch->start - ts_off); |
|
2091 |
22 |
out_ch->end = FFMIN(rt, in_ch->end - ts_off); |
|
2092 |
|||
2093 |
✓✗ | 22 |
if (copy_metadata) |
2094 |
22 |
av_dict_copy(&out_ch->metadata, in_ch->metadata, 0); |
|
2095 |
|||
2096 |
22 |
os->chapters[os->nb_chapters++] = out_ch; |
|
2097 |
} |
||
2098 |
15 |
return 0; |
|
2099 |
} |
||
2100 |
|||
2101 |
83 |
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, |
|
2102 |
AVFormatContext *oc) |
||
2103 |
{ |
||
2104 |
OutputStream *ost; |
||
2105 |
|||
2106 |
✓✓✗ | 83 |
switch (ofilter->type) { |
2107 |
68 |
case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break; |
|
2108 |
15 |
case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break; |
|
2109 |
default: |
||
2110 |
av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported " |
||
2111 |
"currently.\n"); |
||
2112 |
exit_program(1); |
||
2113 |
} |
||
2114 |
|||
2115 |
83 |
ost->source_index = -1; |
|
2116 |
83 |
ost->filter = ofilter; |
|
2117 |
|||
2118 |
83 |
ofilter->ost = ost; |
|
2119 |
83 |
ofilter->format = -1; |
|
2120 |
|||
2121 |
✗✓ | 83 |
if (ost->stream_copy) { |
2122 |
av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, " |
||
2123 |
"which is fed from a complex filtergraph. Filtering and streamcopy " |
||
2124 |
"cannot be used together.\n", ost->file_index, ost->index); |
||
2125 |
exit_program(1); |
||
2126 |
} |
||
2127 |
|||
2128 |
✓✗✓✗ ✗✓ |
83 |
if (ost->avfilter && (ost->filters || ost->filters_script)) { |
2129 |
const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script"; |
||
2130 |
av_log(NULL, AV_LOG_ERROR, |
||
2131 |
"%s '%s' was specified through the %s option " |
||
2132 |
"for output stream %d:%d, which is fed from a complex filtergraph.\n" |
||
2133 |
"%s and -filter_complex cannot be used together for the same stream.\n", |
||
2134 |
ost->filters ? "Filtergraph" : "Filtergraph script", |
||
2135 |
ost->filters ? ost->filters : ost->filters_script, |
||
2136 |
opt, ost->file_index, ost->index, opt); |
||
2137 |
exit_program(1); |
||
2138 |
} |
||
2139 |
|||
2140 |
83 |
avfilter_inout_free(&ofilter->out_tmp); |
|
2141 |
83 |
} |
|
2142 |
|||
2143 |
6010 |
static int init_complex_filters(void) |
|
2144 |
{ |
||
2145 |
6010 |
int i, ret = 0; |
|
2146 |
|||
2147 |
✓✓ | 6090 |
for (i = 0; i < nb_filtergraphs; i++) { |
2148 |
80 |
ret = init_complex_filtergraph(filtergraphs[i]); |
|
2149 |
✗✓ | 80 |
if (ret < 0) |
2150 |
return ret; |
||
2151 |
} |
||
2152 |
6010 |
return 0; |
|
2153 |
} |
||
2154 |
|||
2155 |
6011 |
static int open_output_file(OptionsContext *o, const char *filename) |
|
2156 |
{ |
||
2157 |
AVFormatContext *oc; |
||
2158 |
int i, j, err; |
||
2159 |
OutputFile *of; |
||
2160 |
OutputStream *ost; |
||
2161 |
InputStream *ist; |
||
2162 |
6011 |
AVDictionary *unused_opts = NULL; |
|
2163 |
6011 |
AVDictionaryEntry *e = NULL; |
|
2164 |
6011 |
int format_flags = 0; |
|
2165 |
|||
2166 |
✗✓✗✗ |
6011 |
if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) { |
2167 |
o->stop_time = INT64_MAX; |
||
2168 |
av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n"); |
||
2169 |
} |
||
2170 |
|||
2171 |
✗✓✗✗ |
6011 |
if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) { |
2172 |
int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time; |
||
2173 |
if (o->stop_time <= start_time) { |
||
2174 |
av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n"); |
||
2175 |
exit_program(1); |
||
2176 |
} else { |
||
2177 |
o->recording_time = o->stop_time - start_time; |
||
2178 |
} |
||
2179 |
} |
||
2180 |
|||
2181 |
6011 |
GROW_ARRAY(output_files, nb_output_files); |
|
2182 |
6011 |
of = av_mallocz(sizeof(*of)); |
|
2183 |
✗✓ | 6011 |
if (!of) |
2184 |
exit_program(1); |
||
2185 |
6011 |
output_files[nb_output_files - 1] = of; |
|
2186 |
|||
2187 |
6011 |
of->ost_index = nb_output_streams; |
|
2188 |
6011 |
of->recording_time = o->recording_time; |
|
2189 |
6011 |
of->start_time = o->start_time; |
|
2190 |
6011 |
of->limit_filesize = o->limit_filesize; |
|
2191 |
6011 |
of->shortest = o->shortest; |
|
2192 |
6011 |
av_dict_copy(&of->opts, o->g->format_opts, 0); |
|
2193 |
|||
2194 |
✓✓ | 6011 |
if (!strcmp(filename, "-")) |
2195 |
2239 |
filename = "pipe:"; |
|
2196 |
|||
2197 |
6011 |
err = avformat_alloc_output_context2(&oc, NULL, o->format, filename); |
|
2198 |
✗✓ | 6011 |
if (!oc) { |
2199 |
print_error(filename, err); |
||
2200 |
exit_program(1); |
||
2201 |
} |
||
2202 |
|||
2203 |
6011 |
of->ctx = oc; |
|
2204 |
✓✓ | 6011 |
if (o->recording_time != INT64_MAX) |
2205 |
137 |
oc->duration = o->recording_time; |
|
2206 |
|||
2207 |
6011 |
oc->interrupt_callback = int_cb; |
|
2208 |
|||
2209 |
6011 |
e = av_dict_get(o->g->format_opts, "fflags", NULL, 0); |
|
2210 |
✓✓ | 6011 |
if (e) { |
2211 |
3440 |
const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0); |
|
2212 |
3440 |
av_opt_eval_flags(oc, o, e->value, &format_flags); |
|
2213 |
} |
||
2214 |
✓✓ | 6011 |
if (o->bitexact) { |
2215 |
1649 |
format_flags |= AVFMT_FLAG_BITEXACT; |
|
2216 |
1649 |
oc->flags |= AVFMT_FLAG_BITEXACT; |
|
2217 |
} |
||
2218 |
|||
2219 |
/* create streams for all unlabeled output pads */ |
||
2220 |
✓✓ | 6092 |
for (i = 0; i < nb_filtergraphs; i++) { |
2221 |
81 |
FilterGraph *fg = filtergraphs[i]; |
|
2222 |
✓✓ | 165 |
for (j = 0; j < fg->nb_outputs; j++) { |
2223 |
84 |
OutputFilter *ofilter = fg->outputs[j]; |
|
2224 |
|||
2225 |
✓✓✓✓ |
84 |
if (!ofilter->out_tmp || ofilter->out_tmp->name) |
2226 |
4 |
continue; |
|
2227 |
|||
2228 |
✓✓✗✗ |
80 |
switch (ofilter->type) { |
2229 |
66 |
case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break; |
|
2230 |
14 |
case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break; |
|
2231 |
case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break; |
||
2232 |
} |
||
2233 |
80 |
init_output_filter(ofilter, o, oc); |
|
2234 |
} |
||
2235 |
} |
||
2236 |
|||
2237 |
✓✓ | 6011 |
if (!o->nb_stream_maps) { |
2238 |
5940 |
char *subtitle_codec_name = NULL; |
|
2239 |
/* pick the "best" stream of each type */ |
||
2240 |
|||
2241 |
/* video: highest resolution */ |
||
2242 |
✓✓✓✓ |
5940 |
if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) { |
2243 |
5012 |
int best_score = 0, idx = -1; |
|
2244 |
5012 |
int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0); |
|
2245 |
✓✓ | 10304 |
for (i = 0; i < nb_input_streams; i++) { |
2246 |
int score; |
||
2247 |
5292 |
ist = input_streams[i]; |
|
2248 |
10584 |
score = ist->st->codecpar->width * ist->st->codecpar->height |
|
2249 |
✓✓ | 5292 |
+ 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS) |
2250 |
✓✓ | 5292 |
+ 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT); |
2251 |
✗✓ | 5292 |
if (ist->user_set_discard == AVDISCARD_ALL) |
2252 |
continue; |
||
2253 |
✓✓✓✓ |
5292 |
if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC)) |
2254 |
8 |
score = 1; |
|
2255 |
✓✓✓✓ |
5292 |
if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && |
2256 |
score > best_score) { |
||
2257 |
✗✓✗✗ |
4760 |
if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC)) |
2258 |
continue; |
||
2259 |
4760 |
best_score = score; |
|
2260 |
4760 |
idx = i; |
|
2261 |
} |
||
2262 |
} |
||
2263 |
✓✓ | 5012 |
if (idx >= 0) |
2264 |
4760 |
new_video_stream(o, oc, idx); |
|
2265 |
} |
||
2266 |
|||
2267 |
/* audio: most channels */ |
||
2268 |
✓✓✓✓ |
5940 |
if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) { |
2269 |
5046 |
int best_score = 0, idx = -1; |
|
2270 |
✓✓ | 10263 |
for (i = 0; i < nb_input_streams; i++) { |
2271 |
int score; |
||
2272 |
5217 |
ist = input_streams[i]; |
|
2273 |
✓✓ | 5217 |
score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames |
2274 |
✓✓ | 5217 |
+ 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT); |
2275 |
✗✓ | 5217 |
if (ist->user_set_discard == AVDISCARD_ALL) |
2276 |
continue; |
||
2277 |
✓✓✓✓ |
5217 |
if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && |
2278 |
score > best_score) { |
||
2279 |
1177 |
best_score = score; |
|
2280 |
1177 |
idx = i; |
|
2281 |
} |
||
2282 |
} |
||
2283 |
✓✓ | 5046 |
if (idx >= 0) |
2284 |
1177 |
new_audio_stream(o, oc, idx); |
|
2285 |
} |
||
2286 |
|||
2287 |
/* subtitles: pick first */ |
||
2288 |
✓✓✓✓ |
9407 |
MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s"); |
2289 |
✓✓✓✓ ✓✓ |
5940 |
if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) { |
2290 |
✓✓ | 63 |
for (i = 0; i < nb_input_streams; i++) |
2291 |
✓✓ | 53 |
if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) { |
2292 |
AVCodecDescriptor const *input_descriptor = |
||
2293 |
38 |
avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id); |
|
2294 |
38 |
AVCodecDescriptor const *output_descriptor = NULL; |
|
2295 |
AVCodec const *output_codec = |
||
2296 |
38 |
avcodec_find_encoder(oc->oformat->subtitle_codec); |
|
2297 |
38 |
int input_props = 0, output_props = 0; |
|
2298 |
✗✓ | 38 |
if (input_streams[i]->user_set_discard == AVDISCARD_ALL) |
2299 |
continue; |
||
2300 |
✓✓ | 38 |
if (output_codec) |
2301 |
35 |
output_descriptor = avcodec_descriptor_get(output_codec->id); |
|
2302 |
✓✗ | 38 |
if (input_descriptor) |
2303 |
38 |
input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB); |
|
2304 |
✓✓ | 38 |
if (output_descriptor) |
2305 |
35 |
output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB); |
|
2306 |
✓✓ | 38 |
if (subtitle_codec_name || |
2307 |
✗✓✗✗ |
29 |
input_props & output_props || |
2308 |
// Map dvb teletext which has neither property to any output subtitle encoder |
||
2309 |
input_descriptor && output_descriptor && |
||
2310 |
(!input_descriptor->props || |
||
2311 |
!output_descriptor->props)) { |
||
2312 |
38 |
new_subtitle_stream(o, oc, i); |
|
2313 |
38 |
break; |
|
2314 |
} |
||
2315 |
} |
||
2316 |
} |
||
2317 |
/* Data only if codec id match */ |
||
2318 |
✓✗ | 5940 |
if (!o->data_disable ) { |
2319 |
5940 |
enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA); |
|
2320 |
✗✓✗✗ |
5940 |
for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) { |
2321 |
if (input_streams[i]->user_set_discard == AVDISCARD_ALL) |
||
2322 |
continue; |
||
2323 |
if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA |
||
2324 |
&& input_streams[i]->st->codecpar->codec_id == codec_id ) |
||
2325 |
new_data_stream(o, oc, i); |
||
2326 |
} |
||
2327 |
} |
||
2328 |
} else { |
||
2329 |
✓✓ | 208 |
for (i = 0; i < o->nb_stream_maps; i++) { |
2330 |
137 |
StreamMap *map = &o->stream_maps[i]; |
|
2331 |
|||
2332 |
✗✓ | 137 |
if (map->disabled) |
2333 |
continue; |
||
2334 |
|||
2335 |
✓✓ | 137 |
if (map->linklabel) { |
2336 |
FilterGraph *fg; |
||
2337 |
3 |
OutputFilter *ofilter = NULL; |
|
2338 |
int j, k; |
||
2339 |
|||
2340 |
✓✗ | 3 |
for (j = 0; j < nb_filtergraphs; j++) { |
2341 |
3 |
fg = filtergraphs[j]; |
|
2342 |
✓✗ | 3 |
for (k = 0; k < fg->nb_outputs; k++) { |
2343 |
3 |
AVFilterInOut *out = fg->outputs[k]->out_tmp; |
|
2344 |
✓✗✓✗ |
3 |
if (out && !strcmp(out->name, map->linklabel)) { |
2345 |
3 |
ofilter = fg->outputs[k]; |
|
2346 |
3 |
goto loop_end; |
|
2347 |
} |
||
2348 |
} |
||
2349 |
} |
||
2350 |
loop_end: |
||
2351 |
✗✓ | 3 |
if (!ofilter) { |
2352 |
av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist " |
||
2353 |
"in any defined filter graph, or was already used elsewhere.\n", map->linklabel); |
||
2354 |
exit_program(1); |
||
2355 |
} |
||
2356 |
3 |
init_output_filter(ofilter, o, oc); |
|
2357 |
} else { |
||
2358 |
134 |
int src_idx = input_files[map->file_index]->ist_index + map->stream_index; |
|
2359 |
|||
2360 |
134 |
ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index]; |
|
2361 |
✗✓ | 134 |
if (ist->user_set_discard == AVDISCARD_ALL) { |
2362 |
av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n", |
||
2363 |
map->file_index, map->stream_index); |
||
2364 |
exit_program(1); |
||
2365 |
} |
||
2366 |
✗✓✗✗ |
134 |
if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) |
2367 |
continue; |
||
2368 |
✗✓✗✗ |
134 |
if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) |
2369 |
continue; |
||
2370 |
✓✓✗✓ |
134 |
if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) |
2371 |
continue; |
||
2372 |
✗✓✗✗ |
134 |
if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA) |
2373 |
continue; |
||
2374 |
|||
2375 |
134 |
ost = NULL; |
|
2376 |
✓✓✓✓ ✗✗✗ |
134 |
switch (ist->st->codecpar->codec_type) { |
2377 |
53 |
case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break; |
|
2378 |
62 |
case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break; |
|
2379 |
9 |
case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break; |
|
2380 |
10 |
case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break; |
|
2381 |
case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break; |
||
2382 |
case AVMEDIA_TYPE_UNKNOWN: |
||
2383 |
if (copy_unknown_streams) { |
||
2384 |
ost = new_unknown_stream (o, oc, src_idx); |
||
2385 |
break; |
||
2386 |
} |
||
2387 |
default: |
||
2388 |
av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL, |
||
2389 |
"Cannot map stream #%d:%d - unsupported type.\n", |
||
2390 |
map->file_index, map->stream_index); |
||
2391 |
if (!ignore_unknown_streams) { |
||
2392 |
av_log(NULL, AV_LOG_FATAL, |
||
2393 |
"If you want unsupported types ignored instead " |
||
2394 |
"of failing, please use the -ignore_unknown option\n" |
||
2395 |
"If you want them copied, please use -copy_unknown\n"); |
||
2396 |
exit_program(1); |
||
2397 |
} |
||
2398 |
} |
||
2399 |
✓✗ | 134 |
if (ost) |
2400 |
134 |
ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index |
|
2401 |
134 |
+ map->sync_stream_index]; |
|
2402 |
} |
||
2403 |
} |
||
2404 |
} |
||
2405 |
|||
2406 |
/* handle attached files */ |
||
2407 |
✓✓ | 6012 |
for (i = 0; i < o->nb_attachments; i++) { |
2408 |
AVIOContext *pb; |
||
2409 |
uint8_t *attachment; |
||
2410 |
const char *p; |
||
2411 |
int64_t len; |
||
2412 |
|||
2413 |
✗✓ | 1 |
if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) { |
2414 |
av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n", |
||
2415 |
o->attachments[i]); |
||
2416 |
exit_program(1); |
||
2417 |
} |
||
2418 |
✗✓ | 1 |
if ((len = avio_size(pb)) <= 0) { |
2419 |
av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n", |
||
2420 |
o->attachments[i]); |
||
2421 |
exit_program(1); |
||
2422 |
} |
||
2423 |
✓✗✗✓ |
2 |
if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE || |
2424 |
1 |
!(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) { |
|
2425 |
av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n", |
||
2426 |
o->attachments[i]); |
||
2427 |
exit_program(1); |
||
2428 |
} |
||
2429 |
1 |
avio_read(pb, attachment, len); |
|
2430 |
1 |
memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE); |
|
2431 |
|||
2432 |
1 |
ost = new_attachment_stream(o, oc, -1); |
|
2433 |
1 |
ost->stream_copy = 0; |
|
2434 |
1 |
ost->attachment_filename = o->attachments[i]; |
|
2435 |
1 |
ost->st->codecpar->extradata = attachment; |
|
2436 |
1 |
ost->st->codecpar->extradata_size = len; |
|
2437 |
|||
2438 |
1 |
p = strrchr(o->attachments[i], '/'); |
|
2439 |
✓✗✓✗ |
1 |
av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE); |
2440 |
1 |
avio_closep(&pb); |
|
2441 |
} |
||
2442 |
|||
2443 |
#if FF_API_LAVF_AVCTX |
||
2444 |
✓✓ | 12204 |
for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file |
2445 |
AVDictionaryEntry *e; |
||
2446 |
6193 |
ost = output_streams[i]; |
|
2447 |
|||
2448 |
✓✓✓✓ |
6193 |
if ((ost->stream_copy || ost->attachment_filename) |
2449 |
✓✓ | 347 |
&& (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX)) |
2450 |
✗✓✗✗ |
116 |
&& (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6))) |
2451 |
✗✓ | 116 |
if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0) |
2452 |
exit_program(1); |
||
2453 |
} |
||
2454 |
#endif |
||
2455 |
|||
2456 |
✓✓✗✓ |
6011 |
if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) { |
2457 |
av_dump_format(oc, nb_output_files - 1, oc->url, 1); |
||
2458 |
av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1); |
||
2459 |
exit_program(1); |
||
2460 |
} |
||
2461 |
|||
2462 |
/* check if all codec options have been used */ |
||
2463 |
6011 |
unused_opts = strip_specifiers(o->g->codec_opts); |
|
2464 |
✓✓ | 12204 |
for (i = of->ost_index; i < nb_output_streams; i++) { |
2465 |
6193 |
e = NULL; |
|
2466 |
✓✓ | 20455 |
while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e, |
2467 |
AV_DICT_IGNORE_SUFFIX))) |
||
2468 |
14262 |
av_dict_set(&unused_opts, e->key, NULL, 0); |
|
2469 |
} |
||
2470 |
|||
2471 |
6011 |
e = NULL; |
|
2472 |
✓✓ | 6281 |
while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) { |
2473 |
270 |
const AVClass *class = avcodec_get_class(); |
|
2474 |
270 |
const AVOption *option = av_opt_find(&class, e->key, NULL, 0, |
|
2475 |
AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ); |
||
2476 |
270 |
const AVClass *fclass = avformat_get_class(); |
|
2477 |
270 |
const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0, |
|
2478 |
AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ); |
||
2479 |
✓✓✗✓ |
270 |
if (!option || foption) |
2480 |
9 |
continue; |
|
2481 |
|||
2482 |
|||
2483 |
✗✓ | 269 |
if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) { |
2484 |
av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for " |
||
2485 |
"output file #%d (%s) is not an encoding option.\n", e->key, |
||
2486 |
option->help ? option->help : "", nb_output_files - 1, |
||
2487 |
filename); |
||
2488 |
exit_program(1); |
||
2489 |
} |
||
2490 |
|||
2491 |
// gop_timecode is injected by generic code but not always used |
||
2492 |
✓✓ | 269 |
if (!strcmp(e->key, "gop_timecode")) |
2493 |
8 |
continue; |
|
2494 |
|||
2495 |
261 |
av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for " |
|
2496 |
"output file #%d (%s) has not been used for any stream. The most " |
||
2497 |
"likely reason is either wrong type (e.g. a video option with " |
||
2498 |
"no video streams) or that it is a private option of some encoder " |
||
2499 |
"which was not actually used for any stream.\n", e->key, |
||
2500 |
✓✗ | 261 |
option->help ? option->help : "", nb_output_files - 1, filename); |
2501 |
} |
||
2502 |
6011 |
av_dict_free(&unused_opts); |
|
2503 |
|||
2504 |
/* set the decoding_needed flags and create simple filtergraphs */ |
||
2505 |
✓✓ | 12204 |
for (i = of->ost_index; i < nb_output_streams; i++) { |
2506 |
6193 |
OutputStream *ost = output_streams[i]; |
|
2507 |
|||
2508 |
✓✓✓✓ |
6193 |
if (ost->encoding_needed && ost->source_index >= 0) { |
2509 |
5763 |
InputStream *ist = input_streams[ost->source_index]; |
|
2510 |
5763 |
ist->decoding_needed |= DECODING_FOR_OST; |
|
2511 |
|||
2512 |
✓✓ | 5763 |
if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO || |
2513 |
✓✓ | 1145 |
ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) { |
2514 |
5731 |
err = init_simple_filtergraph(ist, ost); |
|
2515 |
✗✓ | 5731 |
if (err < 0) { |
2516 |
av_log(NULL, AV_LOG_ERROR, |
||
2517 |
"Error initializing a simple filtergraph between streams " |
||
2518 |
"%d:%d->%d:%d\n", ist->file_index, ost->source_index, |
||
2519 |
nb_output_files - 1, ost->st->index); |
||
2520 |
exit_program(1); |
||
2521 |
} |
||
2522 |
} |
||
2523 |
} |
||
2524 |
|||
2525 |
/* set the filter output constraints */ |
||
2526 |
✓✓ | 6193 |
if (ost->filter) { |
2527 |
5814 |
OutputFilter *f = ost->filter; |
|
2528 |
int count; |
||
2529 |
✓✓✗ | 5814 |
switch (ost->enc_ctx->codec_type) { |
2530 |
4686 |
case AVMEDIA_TYPE_VIDEO: |
|
2531 |
4686 |
f->frame_rate = ost->frame_rate; |
|
2532 |
4686 |
f->width = ost->enc_ctx->width; |
|
2533 |
4686 |
f->height = ost->enc_ctx->height; |
|
2534 |
✓✓ | 4686 |
if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) { |
2535 |
3365 |
f->format = ost->enc_ctx->pix_fmt; |
|
2536 |
✓✓ | 1321 |
} else if (ost->enc->pix_fmts) { |
2537 |
297 |
count = 0; |
|
2538 |
✓✓ | 1593 |
while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE) |
2539 |
1296 |
count++; |
|
2540 |
297 |
f->formats = av_mallocz_array(count + 1, sizeof(*f->formats)); |
|
2541 |
✗✓ | 297 |
if (!f->formats) |
2542 |
exit_program(1); |
||
2543 |
297 |
memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats)); |
|
2544 |
} |
||
2545 |
4686 |
break; |
|
2546 |
1128 |
case AVMEDIA_TYPE_AUDIO: |
|
2547 |
✗✓ | 1128 |
if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) { |
2548 |
f->format = ost->enc_ctx->sample_fmt; |
||
2549 |
✓✗ | 1128 |
} else if (ost->enc->sample_fmts) { |
2550 |
1128 |
count = 0; |
|
2551 |
✓✓ | 2293 |
while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE) |
2552 |
1165 |
count++; |
|
2553 |
1128 |
f->formats = av_mallocz_array(count + 1, sizeof(*f->formats)); |
|
2554 |
✗✓ | 1128 |
if (!f->formats) |
2555 |
exit_program(1); |
||
2556 |
1128 |
memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats)); |
|
2557 |
} |
||
2558 |
✓✓ | 1128 |
if (ost->enc_ctx->sample_rate) { |
2559 |
25 |
f->sample_rate = ost->enc_ctx->sample_rate; |
|
2560 |
✓✓ | 1103 |
} else if (ost->enc->supported_samplerates) { |
2561 |
35 |
count = 0; |
|
2562 |
✓✓ | 305 |
while (ost->enc->supported_samplerates[count]) |
2563 |
270 |
count++; |
|
2564 |
35 |
f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates)); |
|
2565 |
✗✓ | 35 |
if (!f->sample_rates) |
2566 |
exit_program(1); |
||
2567 |
35 |
memcpy(f->sample_rates, ost->enc->supported_samplerates, |
|
2568 |
35 |
(count + 1) * sizeof(*f->sample_rates)); |
|
2569 |
} |
||
2570 |
✓✓ | 1128 |
if (ost->enc_ctx->channels) { |
2571 |
12 |
f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels); |
|
2572 |
✓✓ | 1116 |
} else if (ost->enc->channel_layouts) { |
2573 |
42 |
count = 0; |
|
2574 |
✓✓ | 280 |
while (ost->enc->channel_layouts[count]) |
2575 |
238 |
count++; |
|
2576 |
42 |
f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts)); |
|
2577 |
✗✓ | 42 |
if (!f->channel_layouts) |
2578 |
exit_program(1); |
||
2579 |
42 |
memcpy(f->channel_layouts, ost->enc->channel_layouts, |
|
2580 |
42 |
(count + 1) * sizeof(*f->channel_layouts)); |
|
2581 |
} |
||
2582 |
1128 |
break; |
|
2583 |
} |
||
2584 |
6193 |
} |
|
2585 |
} |
||
2586 |
|||
2587 |
/* check filename in case of an image number is expected */ |
||
2588 |
✗✓ | 6011 |
if (oc->oformat->flags & AVFMT_NEEDNUMBER) { |
2589 |
if (!av_filename_number_test(oc->url)) { |
||
2590 |
print_error(oc->url, AVERROR(EINVAL)); |
||
2591 |
exit_program(1); |
||
2592 |
} |
||
2593 |
} |
||
2594 |
|||
2595 |
✓✓✗✓ |
6011 |
if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) { |
2596 |
av_log(NULL, AV_LOG_ERROR, |
||
2597 |
"No input streams but output needs an input stream\n"); |
||
2598 |
exit_program(1); |
||
2599 |
} |
||
2600 |
|||
2601 |
✓✓ | 6011 |
if (!(oc->oformat->flags & AVFMT_NOFILE)) { |
2602 |
/* test if it already exists to avoid losing precious files */ |
||
2603 |
5957 |
assert_file_overwrite(filename); |
|
2604 |
|||
2605 |
/* open the file */ |
||
2606 |
✗✓ | 5957 |
if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE, |
2607 |
5957 |
&oc->interrupt_callback, |
|
2608 |
&of->opts)) < 0) { |
||
2609 |
print_error(filename, err); |
||
2610 |
exit_program(1); |
||
2611 |
} |
||
2612 |
✓✓✗✓ |
54 |
} else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename)) |
2613 |
assert_file_overwrite(filename); |
||
2614 |
|||
2615 |
✗✓ | 6011 |
if (o->mux_preload) { |
2616 |
av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0); |
||
2617 |
} |
||
2618 |
6011 |
oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE); |
|
2619 |
|||
2620 |
/* copy metadata */ |
||
2621 |
✓✓ | 6016 |
for (i = 0; i < o->nb_metadata_map; i++) { |
2622 |
char *p; |
||
2623 |
5 |
int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0); |
|
2624 |
|||
2625 |
✗✓ | 5 |
if (in_file_index >= nb_input_files) { |
2626 |
av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index); |
||
2627 |
exit_program(1); |
||
2628 |
} |
||
2629 |
✓✓✓✓ |
8 |
copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, |
2630 |
in_file_index >= 0 ? |
||
2631 |
3 |
input_files[in_file_index]->ctx : NULL, o); |
|
2632 |
} |
||
2633 |
|||
2634 |
/* copy chapters */ |
||
2635 |
✓✗ | 6011 |
if (o->chapters_input_file >= nb_input_files) { |
2636 |
✓✗ | 6011 |
if (o->chapters_input_file == INT_MAX) { |
2637 |
/* copy chapters from the first input file that has them*/ |
||
2638 |
6011 |
o->chapters_input_file = -1; |
|
2639 |
✓✓ | 12035 |
for (i = 0; i < nb_input_files; i++) |
2640 |
✓✓ | 6039 |
if (input_files[i]->ctx->nb_chapters) { |
2641 |
15 |
o->chapters_input_file = i; |
|
2642 |
15 |
break; |
|
2643 |
} |
||
2644 |
} else { |
||
2645 |
av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n", |
||
2646 |
o->chapters_input_file); |
||
2647 |
exit_program(1); |
||
2648 |
} |
||
2649 |
} |
||
2650 |
✓✓ | 6011 |
if (o->chapters_input_file >= 0) |
2651 |
15 |
copy_chapters(input_files[o->chapters_input_file], of, |
|
2652 |
15 |
!o->metadata_chapters_manual); |
|
2653 |
|||
2654 |
/* copy global metadata by default */ |
||
2655 |
✓✓✓✓ |
6011 |
if (!o->metadata_global_manual && nb_input_files){ |
2656 |
5967 |
av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata, |
|
2657 |
AV_DICT_DONT_OVERWRITE); |
||
2658 |
✓✓ | 5967 |
if(o->recording_time != INT64_MAX) |
2659 |
131 |
av_dict_set(&oc->metadata, "duration", NULL, 0); |
|
2660 |
5967 |
av_dict_set(&oc->metadata, "creation_time", NULL, 0); |
|
2661 |
5967 |
av_dict_set(&oc->metadata, "company_name", NULL, 0); |
|
2662 |
5967 |
av_dict_set(&oc->metadata, "product_name", NULL, 0); |
|
2663 |
5967 |
av_dict_set(&oc->metadata, "product_version", NULL, 0); |
|
2664 |
} |
||
2665 |
✓✓ | 6011 |
if (!o->metadata_streams_manual) |
2666 |
✓✓ | 12200 |
for (i = of->ost_index; i < nb_output_streams; i++) { |
2667 |
InputStream *ist; |
||
2668 |
✓✓ | 6190 |
if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */ |
2669 |
84 |
continue; |
|
2670 |
6106 |
ist = input_streams[output_streams[i]->source_index]; |
|
2671 |
6106 |
av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE); |
|
2672 |
✓✓ | 6106 |
if (!output_streams[i]->stream_copy) { |
2673 |
5760 |
av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0); |
|
2674 |
} |
||
2675 |
} |
||
2676 |
|||
2677 |
/* process manually set programs */ |
||
2678 |
✗✓ | 6011 |
for (i = 0; i < o->nb_program; i++) { |
2679 |
const char *p = o->program[i].u.str; |
||
2680 |
int progid = i+1; |
||
2681 |
AVProgram *program; |
||
2682 |
|||
2683 |
while(*p) { |
||
2684 |
const char *p2 = av_get_token(&p, ":"); |
||
2685 |
const char *to_dealloc = p2; |
||
2686 |
char *key; |
||
2687 |
if (!p2) |
||
2688 |
break; |
||
2689 |
|||
2690 |
if(*p) p++; |
||
2691 |
|||
2692 |
key = av_get_token(&p2, "="); |
||
2693 |
if (!key || !*p2) { |
||
2694 |
av_freep(&to_dealloc); |
||
2695 |
av_freep(&key); |
||
2696 |
break; |
||
2697 |
} |
||
2698 |
p2++; |
||
2699 |
|||
2700 |
if (!strcmp(key, "program_num")) |
||
2701 |
progid = strtol(p2, NULL, 0); |
||
2702 |
av_freep(&to_dealloc); |
||
2703 |
av_freep(&key); |
||
2704 |
} |
||
2705 |
|||
2706 |
program = av_new_program(oc, progid); |
||
2707 |
|||
2708 |
p = o->program[i].u.str; |
||
2709 |
while(*p) { |
||
2710 |
const char *p2 = av_get_token(&p, ":"); |
||
2711 |
const char *to_dealloc = p2; |
||
2712 |
char *key; |
||
2713 |
if (!p2) |
||
2714 |
break; |
||
2715 |
if(*p) p++; |
||
2716 |
|||
2717 |
key = av_get_token(&p2, "="); |
||
2718 |
if (!key) { |
||
2719 |
av_log(NULL, AV_LOG_FATAL, |
||
2720 |
"No '=' character in program string %s.\n", |
||
2721 |
p2); |
||
2722 |
exit_program(1); |
||
2723 |
} |
||
2724 |
if (!*p2) |
||
2725 |
exit_program(1); |
||
2726 |
p2++; |
||
2727 |
|||
2728 |
if (!strcmp(key, "title")) { |
||
2729 |
av_dict_set(&program->metadata, "title", p2, 0); |
||
2730 |
} else if (!strcmp(key, "program_num")) { |
||
2731 |
} else if (!strcmp(key, "st")) { |
||
2732 |
int st_num = strtol(p2, NULL, 0); |
||
2733 |
av_program_add_stream_index(oc, progid, st_num); |
||
2734 |
} else { |
||
2735 |
av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key); |
||
2736 |
exit_program(1); |
||
2737 |
} |
||
2738 |
av_freep(&to_dealloc); |
||
2739 |
av_freep(&key); |
||
2740 |
} |
||
2741 |
} |
||
2742 |
|||
2743 |
/* process manually set metadata */ |
||
2744 |
✓✓ | 6172 |
for (i = 0; i < o->nb_metadata; i++) { |
2745 |
AVDictionary **m; |
||
2746 |
char type, *val; |
||
2747 |
const char *stream_spec; |
||
2748 |
161 |
int index = 0, j, ret = 0; |
|
2749 |
|||
2750 |
161 |
val = strchr(o->metadata[i].u.str, '='); |
|
2751 |
✗✓ | 161 |
if (!val) { |
2752 |
av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n", |
||
2753 |
o->metadata[i].u.str); |
||
2754 |
exit_program(1); |
||
2755 |
} |
||
2756 |
161 |
*val++ = 0; |
|
2757 |
|||
2758 |
161 |
parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec); |
|
2759 |
✓✓ | 161 |
if (type == 's') { |
2760 |
✓✓ | 76 |
for (j = 0; j < oc->nb_streams; j++) { |
2761 |
58 |
ost = output_streams[nb_output_streams - oc->nb_streams + j]; |
|
2762 |
✓✓ | 58 |
if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) { |
2763 |
✓✓ | 18 |
if (!strcmp(o->metadata[i].u.str, "rotate")) { |
2764 |
char *tail; |
||
2765 |
1 |
double theta = av_strtod(val, &tail); |
|
2766 |
✓✗ | 1 |
if (!*tail) { |
2767 |
1 |
ost->rotate_overridden = 1; |
|
2768 |
1 |
ost->rotate_override_value = theta; |
|
2769 |
} |
||
2770 |
} else { |
||
2771 |
✓✗ | 17 |
av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0); |
2772 |
} |
||
2773 |
✗✓ | 40 |
} else if (ret < 0) |
2774 |
exit_program(1); |
||
2775 |
} |
||
2776 |
} |
||
2777 |
else { |
||
2778 |
✓✓✗✗ |
143 |
switch (type) { |
2779 |
139 |
case 'g': |
|
2780 |
139 |
m = &oc->metadata; |
|
2781 |
139 |
break; |
|
2782 |
4 |
case 'c': |
|
2783 |
✓✗✗✓ |
4 |
if (index < 0 || index >= oc->nb_chapters) { |
2784 |
av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index); |
||
2785 |
exit_program(1); |
||
2786 |
} |
||
2787 |
4 |
m = &oc->chapters[index]->metadata; |
|
2788 |
4 |
break; |
|
2789 |
case 'p': |
||
2790 |
if (index < 0 || index >= oc->nb_programs) { |
||
2791 |
av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index); |
||
2792 |
exit_program(1); |
||
2793 |
} |
||
2794 |
m = &oc->programs[index]->metadata; |
||
2795 |
break; |
||
2796 |
default: |
||
2797 |
av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier); |
||
2798 |
exit_program(1); |
||
2799 |
} |
||
2800 |
✓✗ | 143 |
av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0); |
2801 |
} |
||
2802 |
} |
||
2803 |
|||
2804 |
6011 |
return 0; |
|
2805 |
} |
||
2806 |
|||
2807 |
static int opt_target(void *optctx, const char *opt, const char *arg) |
||
2808 |
{ |
||
2809 |
OptionsContext *o = optctx; |
||
2810 |
enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN; |
||
2811 |
static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" }; |
||
2812 |
|||
2813 |
if (!strncmp(arg, "pal-", 4)) { |
||
2814 |
norm = PAL; |
||
2815 |
arg += 4; |
||
2816 |
} else if (!strncmp(arg, "ntsc-", 5)) { |
||
2817 |
norm = NTSC; |
||
2818 |
arg += 5; |
||
2819 |
} else if (!strncmp(arg, "film-", 5)) { |
||
2820 |
norm = FILM; |
||
2821 |
arg += 5; |
||
2822 |
} else { |
||
2823 |
/* Try to determine PAL/NTSC by peeking in the input files */ |
||
2824 |
if (nb_input_files) { |
||
2825 |
int i, j; |
||
2826 |
for (j = 0; j < nb_input_files; j++) { |
||
2827 |
for (i = 0; i < input_files[j]->nb_streams; i++) { |
||
2828 |
AVStream *st = input_files[j]->ctx->streams[i]; |
||
2829 |
int64_t fr; |
||
2830 |
if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) |
||
2831 |
continue; |
||
2832 |
fr = st->time_base.den * 1000LL / st->time_base.num; |
||
2833 |
if (fr == 25000) { |
||
2834 |
norm = PAL; |
||
2835 |
break; |
||
2836 |
} else if ((fr == 29970) || (fr == 23976)) { |
||
2837 |
norm = NTSC; |
||
2838 |
break; |
||
2839 |
} |
||
2840 |
} |
||
2841 |
if (norm != UNKNOWN) |
||
2842 |
break; |
||
2843 |
} |
||
2844 |
} |
||
2845 |
if (norm != UNKNOWN) |
||
2846 |
av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC"); |
||
2847 |
} |
||
2848 |
|||
2849 |
if (norm == UNKNOWN) { |
||
2850 |
av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n"); |
||
2851 |
av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n"); |
||
2852 |
av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n"); |
||
2853 |
exit_program(1); |
||
2854 |
} |
||
2855 |
|||
2856 |
if (!strcmp(arg, "vcd")) { |
||
2857 |
opt_video_codec(o, "c:v", "mpeg1video"); |
||
2858 |
opt_audio_codec(o, "c:a", "mp2"); |
||
2859 |
parse_option(o, "f", "vcd", options); |
||
2860 |
|||
2861 |
parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options); |
||
2862 |
parse_option(o, "r", frame_rates[norm], options); |
||
2863 |
opt_default(NULL, "g", norm == PAL ? "15" : "18"); |
||
2864 |
|||
2865 |
opt_default(NULL, "b:v", "1150000"); |
||
2866 |
opt_default(NULL, "maxrate:v", "1150000"); |
||
2867 |
opt_default(NULL, "minrate:v", "1150000"); |
||
2868 |
opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8; |
||
2869 |
|||
2870 |
opt_default(NULL, "b:a", "224000"); |
||
2871 |
parse_option(o, "ar", "44100", options); |
||
2872 |
parse_option(o, "ac", "2", options); |
||
2873 |
|||
2874 |
opt_default(NULL, "packetsize", "2324"); |
||
2875 |
opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8; |
||
2876 |
|||
2877 |
/* We have to offset the PTS, so that it is consistent with the SCR. |
||
2878 |
SCR starts at 36000, but the first two packs contain only padding |
||
2879 |
and the first pack from the other stream, respectively, may also have |
||
2880 |
been written before. |
||
2881 |
So the real data starts at SCR 36000+3*1200. */ |
||
2882 |
o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44 |
||
2883 |
} else if (!strcmp(arg, "svcd")) { |
||
2884 |
|||
2885 |
opt_video_codec(o, "c:v", "mpeg2video"); |
||
2886 |
opt_audio_codec(o, "c:a", "mp2"); |
||
2887 |
parse_option(o, "f", "svcd", options); |
||
2888 |
|||
2889 |
parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options); |
||
2890 |
parse_option(o, "r", frame_rates[norm], options); |
||
2891 |
parse_option(o, "pix_fmt", "yuv420p", options); |
||
2892 |
opt_default(NULL, "g", norm == PAL ? "15" : "18"); |
||
2893 |
|||
2894 |
opt_default(NULL, "b:v", "2040000"); |
||
2895 |
opt_default(NULL, "maxrate:v", "2516000"); |
||
2896 |
opt_default(NULL, "minrate:v", "0"); // 1145000; |
||
2897 |
opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8; |
||
2898 |
opt_default(NULL, "scan_offset", "1"); |
||
2899 |
|||
2900 |
opt_default(NULL, "b:a", "224000"); |
||
2901 |
parse_option(o, "ar", "44100", options); |
||
2902 |
|||
2903 |
opt_default(NULL, "packetsize", "2324"); |
||
2904 |
|||
2905 |
} else if (!strcmp(arg, "dvd")) { |
||
2906 |
|||
2907 |
opt_video_codec(o, "c:v", "mpeg2video"); |
||
2908 |
opt_audio_codec(o, "c:a", "ac3"); |
||
2909 |
parse_option(o, "f", "dvd", options); |
||
2910 |
|||
2911 |
parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options); |
||
2912 |
parse_option(o, "r", frame_rates[norm], options); |
||
2913 |
parse_option(o, "pix_fmt", "yuv420p", options); |
||
2914 |
opt_default(NULL, "g", norm == PAL ? "15" : "18"); |
||
2915 |
|||
2916 |
opt_default(NULL, "b:v", "6000000"); |
||
2917 |
opt_default(NULL, "maxrate:v", "9000000"); |
||
2918 |
opt_default(NULL, "minrate:v", "0"); // 1500000; |
||
2919 |
opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8; |
||
2920 |
|||
2921 |
opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack. |
||
2922 |
opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8 |
||
2923 |
|||
2924 |
opt_default(NULL, "b:a", "448000"); |
||
2925 |
parse_option(o, "ar", "48000", options); |
||
2926 |
|||
2927 |
} else if (!strncmp(arg, "dv", 2)) { |
||
2928 |
|||
2929 |
parse_option(o, "f", "dv", options); |
||
2930 |
|||
2931 |
parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options); |
||
2932 |
parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" : |
||
2933 |
norm == PAL ? "yuv420p" : "yuv411p", options); |
||
2934 |
parse_option(o, "r", frame_rates[norm], options); |
||
2935 |
|||
2936 |
parse_option(o, "ar", "48000", options); |
||
2937 |
parse_option(o, "ac", "2", options); |
||
2938 |
|||
2939 |
} else { |
||
2940 |
av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg); |
||
2941 |
return AVERROR(EINVAL); |
||
2942 |
} |
||
2943 |
|||
2944 |
av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE); |
||
2945 |
av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE); |
||
2946 |
|||
2947 |
return 0; |
||
2948 |
} |
||
2949 |
|||
2950 |
static int opt_vstats_file(void *optctx, const char *opt, const char *arg) |
||
2951 |
{ |
||
2952 |
av_free (vstats_filename); |
||
2953 |
vstats_filename = av_strdup (arg); |
||
2954 |
return 0; |
||
2955 |
} |
||
2956 |
|||
2957 |
static int opt_vstats(void *optctx, const char *opt, const char *arg) |
||
2958 |
{ |
||
2959 |
char filename[40]; |
||
2960 |
time_t today2 = time(NULL); |
||
2961 |
struct tm *today = localtime(&today2); |
||
2962 |
|||
2963 |
if (!today) { // maybe tomorrow |
||
2964 |
av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno)); |
||
2965 |
exit_program(1); |
||
2966 |
} |
||
2967 |
|||
2968 |
snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min, |
||
2969 |
today->tm_sec); |
||
2970 |
return opt_vstats_file(NULL, opt, filename); |
||
2971 |
} |
||
2972 |
|||
2973 |
static int opt_video_frames(void *optctx, const char *opt, const char *arg) |
||
2974 |
{ |
||
2975 |
OptionsContext *o = optctx; |
||
2976 |
return parse_option(o, "frames:v", arg, options); |
||
2977 |
} |
||
2978 |
|||
2979 |
static int opt_audio_frames(void *optctx, const char *opt, const char *arg) |
||
2980 |
{ |
||
2981 |
OptionsContext *o = optctx; |
||
2982 |
return parse_option(o, "frames:a", arg, options); |
||
2983 |
} |
||
2984 |
|||
2985 |
static int opt_data_frames(void *optctx, const char *opt, const char *arg) |
||
2986 |
{ |
||
2987 |
OptionsContext *o = optctx; |
||
2988 |
return parse_option(o, "frames:d", arg, options); |
||
2989 |
} |
||
2990 |
|||
2991 |
2 |
static int opt_default_new(OptionsContext *o, const char *opt, const char *arg) |
|
2992 |
{ |
||
2993 |
int ret; |
||
2994 |
2 |
AVDictionary *cbak = codec_opts; |
|
2995 |
2 |
AVDictionary *fbak = format_opts; |
|
2996 |
2 |
codec_opts = NULL; |
|
2997 |
2 |
format_opts = NULL; |
|
2998 |
|||
2999 |
2 |
ret = opt_default(NULL, opt, arg); |
|
3000 |
|||
3001 |
2 |
av_dict_copy(&o->g->codec_opts , codec_opts, 0); |
|
3002 |
2 |
av_dict_copy(&o->g->format_opts, format_opts, 0); |
|
3003 |
2 |
av_dict_free(&codec_opts); |
|
3004 |
2 |
av_dict_free(&format_opts); |
|
3005 |
2 |
codec_opts = cbak; |
|
3006 |
2 |
format_opts = fbak; |
|
3007 |
|||
3008 |
2 |
return ret; |
|
3009 |
} |
||
3010 |
|||
3011 |
static int opt_preset(void *optctx, const char *opt, const char *arg) |
||
3012 |
{ |
||
3013 |
OptionsContext *o = optctx; |
||
3014 |
FILE *f=NULL; |
||
3015 |
char filename[1000], line[1000], tmp_line[1000]; |
||
3016 |
const char *codec_name = NULL; |
||
3017 |
|||
3018 |
tmp_line[0] = *opt; |
||
3019 |
tmp_line[1] = 0; |
||
3020 |
MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line); |
||
3021 |
|||
3022 |
if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) { |
||
3023 |
if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){ |
||
3024 |
av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n"); |
||
3025 |
}else |
||
3026 |
av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg); |
||
3027 |
exit_program(1); |
||
3028 |
} |
||
3029 |
|||
3030 |
while (fgets(line, sizeof(line), f)) { |
||
3031 |
char *key = tmp_line, *value, *endptr; |
||
3032 |
|||
3033 |
if (strcspn(line, "#\n\r") == 0) |
||
3034 |
continue; |
||
3035 |
av_strlcpy(tmp_line, line, sizeof(tmp_line)); |
||
3036 |
if (!av_strtok(key, "=", &value) || |
||
3037 |
!av_strtok(value, "\r\n", &endptr)) { |
||
3038 |
av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line); |
||
3039 |
exit_program(1); |
||
3040 |
} |
||
3041 |
av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value); |
||
3042 |
|||
3043 |
if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value); |
||
3044 |
else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value); |
||
3045 |
else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value); |
||
3046 |
else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value); |
||
3047 |
else if (opt_default_new(o, key, value) < 0) { |
||
3048 |
av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", |
||
3049 |
filename, line, key, value); |
||
3050 |
exit_program(1); |
||
3051 |
} |
||
3052 |
} |
||
3053 |
|||
3054 |
fclose(f); |
||
3055 |
|||
3056 |
return 0; |
||
3057 |
} |
||
3058 |
|||
3059 |
3 |
static int opt_old2new(void *optctx, const char *opt, const char *arg) |
|
3060 |
{ |
||
3061 |
3 |
OptionsContext *o = optctx; |
|
3062 |
int ret; |
||
3063 |
3 |
char *s = av_asprintf("%s:%c", opt + 1, *opt); |
|
3064 |
✗✓ | 3 |
if (!s) |
3065 |
return AVERROR(ENOMEM); |
||
3066 |
3 |
ret = parse_option(o, s, arg, options); |
|
3067 |
3 |
av_free(s); |
|
3068 |
3 |
return ret; |
|
3069 |
} |
||
3070 |
|||
3071 |
159 |
static int opt_bitrate(void *optctx, const char *opt, const char *arg) |
|
3072 |
{ |
||
3073 |
159 |
OptionsContext *o = optctx; |
|
3074 |
|||
3075 |
✓✓ | 159 |
if(!strcmp(opt, "ab")){ |
3076 |
1 |
av_dict_set(&o->g->codec_opts, "b:a", arg, 0); |
|
3077 |
1 |
return 0; |
|
3078 |
✓✓ | 158 |
} else if(!strcmp(opt, "b")){ |
3079 |
39 |
av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n"); |
|
3080 |
39 |
av_dict_set(&o->g->codec_opts, "b:v", arg, 0); |
|
3081 |
39 |
return 0; |
|
3082 |
} |
||
3083 |
119 |
av_dict_set(&o->g->codec_opts, opt, arg, 0); |
|
3084 |
119 |
return 0; |
|
3085 |
} |
||
3086 |
|||
3087 |
254 |
static int opt_qscale(void *optctx, const char *opt, const char *arg) |
|
3088 |
{ |
||
3089 |
254 |
OptionsContext *o = optctx; |
|
3090 |
char *s; |
||
3091 |
int ret; |
||
3092 |
✓✓ | 254 |
if(!strcmp(opt, "qscale")){ |
3093 |
215 |
av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n"); |
|
3094 |
215 |
return parse_option(o, "q:v", arg, options); |
|
3095 |
} |
||
3096 |
39 |
s = av_asprintf("q%s", opt + 6); |
|
3097 |
✗✓ | 39 |
if (!s) |
3098 |
return AVERROR(ENOMEM); |
||
3099 |
39 |
ret = parse_option(o, s, arg, options); |
|
3100 |
39 |
av_free(s); |
|
3101 |
39 |
return ret; |
|
3102 |
} |
||
3103 |
|||
3104 |
45 |
static int opt_profile(void *optctx, const char *opt, const char *arg) |
|
3105 |
{ |
||
3106 |
45 |
OptionsContext *o = optctx; |
|
3107 |
✓✓ | 45 |
if(!strcmp(opt, "profile")){ |
3108 |
4 |
av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n"); |
|
3109 |
4 |
av_dict_set(&o->g->codec_opts, "profile:v", arg, 0); |
|
3110 |
4 |
return 0; |
|
3111 |
} |
||
3112 |
41 |
av_dict_set(&o->g->codec_opts, opt, arg, 0); |
|
3113 |
41 |
return 0; |
|
3114 |
} |
||
3115 |
|||
3116 |
2538 |
static int opt_video_filters(void *optctx, const char *opt, const char *arg) |
|
3117 |
{ |
||
3118 |
2538 |
OptionsContext *o = optctx; |
|
3119 |
2538 |
return parse_option(o, "filter:v", arg, options); |
|
3120 |
} |
||
3121 |
|||
3122 |
543 |
static int opt_audio_filters(void *optctx, const char *opt, const char *arg) |
|
3123 |
{ |
||
3124 |
543 |
OptionsContext *o = optctx; |
|
3125 |
543 |
return parse_option(o, "filter:a", arg, options); |
|
3126 |
} |
||
3127 |
|||
3128 |
483 |
static int opt_vsync(void *optctx, const char *opt, const char *arg) |
|
3129 |
{ |
||
3130 |
✓✓ | 483 |
if (!av_strcasecmp(arg, "cf |