1/* 2 * ffmpeg option parsing 3 * 4 * This file is part of FFmpeg. 5 * 6 * FFmpeg is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * FFmpeg is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with FFmpeg; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 21#include "config.h" 22 23#include <stdint.h> 24 25#if HAVE_SYS_RESOURCE_H 26#include <sys/time.h> 27#include <sys/resource.h> 28#endif 29 30#include "ffmpeg.h" 31#include "fopen_utf8.h" 32#include "cmdutils.h" 33#include "opt_common.h" 34 35#include "libavformat/avformat.h" 36 37#include "libavcodec/avcodec.h" 38#include "libavcodec/bsf.h" 39 40#include "libavfilter/avfilter.h" 41 42#include "libavutil/avassert.h" 43#include "libavutil/avstring.h" 44#include "libavutil/avutil.h" 45#include "libavutil/bprint.h" 46#include "libavutil/channel_layout.h" 47#include "libavutil/getenv_utf8.h" 48#include "libavutil/intreadwrite.h" 49#include "libavutil/fifo.h" 50#include "libavutil/mathematics.h" 51#include "libavutil/opt.h" 52#include "libavutil/parseutils.h" 53#include "libavutil/pixdesc.h" 54#include "libavutil/pixfmt.h" 55 56#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass" 57 58#define SPECIFIER_OPT_FMT_str "%s" 59#define SPECIFIER_OPT_FMT_i "%i" 60#define SPECIFIER_OPT_FMT_i64 "%"PRId64 61#define SPECIFIER_OPT_FMT_ui64 "%"PRIu64 62#define SPECIFIER_OPT_FMT_f "%f" 63#define SPECIFIER_OPT_FMT_dbl "%lf" 64 65static const char *const opt_name_codec_names[] = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL}; 66static const char *const opt_name_audio_channels[] = {"ac", NULL}; 67static const char *const opt_name_audio_ch_layouts[] = {"channel_layout", "ch_layout", NULL}; 68static const char *const opt_name_audio_sample_rate[] = {"ar", NULL}; 69static const char *const opt_name_frame_rates[] = {"r", NULL}; 70static const char *const opt_name_max_frame_rates[] = {"fpsmax", NULL}; 71static const char *const opt_name_frame_sizes[] = {"s", NULL}; 72static const char *const opt_name_frame_pix_fmts[] = {"pix_fmt", NULL}; 73static const char *const opt_name_ts_scale[] = {"itsscale", NULL}; 74static const char *const opt_name_hwaccels[] = {"hwaccel", NULL}; 75static const char *const opt_name_hwaccel_devices[] = {"hwaccel_device", NULL}; 76static const char *const opt_name_hwaccel_output_formats[] = {"hwaccel_output_format", NULL}; 77static const char *const opt_name_autorotate[] = {"autorotate", NULL}; 78static const char *const opt_name_autoscale[] = {"autoscale", NULL}; 79static const char *const opt_name_max_frames[] = {"frames", "aframes", "vframes", "dframes", NULL}; 80static const char *const opt_name_bitstream_filters[] = {"bsf", "absf", "vbsf", NULL}; 81static const char *const opt_name_codec_tags[] = {"tag", "atag", "vtag", "stag", NULL}; 82static const char *const opt_name_sample_fmts[] = {"sample_fmt", NULL}; 83static const char *const opt_name_qscale[] = {"q", "qscale", NULL}; 84static const char *const opt_name_forced_key_frames[] = {"forced_key_frames", NULL}; 85static const char *const opt_name_fps_mode[] = {"fps_mode", NULL}; 86static const char *const opt_name_force_fps[] = {"force_fps", NULL}; 87static const char *const opt_name_frame_aspect_ratios[] = {"aspect", NULL}; 88static const char *const opt_name_rc_overrides[] = {"rc_override", NULL}; 89static const char *const opt_name_intra_matrices[] = {"intra_matrix", NULL}; 90static const char *const opt_name_inter_matrices[] = {"inter_matrix", NULL}; 91static const char *const opt_name_chroma_intra_matrices[] = {"chroma_intra_matrix", NULL}; 92static const char *const opt_name_top_field_first[] = {"top", NULL}; 93static const char *const opt_name_presets[] = {"pre", "apre", "vpre", "spre", NULL}; 94static const char *const opt_name_copy_initial_nonkeyframes[] = {"copyinkf", NULL}; 95static const char *const opt_name_copy_prior_start[] = {"copypriorss", NULL}; 96static const char *const opt_name_filters[] = {"filter", "af", "vf", NULL}; 97static const char *const opt_name_filter_scripts[] = {"filter_script", NULL}; 98static const char *const opt_name_reinit_filters[] = {"reinit_filter", NULL}; 99static const char *const opt_name_fix_sub_duration[] = {"fix_sub_duration", NULL}; 100static const char *const opt_name_canvas_sizes[] = {"canvas_size", NULL}; 101static const char *const opt_name_pass[] = {"pass", NULL}; 102static const char *const opt_name_passlogfiles[] = {"passlogfile", NULL}; 103static const char *const opt_name_max_muxing_queue_size[] = {"max_muxing_queue_size", NULL}; 104static const char *const opt_name_muxing_queue_data_threshold[] = {"muxing_queue_data_threshold", NULL}; 105static const char *const opt_name_guess_layout_max[] = {"guess_layout_max", NULL}; 106static const char *const opt_name_apad[] = {"apad", NULL}; 107static const char *const opt_name_discard[] = {"discard", NULL}; 108static const char *const opt_name_disposition[] = {"disposition", NULL}; 109static const char *const opt_name_time_bases[] = {"time_base", NULL}; 110static const char *const opt_name_enc_time_bases[] = {"enc_time_base", NULL}; 111static const char *const opt_name_bits_per_raw_sample[] = {"bits_per_raw_sample", NULL}; 112 113#define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\ 114{\ 115 char namestr[128] = "";\ 116 const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\ 117 for (i = 0; opt_name_##name[i]; i++)\ 118 av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\ 119 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",\ 120 namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\ 121} 122 123#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\ 124{\ 125 int i, ret, matches = 0;\ 126 SpecifierOpt *so;\ 127 for (i = 0; i < o->nb_ ## name; i++) {\ 128 char *spec = o->name[i].specifier;\ 129 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\ 130 outvar = o->name[i].u.type;\ 131 so = &o->name[i];\ 132 matches++;\ 133 } else if (ret < 0)\ 134 exit_program(1);\ 135 }\ 136 if (matches > 1)\ 137 WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\ 138} 139 140#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\ 141{\ 142 int i;\ 143 for (i = 0; i < o->nb_ ## name; i++) {\ 144 char *spec = o->name[i].specifier;\ 145 if (!strcmp(spec, mediatype))\ 146 outvar = o->name[i].u.type;\ 147 }\ 148} 149 150HWDevice *filter_hw_device; 151 152char *vstats_filename; 153char *sdp_filename; 154 155float audio_drift_threshold = 0.1; 156float dts_delta_threshold = 10; 157float dts_error_threshold = 3600*30; 158 159int audio_volume = 256; 160int audio_sync_method = 0; 161enum VideoSyncMethod video_sync_method = VSYNC_AUTO; 162float frame_drop_threshold = 0; 163int do_benchmark = 0; 164int do_benchmark_all = 0; 165int do_hex_dump = 0; 166int do_pkt_dump = 0; 167int copy_ts = 0; 168int start_at_zero = 0; 169int copy_tb = -1; 170int debug_ts = 0; 171int exit_on_error = 0; 172int abort_on_flags = 0; 173int print_stats = -1; 174int qp_hist = 0; 175int stdin_interaction = 1; 176float max_error_rate = 2.0/3; 177char *filter_nbthreads; 178int filter_complex_nbthreads = 0; 179int vstats_version = 2; 180int auto_conversion_filters = 1; 181int64_t stats_period = 500000; 182 183 184static int file_overwrite = 0; 185static int no_file_overwrite = 0; 186static int do_psnr = 0; 187static int input_stream_potentially_available = 0; 188static int ignore_unknown_streams = 0; 189static int copy_unknown_streams = 0; 190static int recast_media = 0; 191static int find_stream_info = 1; 192 193static void uninit_options(OptionsContext *o) 194{ 195 const OptionDef *po = options; 196 int i; 197 198 /* all OPT_SPEC and OPT_STRING can be freed in generic way */ 199 while (po->name) { 200 void *dst = (uint8_t*)o + po->u.off; 201 202 if (po->flags & OPT_SPEC) { 203 SpecifierOpt **so = dst; 204 int i, *count = (int*)(so + 1); 205 for (i = 0; i < *count; i++) { 206 av_freep(&(*so)[i].specifier); 207 if (po->flags & OPT_STRING) 208 av_freep(&(*so)[i].u.str); 209 } 210 av_freep(so); 211 *count = 0; 212 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING) 213 av_freep(dst); 214 po++; 215 } 216 217 for (i = 0; i < o->nb_stream_maps; i++) 218 av_freep(&o->stream_maps[i].linklabel); 219 av_freep(&o->stream_maps); 220 av_freep(&o->audio_channel_maps); 221 av_freep(&o->streamid_map); 222 av_freep(&o->attachments); 223} 224 225static void init_options(OptionsContext *o) 226{ 227 memset(o, 0, sizeof(*o)); 228 229 o->stop_time = INT64_MAX; 230 o->mux_max_delay = 0.7; 231 o->start_time = AV_NOPTS_VALUE; 232 o->start_time_eof = AV_NOPTS_VALUE; 233 o->recording_time = INT64_MAX; 234 o->limit_filesize = UINT64_MAX; 235 o->chapters_input_file = INT_MAX; 236 o->accurate_seek = 1; 237 o->thread_queue_size = -1; 238 o->input_sync_ref = -1; 239} 240 241static int show_hwaccels(void *optctx, const char *opt, const char *arg) 242{ 243 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE; 244 245 printf("Hardware acceleration methods:\n"); 246 while ((type = av_hwdevice_iterate_types(type)) != 247 AV_HWDEVICE_TYPE_NONE) 248 printf("%s\n", av_hwdevice_get_type_name(type)); 249 printf("\n"); 250 return 0; 251} 252 253/* return a copy of the input with the stream specifiers removed from the keys */ 254static AVDictionary *strip_specifiers(AVDictionary *dict) 255{ 256 const AVDictionaryEntry *e = NULL; 257 AVDictionary *ret = NULL; 258 259 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) { 260 char *p = strchr(e->key, ':'); 261 262 if (p) 263 *p = 0; 264 av_dict_set(&ret, e->key, e->value, 0); 265 if (p) 266 *p = ':'; 267 } 268 return ret; 269} 270 271static int parse_and_set_vsync(const char *arg, int *vsync_var, int file_idx, int st_idx, int is_global) 272{ 273 if (!av_strcasecmp(arg, "cfr")) *vsync_var = VSYNC_CFR; 274 else if (!av_strcasecmp(arg, "vfr")) *vsync_var = VSYNC_VFR; 275 else if (!av_strcasecmp(arg, "passthrough")) *vsync_var = VSYNC_PASSTHROUGH; 276 else if (!av_strcasecmp(arg, "drop")) *vsync_var = VSYNC_DROP; 277 else if (!is_global && !av_strcasecmp(arg, "auto")) *vsync_var = VSYNC_AUTO; 278 else if (!is_global) { 279 av_log(NULL, AV_LOG_FATAL, "Invalid value %s specified for fps_mode of #%d:%d.\n", arg, file_idx, st_idx); 280 exit_program(1); 281 } 282 283 if (is_global && *vsync_var == VSYNC_AUTO) { 284 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR); 285 av_log(NULL, AV_LOG_WARNING, "Passing a number to -vsync is deprecated," 286 " use a string argument as described in the manual.\n"); 287 } 288 return 0; 289} 290 291static int apply_sync_offsets(void) 292{ 293 for (int i = 0; i < nb_input_files; i++) { 294 InputFile *ref, *self = input_files[i]; 295 int64_t adjustment; 296 int64_t self_start_time, ref_start_time, self_seek_start, ref_seek_start; 297 int start_times_set = 1; 298 299 if (self->input_sync_ref == -1 || self->input_sync_ref == i) continue; 300 if (self->input_sync_ref >= nb_input_files || self->input_sync_ref < -1) { 301 av_log(NULL, AV_LOG_FATAL, "-isync for input %d references non-existent input %d.\n", i, self->input_sync_ref); 302 exit_program(1); 303 } 304 305 if (copy_ts && !start_at_zero) { 306 av_log(NULL, AV_LOG_FATAL, "Use of -isync requires that start_at_zero be set if copyts is set.\n"); 307 exit_program(1); 308 } 309 310 ref = input_files[self->input_sync_ref]; 311 if (ref->input_sync_ref != -1 && ref->input_sync_ref != self->input_sync_ref) { 312 av_log(NULL, AV_LOG_ERROR, "-isync for input %d references a resynced input %d. Sync not set.\n", i, self->input_sync_ref); 313 continue; 314 } 315 316 if (self->ctx->start_time_realtime != AV_NOPTS_VALUE && ref->ctx->start_time_realtime != AV_NOPTS_VALUE) { 317 self_start_time = self->ctx->start_time_realtime; 318 ref_start_time = ref->ctx->start_time_realtime; 319 } else if (self->ctx->start_time != AV_NOPTS_VALUE && ref->ctx->start_time != AV_NOPTS_VALUE) { 320 self_start_time = self->ctx->start_time; 321 ref_start_time = ref->ctx->start_time; 322 } else { 323 start_times_set = 0; 324 } 325 326 if (start_times_set) { 327 self_seek_start = self->start_time == AV_NOPTS_VALUE ? 0 : self->start_time; 328 ref_seek_start = ref->start_time == AV_NOPTS_VALUE ? 0 : ref->start_time; 329 330 adjustment = (self_start_time - ref_start_time) + !copy_ts*(self_seek_start - ref_seek_start) + ref->input_ts_offset; 331 332 self->ts_offset += adjustment; 333 334 av_log(NULL, AV_LOG_INFO, "Adjusted ts offset for Input #%d by %"PRId64" us to sync with Input #%d.\n", i, adjustment, self->input_sync_ref); 335 } else { 336 av_log(NULL, AV_LOG_INFO, "Unable to identify start times for Inputs #%d and %d both. No sync adjustment made.\n", i, self->input_sync_ref); 337 } 338 } 339 340 return 0; 341} 342 343static int opt_filter_threads(void *optctx, const char *opt, const char *arg) 344{ 345 av_free(filter_nbthreads); 346 filter_nbthreads = av_strdup(arg); 347 return 0; 348} 349 350static int opt_abort_on(void *optctx, const char *opt, const char *arg) 351{ 352 static const AVOption opts[] = { 353 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" }, 354 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" }, 355 { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" }, 356 { NULL }, 357 }; 358 static const AVClass class = { 359 .class_name = "", 360 .item_name = av_default_item_name, 361 .option = opts, 362 .version = LIBAVUTIL_VERSION_INT, 363 }; 364 const AVClass *pclass = &class; 365 366 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags); 367} 368 369static int opt_stats_period(void *optctx, const char *opt, const char *arg) 370{ 371 int64_t user_stats_period = parse_time_or_die(opt, arg, 1); 372 373 if (user_stats_period <= 0) { 374 av_log(NULL, AV_LOG_ERROR, "stats_period %s must be positive.\n", arg); 375 return AVERROR(EINVAL); 376 } 377 378 stats_period = user_stats_period; 379 av_log(NULL, AV_LOG_INFO, "ffmpeg stats and -progress period set to %s.\n", arg); 380 381 return 0; 382} 383 384static int opt_audio_codec(void *optctx, const char *opt, const char *arg) 385{ 386 OptionsContext *o = optctx; 387 return parse_option(o, "codec:a", arg, options); 388} 389 390static int opt_video_codec(void *optctx, const char *opt, const char *arg) 391{ 392 OptionsContext *o = optctx; 393 return parse_option(o, "codec:v", arg, options); 394} 395 396static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg) 397{ 398 OptionsContext *o = optctx; 399 return parse_option(o, "codec:s", arg, options); 400} 401 402static int opt_data_codec(void *optctx, const char *opt, const char *arg) 403{ 404 OptionsContext *o = optctx; 405 return parse_option(o, "codec:d", arg, options); 406} 407 408static int opt_map(void *optctx, const char *opt, const char *arg) 409{ 410 OptionsContext *o = optctx; 411 StreamMap *m = NULL; 412 int i, negative = 0, file_idx, disabled = 0; 413 int sync_file_idx = -1, sync_stream_idx = 0; 414 char *p, *sync; 415 char *map; 416 char *allow_unused; 417 418 if (*arg == '-') { 419 negative = 1; 420 arg++; 421 } 422 map = av_strdup(arg); 423 if (!map) 424 return AVERROR(ENOMEM); 425 426 /* parse sync stream first, just pick first matching stream */ 427 if (sync = strchr(map, ',')) { 428 *sync = 0; 429 sync_file_idx = strtol(sync + 1, &sync, 0); 430 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) { 431 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx); 432 exit_program(1); 433 } 434 if (*sync) 435 sync++; 436 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++) 437 if (check_stream_specifier(input_files[sync_file_idx]->ctx, 438 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) { 439 sync_stream_idx = i; 440 break; 441 } 442 if (i == input_files[sync_file_idx]->nb_streams) { 443 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not " 444 "match any streams.\n", arg); 445 exit_program(1); 446 } 447 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) { 448 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input " 449 "stream.\n", arg); 450 exit_program(1); 451 } 452 } 453 454 455 if (map[0] == '[') { 456 /* this mapping refers to lavfi output */ 457 const char *c = map + 1; 458 GROW_ARRAY(o->stream_maps, o->nb_stream_maps); 459 m = &o->stream_maps[o->nb_stream_maps - 1]; 460 m->linklabel = av_get_token(&c, "]"); 461 if (!m->linklabel) { 462 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map); 463 exit_program(1); 464 } 465 } else { 466 if (allow_unused = strchr(map, '?')) 467 *allow_unused = 0; 468 file_idx = strtol(map, &p, 0); 469 if (file_idx >= nb_input_files || file_idx < 0) { 470 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx); 471 exit_program(1); 472 } 473 if (negative) 474 /* disable some already defined maps */ 475 for (i = 0; i < o->nb_stream_maps; i++) { 476 m = &o->stream_maps[i]; 477 if (file_idx == m->file_index && 478 check_stream_specifier(input_files[m->file_index]->ctx, 479 input_files[m->file_index]->ctx->streams[m->stream_index], 480 *p == ':' ? p + 1 : p) > 0) 481 m->disabled = 1; 482 } 483 else 484 for (i = 0; i < input_files[file_idx]->nb_streams; i++) { 485 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i], 486 *p == ':' ? p + 1 : p) <= 0) 487 continue; 488 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) { 489 disabled = 1; 490 continue; 491 } 492 GROW_ARRAY(o->stream_maps, o->nb_stream_maps); 493 m = &o->stream_maps[o->nb_stream_maps - 1]; 494 495 m->file_index = file_idx; 496 m->stream_index = i; 497 498 if (sync_file_idx >= 0) { 499 m->sync_file_index = sync_file_idx; 500 m->sync_stream_index = sync_stream_idx; 501 } else { 502 m->sync_file_index = file_idx; 503 m->sync_stream_index = i; 504 } 505 } 506 } 507 508 if (!m) { 509 if (allow_unused) { 510 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg); 511 } else if (disabled) { 512 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n" 513 "To ignore this, add a trailing '?' to the map.\n", arg); 514 exit_program(1); 515 } else { 516 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n" 517 "To ignore this, add a trailing '?' to the map.\n", arg); 518 exit_program(1); 519 } 520 } 521 522 av_freep(&map); 523 return 0; 524} 525 526static int opt_attach(void *optctx, const char *opt, const char *arg) 527{ 528 OptionsContext *o = optctx; 529 GROW_ARRAY(o->attachments, o->nb_attachments); 530 o->attachments[o->nb_attachments - 1] = arg; 531 return 0; 532} 533 534static int opt_map_channel(void *optctx, const char *opt, const char *arg) 535{ 536 OptionsContext *o = optctx; 537 int n; 538 AVStream *st; 539 AudioChannelMap *m; 540 char *allow_unused; 541 char *mapchan; 542 mapchan = av_strdup(arg); 543 if (!mapchan) 544 return AVERROR(ENOMEM); 545 546 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps); 547 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1]; 548 549 /* muted channel syntax */ 550 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx); 551 if ((n == 1 || n == 3) && m->channel_idx == -1) { 552 m->file_idx = m->stream_idx = -1; 553 if (n == 1) 554 m->ofile_idx = m->ostream_idx = -1; 555 av_free(mapchan); 556 return 0; 557 } 558 559 /* normal syntax */ 560 n = sscanf(arg, "%d.%d.%d:%d.%d", 561 &m->file_idx, &m->stream_idx, &m->channel_idx, 562 &m->ofile_idx, &m->ostream_idx); 563 564 if (n != 3 && n != 5) { 565 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: " 566 "[file.stream.channel|-1][:syncfile:syncstream]\n"); 567 exit_program(1); 568 } 569 570 if (n != 5) // only file.stream.channel specified 571 m->ofile_idx = m->ostream_idx = -1; 572 573 /* check input */ 574 if (m->file_idx < 0 || m->file_idx >= nb_input_files) { 575 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n", 576 m->file_idx); 577 exit_program(1); 578 } 579 if (m->stream_idx < 0 || 580 m->stream_idx >= input_files[m->file_idx]->nb_streams) { 581 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n", 582 m->file_idx, m->stream_idx); 583 exit_program(1); 584 } 585 st = input_files[m->file_idx]->ctx->streams[m->stream_idx]; 586 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) { 587 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n", 588 m->file_idx, m->stream_idx); 589 exit_program(1); 590 } 591 /* allow trailing ? to map_channel */ 592 if (allow_unused = strchr(mapchan, '?')) 593 *allow_unused = 0; 594 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->ch_layout.nb_channels || 595 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) { 596 if (allow_unused) { 597 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n", 598 m->file_idx, m->stream_idx, m->channel_idx); 599 } else { 600 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n" 601 "To ignore this, add a trailing '?' to the map_channel.\n", 602 m->file_idx, m->stream_idx, m->channel_idx); 603 exit_program(1); 604 } 605 606 } 607 av_free(mapchan); 608 return 0; 609} 610 611static int opt_sdp_file(void *optctx, const char *opt, const char *arg) 612{ 613 av_free(sdp_filename); 614 sdp_filename = av_strdup(arg); 615 return 0; 616} 617 618#if CONFIG_VAAPI 619static int opt_vaapi_device(void *optctx, const char *opt, const char *arg) 620{ 621 const char *prefix = "vaapi:"; 622 char *tmp; 623 int err; 624 tmp = av_asprintf("%s%s", prefix, arg); 625 if (!tmp) 626 return AVERROR(ENOMEM); 627 err = hw_device_init_from_string(tmp, NULL); 628 av_free(tmp); 629 return err; 630} 631#endif 632 633#if CONFIG_QSV 634static int opt_qsv_device(void *optctx, const char *opt, const char *arg) 635{ 636 const char *prefix = "qsv=__qsv_device:hw_any,child_device="; 637 int err; 638 char *tmp = av_asprintf("%s%s", prefix, arg); 639 640 if (!tmp) 641 return AVERROR(ENOMEM); 642 643 err = hw_device_init_from_string(tmp, NULL); 644 av_free(tmp); 645 646 return err; 647} 648#endif 649 650static int opt_init_hw_device(void *optctx, const char *opt, const char *arg) 651{ 652 if (!strcmp(arg, "list")) { 653 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE; 654 printf("Supported hardware device types:\n"); 655 while ((type = av_hwdevice_iterate_types(type)) != 656 AV_HWDEVICE_TYPE_NONE) 657 printf("%s\n", av_hwdevice_get_type_name(type)); 658 printf("\n"); 659 exit_program(0); 660 } else { 661 return hw_device_init_from_string(arg, NULL); 662 } 663} 664 665static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg) 666{ 667 if (filter_hw_device) { 668 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n"); 669 return AVERROR(EINVAL); 670 } 671 filter_hw_device = hw_device_get_by_name(arg); 672 if (!filter_hw_device) { 673 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg); 674 return AVERROR(EINVAL); 675 } 676 return 0; 677} 678 679/** 680 * Parse a metadata specifier passed as 'arg' parameter. 681 * @param arg metadata string to parse 682 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram) 683 * @param index for type c/p, chapter/program index is written here 684 * @param stream_spec for type s, the stream specifier is written here 685 */ 686static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec) 687{ 688 if (*arg) { 689 *type = *arg; 690 switch (*arg) { 691 case 'g': 692 break; 693 case 's': 694 if (*(++arg) && *arg != ':') { 695 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg); 696 exit_program(1); 697 } 698 *stream_spec = *arg == ':' ? arg + 1 : ""; 699 break; 700 case 'c': 701 case 'p': 702 if (*(++arg) == ':') 703 *index = strtol(++arg, NULL, 0); 704 break; 705 default: 706 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg); 707 exit_program(1); 708 } 709 } else 710 *type = 'g'; 711} 712 713static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o) 714{ 715 AVDictionary **meta_in = NULL; 716 AVDictionary **meta_out = NULL; 717 int i, ret = 0; 718 char type_in, type_out; 719 const char *istream_spec = NULL, *ostream_spec = NULL; 720 int idx_in = 0, idx_out = 0; 721 722 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec); 723 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec); 724 725 if (!ic) { 726 if (type_out == 'g' || !*outspec) 727 o->metadata_global_manual = 1; 728 if (type_out == 's' || !*outspec) 729 o->metadata_streams_manual = 1; 730 if (type_out == 'c' || !*outspec) 731 o->metadata_chapters_manual = 1; 732 return 0; 733 } 734 735 if (type_in == 'g' || type_out == 'g') 736 o->metadata_global_manual = 1; 737 if (type_in == 's' || type_out == 's') 738 o->metadata_streams_manual = 1; 739 if (type_in == 'c' || type_out == 'c') 740 o->metadata_chapters_manual = 1; 741 742 /* ic is NULL when just disabling automatic mappings */ 743 if (!ic) 744 return 0; 745 746#define METADATA_CHECK_INDEX(index, nb_elems, desc)\ 747 if ((index) < 0 || (index) >= (nb_elems)) {\ 748 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\ 749 (desc), (index));\ 750 exit_program(1);\ 751 } 752 753#define SET_DICT(type, meta, context, index)\ 754 switch (type) {\ 755 case 'g':\ 756 meta = &context->metadata;\ 757 break;\ 758 case 'c':\ 759 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\ 760 meta = &context->chapters[index]->metadata;\ 761 break;\ 762 case 'p':\ 763 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\ 764 meta = &context->programs[index]->metadata;\ 765 break;\ 766 case 's':\ 767 break; /* handled separately below */ \ 768 default: av_assert0(0);\ 769 }\ 770 771 SET_DICT(type_in, meta_in, ic, idx_in); 772 SET_DICT(type_out, meta_out, oc, idx_out); 773 774 /* for input streams choose first matching stream */ 775 if (type_in == 's') { 776 for (i = 0; i < ic->nb_streams; i++) { 777 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) { 778 meta_in = &ic->streams[i]->metadata; 779 break; 780 } else if (ret < 0) 781 exit_program(1); 782 } 783 if (!meta_in) { 784 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec); 785 exit_program(1); 786 } 787 } 788 789 if (type_out == 's') { 790 for (i = 0; i < oc->nb_streams; i++) { 791 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) { 792 meta_out = &oc->streams[i]->metadata; 793 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE); 794 } else if (ret < 0) 795 exit_program(1); 796 } 797 } else 798 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE); 799 800 return 0; 801} 802 803static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg) 804{ 805 OptionsContext *o = optctx; 806 char buf[128]; 807 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6; 808 struct tm time = *gmtime((time_t*)&recording_timestamp); 809 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time)) 810 return -1; 811 parse_option(o, "metadata", buf, options); 812 813 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata " 814 "tag instead.\n", opt); 815 return 0; 816} 817 818static const AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder) 819{ 820 const AVCodecDescriptor *desc; 821 const char *codec_string = encoder ? "encoder" : "decoder"; 822 const AVCodec *codec; 823 824 codec = encoder ? 825 avcodec_find_encoder_by_name(name) : 826 avcodec_find_decoder_by_name(name); 827 828 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) { 829 codec = encoder ? avcodec_find_encoder(desc->id) : 830 avcodec_find_decoder(desc->id); 831 if (codec) 832 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n", 833 codec_string, codec->name, desc->name); 834 } 835 836 if (!codec) { 837 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name); 838 exit_program(1); 839 } 840 if (codec->type != type && !recast_media) { 841 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name); 842 exit_program(1); 843 } 844 return codec; 845} 846 847static const AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st) 848{ 849 char *codec_name = NULL; 850 851 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st); 852 if (codec_name) { 853 const AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0); 854 st->codecpar->codec_id = codec->id; 855 if (recast_media && st->codecpar->codec_type != codec->type) 856 st->codecpar->codec_type = codec->type; 857 return codec; 858 } else 859 return avcodec_find_decoder(st->codecpar->codec_id); 860} 861 862/* Add all the streams from the given input file to the global 863 * list of input streams. */ 864static void add_input_streams(OptionsContext *o, AVFormatContext *ic) 865{ 866 int i, ret; 867 868 for (i = 0; i < ic->nb_streams; i++) { 869 AVStream *st = ic->streams[i]; 870 AVCodecParameters *par = st->codecpar; 871 InputStream *ist; 872 char *framerate = NULL, *hwaccel_device = NULL; 873 const char *hwaccel = NULL; 874 char *hwaccel_output_format = NULL; 875 char *codec_tag = NULL; 876 char *next; 877 char *discard_str = NULL; 878 const AVClass *cc = avcodec_get_class(); 879 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 880 0, AV_OPT_SEARCH_FAKE_OBJ); 881 882 ist = ALLOC_ARRAY_ELEM(input_streams, nb_input_streams); 883 ist->st = st; 884 ist->file_index = nb_input_files; 885 ist->discard = 1; 886 st->discard = AVDISCARD_ALL; 887 ist->nb_samples = 0; 888 ist->first_dts = AV_NOPTS_VALUE; 889 ist->min_pts = INT64_MAX; 890 ist->max_pts = INT64_MIN; 891 892 ist->ts_scale = 1.0; 893 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st); 894 895 ist->autorotate = 1; 896 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st); 897 898 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st); 899 if (codec_tag) { 900 uint32_t tag = strtol(codec_tag, &next, 0); 901 if (*next) { 902 uint8_t buf[4] = { 0 }; 903 memcpy(buf, codec_tag, FFMIN(sizeof(buf), strlen(codec_tag))); 904 tag = AV_RL32(buf); 905 } 906 st->codecpar->codec_tag = tag; 907 } 908 909 ist->dec = choose_decoder(o, ic, st); 910 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec); 911 912 ist->reinit_filters = -1; 913 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st); 914 915 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st); 916 ist->user_set_discard = AVDISCARD_NONE; 917 918 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) || 919 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) || 920 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) || 921 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)) 922 ist->user_set_discard = AVDISCARD_ALL; 923 924 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) { 925 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n", 926 discard_str); 927 exit_program(1); 928 } 929 930 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE; 931 ist->prev_pkt_pts = AV_NOPTS_VALUE; 932 933 ist->dec_ctx = avcodec_alloc_context3(ist->dec); 934 if (!ist->dec_ctx) { 935 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n"); 936 exit_program(1); 937 } 938 939 ret = avcodec_parameters_to_context(ist->dec_ctx, par); 940 if (ret < 0) { 941 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n"); 942 exit_program(1); 943 } 944 945 ist->decoded_frame = av_frame_alloc(); 946 if (!ist->decoded_frame) 947 exit_program(1); 948 949 ist->pkt = av_packet_alloc(); 950 if (!ist->pkt) 951 exit_program(1); 952 953 if (o->bitexact) 954 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT; 955 956 switch (par->codec_type) { 957 case AVMEDIA_TYPE_VIDEO: 958 if(!ist->dec) 959 ist->dec = avcodec_find_decoder(par->codec_id); 960 961 // avformat_find_stream_info() doesn't set this for us anymore. 962 ist->dec_ctx->framerate = st->avg_frame_rate; 963 964 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st); 965 if (framerate && av_parse_video_rate(&ist->framerate, 966 framerate) < 0) { 967 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n", 968 framerate); 969 exit_program(1); 970 } 971 972 ist->top_field_first = -1; 973 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st); 974 975 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st); 976 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str, 977 hwaccel_output_format, ic, st); 978 979 if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) { 980 av_log(NULL, AV_LOG_WARNING, 981 "WARNING: defaulting hwaccel_output_format to cuda for compatibility " 982 "with old commandlines. This behaviour is DEPRECATED and will be removed " 983 "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n"); 984 ist->hwaccel_output_format = AV_PIX_FMT_CUDA; 985 } else if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "qsv")) { 986 av_log(NULL, AV_LOG_WARNING, 987 "WARNING: defaulting hwaccel_output_format to qsv for compatibility " 988 "with old commandlines. This behaviour is DEPRECATED and will be removed " 989 "in the future. Please explicitly set \"-hwaccel_output_format qsv\".\n"); 990 ist->hwaccel_output_format = AV_PIX_FMT_QSV; 991 } else if (hwaccel_output_format) { 992 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format); 993 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) { 994 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output " 995 "format: %s", hwaccel_output_format); 996 } 997 } else { 998 ist->hwaccel_output_format = AV_PIX_FMT_NONE; 999 } 1000 1001 if (hwaccel) { 1002 // The NVDEC hwaccels use a CUDA device, so remap the name here. 1003 if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid")) 1004 hwaccel = "cuda"; 1005 1006 if (!strcmp(hwaccel, "none")) 1007 ist->hwaccel_id = HWACCEL_NONE; 1008 else if (!strcmp(hwaccel, "auto")) 1009 ist->hwaccel_id = HWACCEL_AUTO; 1010 else { 1011 enum AVHWDeviceType type = av_hwdevice_find_type_by_name(hwaccel); 1012 if (type != AV_HWDEVICE_TYPE_NONE) { 1013 ist->hwaccel_id = HWACCEL_GENERIC; 1014 ist->hwaccel_device_type = type; 1015 } 1016 1017 if (!ist->hwaccel_id) { 1018 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n", 1019 hwaccel); 1020 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: "); 1021 type = AV_HWDEVICE_TYPE_NONE; 1022 while ((type = av_hwdevice_iterate_types(type)) != 1023 AV_HWDEVICE_TYPE_NONE) 1024 av_log(NULL, AV_LOG_FATAL, "%s ", 1025 av_hwdevice_get_type_name(type)); 1026 av_log(NULL, AV_LOG_FATAL, "\n"); 1027 exit_program(1); 1028 } 1029 } 1030 } 1031 1032 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st); 1033 if (hwaccel_device) { 1034 ist->hwaccel_device = av_strdup(hwaccel_device); 1035 if (!ist->hwaccel_device) 1036 exit_program(1); 1037 } 1038 1039 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE; 1040 1041 break; 1042 case AVMEDIA_TYPE_AUDIO: 1043 ist->guess_layout_max = INT_MAX; 1044 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st); 1045 guess_input_channel_layout(ist); 1046 break; 1047 case AVMEDIA_TYPE_DATA: 1048 case AVMEDIA_TYPE_SUBTITLE: { 1049 char *canvas_size = NULL; 1050 if(!ist->dec) 1051 ist->dec = avcodec_find_decoder(par->codec_id); 1052 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st); 1053 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st); 1054 if (canvas_size && 1055 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) { 1056 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size); 1057 exit_program(1); 1058 } 1059 break; 1060 } 1061 case AVMEDIA_TYPE_ATTACHMENT: 1062 case AVMEDIA_TYPE_UNKNOWN: 1063 break; 1064 default: 1065 abort(); 1066 } 1067 1068 ret = avcodec_parameters_from_context(par, ist->dec_ctx); 1069 if (ret < 0) { 1070 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n"); 1071 exit_program(1); 1072 } 1073 } 1074} 1075 1076static void assert_file_overwrite(const char *filename) 1077{ 1078 const char *proto_name = avio_find_protocol_name(filename); 1079 1080 if (file_overwrite && no_file_overwrite) { 1081 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n"); 1082 exit_program(1); 1083 } 1084 1085 if (!file_overwrite) { 1086 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) { 1087 if (stdin_interaction && !no_file_overwrite) { 1088 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename); 1089 fflush(stderr); 1090 term_exit(); 1091 signal(SIGINT, SIG_DFL); 1092 if (!read_yesno()) { 1093 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n"); 1094 exit_program(1); 1095 } 1096 term_init(); 1097 } 1098 else { 1099 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename); 1100 exit_program(1); 1101 } 1102 } 1103 } 1104 1105 if (proto_name && !strcmp(proto_name, "file")) { 1106 for (int i = 0; i < nb_input_files; i++) { 1107 InputFile *file = input_files[i]; 1108 if (file->ctx->iformat->flags & AVFMT_NOFILE) 1109 continue; 1110 if (!strcmp(filename, file->ctx->url)) { 1111 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i); 1112 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n"); 1113 exit_program(1); 1114 } 1115 } 1116 } 1117} 1118 1119static void dump_attachment(AVStream *st, const char *filename) 1120{ 1121 int ret; 1122 AVIOContext *out = NULL; 1123 const AVDictionaryEntry *e; 1124 1125 if (!st->codecpar->extradata_size) { 1126 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n", 1127 nb_input_files - 1, st->index); 1128 return; 1129 } 1130 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0))) 1131 filename = e->value; 1132 if (!*filename) { 1133 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag" 1134 "in stream #%d:%d.\n", nb_input_files - 1, st->index); 1135 exit_program(1); 1136 } 1137 1138 assert_file_overwrite(filename); 1139 1140 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) { 1141 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n", 1142 filename); 1143 exit_program(1); 1144 } 1145 1146 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size); 1147 avio_flush(out); 1148 avio_close(out); 1149} 1150 1151static int open_input_file(OptionsContext *o, const char *filename) 1152{ 1153 InputFile *f; 1154 AVFormatContext *ic; 1155 const AVInputFormat *file_iformat = NULL; 1156 int err, i, ret; 1157 int64_t timestamp; 1158 AVDictionary *unused_opts = NULL; 1159 const AVDictionaryEntry *e = NULL; 1160 char * video_codec_name = NULL; 1161 char * audio_codec_name = NULL; 1162 char *subtitle_codec_name = NULL; 1163 char * data_codec_name = NULL; 1164 int scan_all_pmts_set = 0; 1165 1166 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) { 1167 o->stop_time = INT64_MAX; 1168 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n"); 1169 } 1170 1171 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) { 1172 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time; 1173 if (o->stop_time <= start_time) { 1174 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n"); 1175 exit_program(1); 1176 } else { 1177 o->recording_time = o->stop_time - start_time; 1178 } 1179 } 1180 1181 if (o->format) { 1182 if (!(file_iformat = av_find_input_format(o->format))) { 1183 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format); 1184 exit_program(1); 1185 } 1186 } 1187 1188 if (!strcmp(filename, "-")) 1189 filename = "pipe:"; 1190 1191 stdin_interaction &= strncmp(filename, "pipe:", 5) && 1192 strcmp(filename, "/dev/stdin"); 1193 1194 /* get default parameters from command line */ 1195 ic = avformat_alloc_context(); 1196 if (!ic) { 1197 print_error(filename, AVERROR(ENOMEM)); 1198 exit_program(1); 1199 } 1200 if (o->nb_audio_sample_rate) { 1201 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0); 1202 } 1203 if (o->nb_audio_channels) { 1204 const AVClass *priv_class; 1205 if (file_iformat && (priv_class = file_iformat->priv_class) && 1206 av_opt_find(&priv_class, "ch_layout", NULL, 0, 1207 AV_OPT_SEARCH_FAKE_OBJ)) { 1208 char buf[32]; 1209 snprintf(buf, sizeof(buf), "%dC", o->audio_channels[o->nb_audio_channels - 1].u.i); 1210 av_dict_set(&o->g->format_opts, "ch_layout", buf, 0); 1211 } 1212 } 1213 if (o->nb_audio_ch_layouts) { 1214 const AVClass *priv_class; 1215 if (file_iformat && (priv_class = file_iformat->priv_class) && 1216 av_opt_find(&priv_class, "ch_layout", NULL, 0, 1217 AV_OPT_SEARCH_FAKE_OBJ)) { 1218 av_dict_set(&o->g->format_opts, "ch_layout", o->audio_ch_layouts[o->nb_audio_ch_layouts - 1].u.str, 0); 1219 } 1220 } 1221 if (o->nb_frame_rates) { 1222 const AVClass *priv_class; 1223 /* set the format-level framerate option; 1224 * this is important for video grabbers, e.g. x11 */ 1225 if (file_iformat && (priv_class = file_iformat->priv_class) && 1226 av_opt_find(&priv_class, "framerate", NULL, 0, 1227 AV_OPT_SEARCH_FAKE_OBJ)) { 1228 av_dict_set(&o->g->format_opts, "framerate", 1229 o->frame_rates[o->nb_frame_rates - 1].u.str, 0); 1230 } 1231 } 1232 if (o->nb_frame_sizes) { 1233 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0); 1234 } 1235 if (o->nb_frame_pix_fmts) 1236 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0); 1237 1238 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v"); 1239 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a"); 1240 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s"); 1241 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d"); 1242 1243 if (video_codec_name) 1244 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0); 1245 if (audio_codec_name) 1246 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0); 1247 if (subtitle_codec_name) 1248 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0); 1249 if (data_codec_name) 1250 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0); 1251 1252 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE; 1253 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE; 1254 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE; 1255 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE; 1256 1257 ic->flags |= AVFMT_FLAG_NONBLOCK; 1258 if (o->bitexact) 1259 ic->flags |= AVFMT_FLAG_BITEXACT; 1260 ic->interrupt_callback = int_cb; 1261 1262 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) { 1263 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE); 1264 scan_all_pmts_set = 1; 1265 } 1266 /* open the input file with generic avformat function */ 1267 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts); 1268 if (err < 0) { 1269 print_error(filename, err); 1270 if (err == AVERROR_PROTOCOL_NOT_FOUND) 1271 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename); 1272 exit_program(1); 1273 } 1274 if (scan_all_pmts_set) 1275 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE); 1276 remove_avoptions(&o->g->format_opts, o->g->codec_opts); 1277 assert_avoptions(o->g->format_opts); 1278 1279 /* apply forced codec ids */ 1280 for (i = 0; i < ic->nb_streams; i++) 1281 choose_decoder(o, ic, ic->streams[i]); 1282 1283 if (find_stream_info) { 1284 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts); 1285 int orig_nb_streams = ic->nb_streams; 1286 1287 /* If not enough info to get the stream parameters, we decode the 1288 first frames to get it. (used in mpeg case for example) */ 1289 ret = avformat_find_stream_info(ic, opts); 1290 1291 for (i = 0; i < orig_nb_streams; i++) 1292 av_dict_free(&opts[i]); 1293 av_freep(&opts); 1294 1295 if (ret < 0) { 1296 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename); 1297 if (ic->nb_streams == 0) { 1298 avformat_close_input(&ic); 1299 exit_program(1); 1300 } 1301 } 1302 } 1303 1304 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) { 1305 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename); 1306 o->start_time_eof = AV_NOPTS_VALUE; 1307 } 1308 1309 if (o->start_time_eof != AV_NOPTS_VALUE) { 1310 if (o->start_time_eof >= 0) { 1311 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n"); 1312 exit_program(1); 1313 } 1314 if (ic->duration > 0) { 1315 o->start_time = o->start_time_eof + ic->duration; 1316 if (o->start_time < 0) { 1317 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename); 1318 o->start_time = AV_NOPTS_VALUE; 1319 } 1320 } else 1321 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename); 1322 } 1323 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time; 1324 /* add the stream start time */ 1325 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE) 1326 timestamp += ic->start_time; 1327 1328 /* if seeking requested, we execute it */ 1329 if (o->start_time != AV_NOPTS_VALUE) { 1330 int64_t seek_timestamp = timestamp; 1331 1332 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) { 1333 int dts_heuristic = 0; 1334 for (i=0; i<ic->nb_streams; i++) { 1335 const AVCodecParameters *par = ic->streams[i]->codecpar; 1336 if (par->video_delay) { 1337 dts_heuristic = 1; 1338 break; 1339 } 1340 } 1341 if (dts_heuristic) { 1342 seek_timestamp -= 3*AV_TIME_BASE / 23; 1343 } 1344 } 1345 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0); 1346 if (ret < 0) { 1347 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n", 1348 filename, (double)timestamp / AV_TIME_BASE); 1349 } 1350 } 1351 1352 /* update the current parameters so that they match the one of the input stream */ 1353 add_input_streams(o, ic); 1354 1355 /* dump the file content */ 1356 av_dump_format(ic, nb_input_files, filename, 0); 1357 1358 f = ALLOC_ARRAY_ELEM(input_files, nb_input_files); 1359 1360 f->ctx = ic; 1361 f->ist_index = nb_input_streams - ic->nb_streams; 1362 f->start_time = o->start_time; 1363 f->recording_time = o->recording_time; 1364 f->input_sync_ref = o->input_sync_ref; 1365 f->input_ts_offset = o->input_ts_offset; 1366 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp); 1367 f->nb_streams = ic->nb_streams; 1368 f->rate_emu = o->rate_emu; 1369 f->accurate_seek = o->accurate_seek; 1370 f->loop = o->loop; 1371 f->duration = 0; 1372 f->time_base = (AVRational){ 1, 1 }; 1373 1374 f->readrate = o->readrate ? o->readrate : 0.0; 1375 if (f->readrate < 0.0f) { 1376 av_log(NULL, AV_LOG_ERROR, "Option -readrate for Input #%d is %0.3f; it must be non-negative.\n", nb_input_files, f->readrate); 1377 exit_program(1); 1378 } 1379 if (f->readrate && f->rate_emu) { 1380 av_log(NULL, AV_LOG_WARNING, "Both -readrate and -re set for Input #%d. Using -readrate %0.3f.\n", nb_input_files, f->readrate); 1381 f->rate_emu = 0; 1382 } 1383 1384 f->pkt = av_packet_alloc(); 1385 if (!f->pkt) 1386 exit_program(1); 1387#if HAVE_THREADS 1388 f->thread_queue_size = o->thread_queue_size; 1389#endif 1390 1391 /* check if all codec options have been used */ 1392 unused_opts = strip_specifiers(o->g->codec_opts); 1393 for (i = f->ist_index; i < nb_input_streams; i++) { 1394 e = NULL; 1395 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e, 1396 AV_DICT_IGNORE_SUFFIX))) 1397 av_dict_set(&unused_opts, e->key, NULL, 0); 1398 } 1399 1400 e = NULL; 1401 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) { 1402 const AVClass *class = avcodec_get_class(); 1403 const AVOption *option = av_opt_find(&class, e->key, NULL, 0, 1404 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ); 1405 const AVClass *fclass = avformat_get_class(); 1406 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0, 1407 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ); 1408 if (!option || foption) 1409 continue; 1410 1411 1412 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) { 1413 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for " 1414 "input file #%d (%s) is not a decoding option.\n", e->key, 1415 option->help ? option->help : "", nb_input_files - 1, 1416 filename); 1417 exit_program(1); 1418 } 1419 1420 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for " 1421 "input file #%d (%s) has not been used for any stream. The most " 1422 "likely reason is either wrong type (e.g. a video option with " 1423 "no video streams) or that it is a private option of some decoder " 1424 "which was not actually used for any stream.\n", e->key, 1425 option->help ? option->help : "", nb_input_files - 1, filename); 1426 } 1427 av_dict_free(&unused_opts); 1428 1429 for (i = 0; i < o->nb_dump_attachment; i++) { 1430 int j; 1431 1432 for (j = 0; j < ic->nb_streams; j++) { 1433 AVStream *st = ic->streams[j]; 1434 1435 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1) 1436 dump_attachment(st, o->dump_attachment[i].u.str); 1437 } 1438 } 1439 1440 input_stream_potentially_available = 1; 1441 1442 return 0; 1443} 1444 1445static char *get_line(AVIOContext *s, AVBPrint *bprint) 1446{ 1447 char c; 1448 1449 while ((c = avio_r8(s)) && c != '\n') 1450 av_bprint_chars(bprint, c, 1); 1451 1452 if (!av_bprint_is_complete(bprint)) { 1453 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n"); 1454 exit_program(1); 1455 } 1456 return bprint->str; 1457} 1458 1459static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s) 1460{ 1461 int i, ret = -1; 1462 char filename[1000]; 1463 char *env_avconv_datadir = getenv_utf8("AVCONV_DATADIR"); 1464 char *env_home = getenv_utf8("HOME"); 1465 const char *base[3] = { env_avconv_datadir, 1466 env_home, 1467 AVCONV_DATADIR, 1468 }; 1469 1470 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) { 1471 if (!base[i]) 1472 continue; 1473 if (codec_name) { 1474 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i], 1475 i != 1 ? "" : "/.avconv", codec_name, preset_name); 1476 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL); 1477 } 1478 if (ret < 0) { 1479 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i], 1480 i != 1 ? "" : "/.avconv", preset_name); 1481 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL); 1482 } 1483 } 1484 freeenv_utf8(env_home); 1485 freeenv_utf8(env_avconv_datadir); 1486 return ret; 1487} 1488 1489static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost) 1490{ 1491 enum AVMediaType type = ost->st->codecpar->codec_type; 1492 char *codec_name = NULL; 1493 1494 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) { 1495 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st); 1496 if (!codec_name) { 1497 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url, 1498 NULL, ost->st->codecpar->codec_type); 1499 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id); 1500 if (!ost->enc) { 1501 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for " 1502 "output stream #%d:%d. Default encoder for format %s (codec %s) is " 1503 "probably disabled. Please choose an encoder manually.\n", 1504 ost->file_index, ost->index, s->oformat->name, 1505 avcodec_get_name(ost->st->codecpar->codec_id)); 1506 return AVERROR_ENCODER_NOT_FOUND; 1507 } 1508 } else if (!strcmp(codec_name, "copy")) 1509 ost->stream_copy = 1; 1510 else { 1511 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1); 1512 ost->st->codecpar->codec_id = ost->enc->id; 1513 } 1514 ost->encoding_needed = !ost->stream_copy; 1515 } else { 1516 /* no encoding supported for other media types */ 1517 ost->stream_copy = 1; 1518 ost->encoding_needed = 0; 1519 } 1520 1521 return 0; 1522} 1523 1524static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index) 1525{ 1526 OutputStream *ost; 1527 AVStream *st = avformat_new_stream(oc, NULL); 1528 int idx = oc->nb_streams - 1, ret = 0; 1529 const char *bsfs = NULL, *time_base = NULL; 1530 char *next, *codec_tag = NULL; 1531 double qscale = -1; 1532 int i; 1533 1534 if (!st) { 1535 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n"); 1536 exit_program(1); 1537 } 1538 1539 if (oc->nb_streams - 1 < o->nb_streamid_map) 1540 st->id = o->streamid_map[oc->nb_streams - 1]; 1541 1542 ost = ALLOC_ARRAY_ELEM(output_streams, nb_output_streams); 1543 1544 ost->file_index = nb_output_files - 1; 1545 ost->index = idx; 1546 ost->st = st; 1547 ost->forced_kf_ref_pts = AV_NOPTS_VALUE; 1548 st->codecpar->codec_type = type; 1549 1550 ret = choose_encoder(o, oc, ost); 1551 if (ret < 0) { 1552 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream " 1553 "%d:%d\n", ost->file_index, ost->index); 1554 exit_program(1); 1555 } 1556 1557 ost->enc_ctx = avcodec_alloc_context3(ost->enc); 1558 if (!ost->enc_ctx) { 1559 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n"); 1560 exit_program(1); 1561 } 1562 ost->enc_ctx->codec_type = type; 1563 1564 ost->ref_par = avcodec_parameters_alloc(); 1565 if (!ost->ref_par) { 1566 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n"); 1567 exit_program(1); 1568 } 1569 1570 ost->filtered_frame = av_frame_alloc(); 1571 if (!ost->filtered_frame) 1572 exit_program(1); 1573 1574 ost->pkt = av_packet_alloc(); 1575 if (!ost->pkt) 1576 exit_program(1); 1577 1578 if (ost->enc) { 1579 AVIOContext *s = NULL; 1580 char *buf = NULL, *arg = NULL, *preset = NULL; 1581 1582 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc); 1583 1584 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st); 1585 ost->autoscale = 1; 1586 MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st); 1587 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) { 1588 AVBPrint bprint; 1589 av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED); 1590 do { 1591 av_bprint_clear(&bprint); 1592 buf = get_line(s, &bprint); 1593 if (!buf[0] || buf[0] == '#') 1594 continue; 1595 if (!(arg = strchr(buf, '='))) { 1596 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n"); 1597 exit_program(1); 1598 } 1599 *arg++ = 0; 1600 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE); 1601 } while (!s->eof_reached); 1602 av_bprint_finalize(&bprint, NULL); 1603 avio_closep(&s); 1604 } 1605 if (ret) { 1606 av_log(NULL, AV_LOG_FATAL, 1607 "Preset %s specified for stream %d:%d, but could not be opened.\n", 1608 preset, ost->file_index, ost->index); 1609 exit_program(1); 1610 } 1611 } else { 1612 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL); 1613 } 1614 1615 1616 if (o->bitexact) 1617 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT; 1618 1619 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st); 1620 if (time_base) { 1621 AVRational q; 1622 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 || 1623 q.num <= 0 || q.den <= 0) { 1624 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base); 1625 exit_program(1); 1626 } 1627 st->time_base = q; 1628 } 1629 1630 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st); 1631 if (time_base) { 1632 AVRational q; 1633 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 || 1634 q.den <= 0) { 1635 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base); 1636 exit_program(1); 1637 } 1638 ost->enc_timebase = q; 1639 } 1640 1641 ost->max_frames = INT64_MAX; 1642 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st); 1643 for (i = 0; i<o->nb_max_frames; i++) { 1644 char *p = o->max_frames[i].specifier; 1645 if (!*p && type != AVMEDIA_TYPE_VIDEO) { 1646 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n"); 1647 break; 1648 } 1649 } 1650 1651 ost->copy_prior_start = -1; 1652 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st); 1653 1654 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st); 1655 if (bsfs && *bsfs) { 1656 ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx); 1657 if (ret < 0) { 1658 av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret)); 1659 exit_program(1); 1660 } 1661 } 1662 1663 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st); 1664 if (codec_tag) { 1665 uint32_t tag = strtol(codec_tag, &next, 0); 1666 if (*next) { 1667 uint8_t buf[4] = { 0 }; 1668 memcpy(buf, codec_tag, FFMIN(sizeof(buf), strlen(codec_tag))); 1669 tag = AV_RL32(buf); 1670 } 1671 ost->st->codecpar->codec_tag = 1672 ost->enc_ctx->codec_tag = tag; 1673 } 1674 1675 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st); 1676 if (qscale >= 0) { 1677 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE; 1678 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale; 1679 } 1680 1681 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st); 1682 ost->disposition = av_strdup(ost->disposition); 1683 1684 ost->max_muxing_queue_size = 128; 1685 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st); 1686 1687 ost->muxing_queue_data_size = 0; 1688 1689 ost->muxing_queue_data_threshold = 50*1024*1024; 1690 MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st); 1691 1692 MATCH_PER_STREAM_OPT(bits_per_raw_sample, i, ost->bits_per_raw_sample, 1693 oc, st); 1694 1695 if (oc->oformat->flags & AVFMT_GLOBALHEADER) 1696 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER; 1697 1698 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0); 1699 1700 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0); 1701 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24) 1702 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0); 1703 1704 ost->source_index = source_index; 1705 if (source_index >= 0) { 1706 ost->sync_ist = input_streams[source_index]; 1707 input_streams[source_index]->discard = 0; 1708 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard; 1709 } 1710 ost->last_mux_dts = AV_NOPTS_VALUE; 1711 1712 ost->muxing_queue = av_fifo_alloc2(8, sizeof(AVPacket*), 0); 1713 if (!ost->muxing_queue) 1714 exit_program(1); 1715 1716 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, 1717 ost->copy_initial_nonkeyframes, oc, st); 1718 1719 return ost; 1720} 1721 1722static void parse_matrix_coeffs(uint16_t *dest, const char *str) 1723{ 1724 int i; 1725 const char *p = str; 1726 for (i = 0;; i++) { 1727 dest[i] = atoi(p); 1728 if (i == 63) 1729 break; 1730 p = strchr(p, ','); 1731 if (!p) { 1732 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i); 1733 exit_program(1); 1734 } 1735 p++; 1736 } 1737} 1738 1739/* read file contents into a string */ 1740static char *read_file(const char *filename) 1741{ 1742 AVIOContext *pb = NULL; 1743 int ret = avio_open(&pb, filename, AVIO_FLAG_READ); 1744 AVBPrint bprint; 1745 char *str; 1746 1747 if (ret < 0) { 1748 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename); 1749 return NULL; 1750 } 1751 1752 av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED); 1753 ret = avio_read_to_bprint(pb, &bprint, SIZE_MAX); 1754 avio_closep(&pb); 1755 if (ret < 0) { 1756 av_bprint_finalize(&bprint, NULL); 1757 return NULL; 1758 } 1759 ret = av_bprint_finalize(&bprint, &str); 1760 if (ret < 0) 1761 return NULL; 1762 return str; 1763} 1764 1765static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc, 1766 OutputStream *ost) 1767{ 1768 AVStream *st = ost->st; 1769 1770 if (ost->filters_script && ost->filters) { 1771 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for " 1772 "output stream #%d:%d.\n", nb_output_files, st->index); 1773 exit_program(1); 1774 } 1775 1776 if (ost->filters_script) 1777 return read_file(ost->filters_script); 1778 else if (ost->filters) 1779 return av_strdup(ost->filters); 1780 1781 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ? 1782 "null" : "anull"); 1783} 1784 1785static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc, 1786 const OutputStream *ost, enum AVMediaType type) 1787{ 1788 if (ost->filters_script || ost->filters) { 1789 av_log(NULL, AV_LOG_ERROR, 1790 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n" 1791 "Filtering and streamcopy cannot be used together.\n", 1792 ost->filters ? "Filtergraph" : "Filtergraph script", 1793 ost->filters ? ost->filters : ost->filters_script, 1794 av_get_media_type_string(type), ost->file_index, ost->index); 1795 exit_program(1); 1796 } 1797} 1798 1799static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index) 1800{ 1801 AVStream *st; 1802 OutputStream *ost; 1803 AVCodecContext *video_enc; 1804 char *frame_rate = NULL, *max_frame_rate = NULL, *frame_aspect_ratio = NULL; 1805 1806 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index); 1807 st = ost->st; 1808 video_enc = ost->enc_ctx; 1809 1810 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st); 1811 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) { 1812 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate); 1813 exit_program(1); 1814 } 1815 1816 MATCH_PER_STREAM_OPT(max_frame_rates, str, max_frame_rate, oc, st); 1817 if (max_frame_rate && av_parse_video_rate(&ost->max_frame_rate, max_frame_rate) < 0) { 1818 av_log(NULL, AV_LOG_FATAL, "Invalid maximum framerate value: %s\n", max_frame_rate); 1819 exit_program(1); 1820 } 1821 1822 if (frame_rate && max_frame_rate) { 1823 av_log(NULL, AV_LOG_ERROR, "Only one of -fpsmax and -r can be set for a stream.\n"); 1824 exit_program(1); 1825 } 1826 1827 if ((frame_rate || max_frame_rate) && 1828 video_sync_method == VSYNC_PASSTHROUGH) 1829 av_log(NULL, AV_LOG_ERROR, "Using -vsync passthrough and -r/-fpsmax can produce invalid output files\n"); 1830 1831 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st); 1832 if (frame_aspect_ratio) { 1833 AVRational q; 1834 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 || 1835 q.num <= 0 || q.den <= 0) { 1836 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio); 1837 exit_program(1); 1838 } 1839 ost->frame_aspect_ratio = q; 1840 } 1841 1842 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st); 1843 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st); 1844 1845 if (!ost->stream_copy) { 1846 const char *p = NULL; 1847 char *frame_size = NULL; 1848 char *frame_pix_fmt = NULL; 1849 char *intra_matrix = NULL, *inter_matrix = NULL; 1850 char *chroma_intra_matrix = NULL; 1851 int do_pass = 0; 1852 int i; 1853 1854 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st); 1855 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) { 1856 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size); 1857 exit_program(1); 1858 } 1859 1860 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st); 1861 if (frame_pix_fmt && *frame_pix_fmt == '+') { 1862 ost->keep_pix_fmt = 1; 1863 if (!*++frame_pix_fmt) 1864 frame_pix_fmt = NULL; 1865 } 1866 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) { 1867 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt); 1868 exit_program(1); 1869 } 1870 st->sample_aspect_ratio = video_enc->sample_aspect_ratio; 1871 1872 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st); 1873 if (intra_matrix) { 1874 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) { 1875 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n"); 1876 exit_program(1); 1877 } 1878 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix); 1879 } 1880 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st); 1881 if (chroma_intra_matrix) { 1882 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64); 1883 if (!p) { 1884 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n"); 1885 exit_program(1); 1886 } 1887 video_enc->chroma_intra_matrix = p; 1888 parse_matrix_coeffs(p, chroma_intra_matrix); 1889 } 1890 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st); 1891 if (inter_matrix) { 1892 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) { 1893 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n"); 1894 exit_program(1); 1895 } 1896 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix); 1897 } 1898 1899 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st); 1900 for (i = 0; p; i++) { 1901 int start, end, q; 1902 int e = sscanf(p, "%d,%d,%d", &start, &end, &q); 1903 if (e != 3) { 1904 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n"); 1905 exit_program(1); 1906 } 1907 video_enc->rc_override = 1908 av_realloc_array(video_enc->rc_override, 1909 i + 1, sizeof(RcOverride)); 1910 if (!video_enc->rc_override) { 1911 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n"); 1912 exit_program(1); 1913 } 1914 video_enc->rc_override[i].start_frame = start; 1915 video_enc->rc_override[i].end_frame = end; 1916 if (q > 0) { 1917 video_enc->rc_override[i].qscale = q; 1918 video_enc->rc_override[i].quality_factor = 1.0; 1919 } 1920 else { 1921 video_enc->rc_override[i].qscale = 0; 1922 video_enc->rc_override[i].quality_factor = -q/100.0; 1923 } 1924 p = strchr(p, '/'); 1925 if (p) p++; 1926 } 1927 video_enc->rc_override_count = i; 1928 1929 if (do_psnr) 1930 video_enc->flags|= AV_CODEC_FLAG_PSNR; 1931 1932 /* two pass mode */ 1933 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st); 1934 if (do_pass) { 1935 if (do_pass & 1) { 1936 video_enc->flags |= AV_CODEC_FLAG_PASS1; 1937 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND); 1938 } 1939 if (do_pass & 2) { 1940 video_enc->flags |= AV_CODEC_FLAG_PASS2; 1941 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND); 1942 } 1943 } 1944 1945 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st); 1946 if (ost->logfile_prefix && 1947 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix))) 1948 exit_program(1); 1949 1950 if (do_pass) { 1951 char logfilename[1024]; 1952 FILE *f; 1953 1954 snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 1955 ost->logfile_prefix ? ost->logfile_prefix : 1956 DEFAULT_PASS_LOGFILENAME_PREFIX, 1957 nb_output_streams - 1); 1958 if (!strcmp(ost->enc->name, "libx264")) { 1959 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE); 1960 } else { 1961 if (video_enc->flags & AV_CODEC_FLAG_PASS2) { 1962 char *logbuffer = read_file(logfilename); 1963 1964 if (!logbuffer) { 1965 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n", 1966 logfilename); 1967 exit_program(1); 1968 } 1969 video_enc->stats_in = logbuffer; 1970 } 1971 if (video_enc->flags & AV_CODEC_FLAG_PASS1) { 1972 f = fopen_utf8(logfilename, "wb"); 1973 if (!f) { 1974 av_log(NULL, AV_LOG_FATAL, 1975 "Cannot write log file '%s' for pass-1 encoding: %s\n", 1976 logfilename, strerror(errno)); 1977 exit_program(1); 1978 } 1979 ost->logfile = f; 1980 } 1981 } 1982 } 1983 1984 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st); 1985 if (ost->forced_keyframes) 1986 ost->forced_keyframes = av_strdup(ost->forced_keyframes); 1987 1988 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st); 1989 1990 ost->top_field_first = -1; 1991 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st); 1992 1993 ost->vsync_method = video_sync_method; 1994 MATCH_PER_STREAM_OPT(fps_mode, str, ost->fps_mode, oc, st); 1995 if (ost->fps_mode) 1996 parse_and_set_vsync(ost->fps_mode, &ost->vsync_method, ost->file_index, ost->index, 0); 1997 1998 if (ost->vsync_method == VSYNC_AUTO) { 1999 if (!strcmp(oc->oformat->name, "avi")) { 2000 ost->vsync_method = VSYNC_VFR; 2001 } else { 2002 ost->vsync_method = (oc->oformat->flags & AVFMT_VARIABLE_FPS) ? 2003 ((oc->oformat->flags & AVFMT_NOTIMESTAMPS) ? 2004 VSYNC_PASSTHROUGH : VSYNC_VFR) : 2005 VSYNC_CFR; 2006 } 2007 2008 if (ost->source_index >= 0 && ost->vsync_method == VSYNC_CFR) { 2009 const InputStream *ist = input_streams[ost->source_index]; 2010 const InputFile *ifile = input_files[ist->file_index]; 2011 2012 if (ifile->nb_streams == 1 && ifile->input_ts_offset == 0) 2013 ost->vsync_method = VSYNC_VSCFR; 2014 } 2015 2016 if (ost->vsync_method == VSYNC_CFR && copy_ts) { 2017 ost->vsync_method = VSYNC_VSCFR; 2018 } 2019 } 2020 ost->is_cfr = (ost->vsync_method == VSYNC_CFR || ost->vsync_method == VSYNC_VSCFR); 2021 2022 ost->avfilter = get_ost_filters(o, oc, ost); 2023 if (!ost->avfilter) 2024 exit_program(1); 2025 2026 ost->last_frame = av_frame_alloc(); 2027 if (!ost->last_frame) 2028 exit_program(1); 2029 } 2030 2031 if (ost->stream_copy) 2032 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO); 2033 2034 return ost; 2035} 2036 2037static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index) 2038{ 2039 int n; 2040 AVStream *st; 2041 OutputStream *ost; 2042 AVCodecContext *audio_enc; 2043 2044 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index); 2045 st = ost->st; 2046 2047 audio_enc = ost->enc_ctx; 2048 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO; 2049 2050 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st); 2051 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st); 2052 2053 if (!ost->stream_copy) { 2054 int channels = 0; 2055 char *layout = NULL; 2056 char *sample_fmt = NULL; 2057 2058 MATCH_PER_STREAM_OPT(audio_channels, i, channels, oc, st); 2059 if (channels) { 2060 audio_enc->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC; 2061 audio_enc->ch_layout.nb_channels = channels; 2062 } 2063 2064 MATCH_PER_STREAM_OPT(audio_ch_layouts, str, layout, oc, st); 2065 if (layout) { 2066 if (av_channel_layout_from_string(&audio_enc->ch_layout, layout) < 0) { 2067#if FF_API_OLD_CHANNEL_LAYOUT 2068 uint64_t mask; 2069 AV_NOWARN_DEPRECATED({ 2070 mask = av_get_channel_layout(layout); 2071 }) 2072 if (!mask) { 2073#endif 2074 av_log(NULL, AV_LOG_FATAL, "Unknown channel layout: %s\n", layout); 2075 exit_program(1); 2076#if FF_API_OLD_CHANNEL_LAYOUT 2077 } 2078 av_log(NULL, AV_LOG_WARNING, "Channel layout '%s' uses a deprecated syntax.\n", 2079 layout); 2080 av_channel_layout_from_mask(&audio_enc->ch_layout, mask); 2081#endif 2082 } 2083 } 2084 2085 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st); 2086 if (sample_fmt && 2087 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) { 2088 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt); 2089 exit_program(1); 2090 } 2091 2092 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st); 2093 2094 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st); 2095 ost->apad = av_strdup(ost->apad); 2096 2097 ost->avfilter = get_ost_filters(o, oc, ost); 2098 if (!ost->avfilter) 2099 exit_program(1); 2100 2101 /* check for channel mapping for this audio stream */ 2102 for (n = 0; n < o->nb_audio_channel_maps; n++) { 2103 AudioChannelMap *map = &o->audio_channel_maps[n]; 2104 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) && 2105 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) { 2106 InputStream *ist; 2107 2108 if (map->channel_idx == -1) { 2109 ist = NULL; 2110 } else if (ost->source_index < 0) { 2111 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n", 2112 ost->file_index, ost->st->index); 2113 continue; 2114 } else { 2115 ist = input_streams[ost->source_index]; 2116 } 2117 2118 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) { 2119 if (av_reallocp_array(&ost->audio_channels_map, 2120 ost->audio_channels_mapped + 1, 2121 sizeof(*ost->audio_channels_map) 2122 ) < 0 ) 2123 exit_program(1); 2124 2125 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx; 2126 } 2127 } 2128 } 2129 } 2130 2131 if (ost->stream_copy) 2132 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO); 2133 2134 return ost; 2135} 2136 2137static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index) 2138{ 2139 OutputStream *ost; 2140 2141 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index); 2142 if (!ost->stream_copy) { 2143 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n"); 2144 exit_program(1); 2145 } 2146 2147 return ost; 2148} 2149 2150static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index) 2151{ 2152 OutputStream *ost; 2153 2154 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index); 2155 if (!ost->stream_copy) { 2156 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n"); 2157 exit_program(1); 2158 } 2159 2160 return ost; 2161} 2162 2163static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index) 2164{ 2165 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index); 2166 ost->stream_copy = 1; 2167 ost->finished = 1; 2168 return ost; 2169} 2170 2171static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index) 2172{ 2173 AVStream *st; 2174 OutputStream *ost; 2175 AVCodecContext *subtitle_enc; 2176 2177 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index); 2178 st = ost->st; 2179 subtitle_enc = ost->enc_ctx; 2180 2181 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE; 2182 2183 if (!ost->stream_copy) { 2184 char *frame_size = NULL; 2185 2186 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st); 2187 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) { 2188 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size); 2189 exit_program(1); 2190 } 2191 } 2192 2193 return ost; 2194} 2195 2196/* arg format is "output-stream-index:streamid-value". */ 2197static int opt_streamid(void *optctx, const char *opt, const char *arg) 2198{ 2199 OptionsContext *o = optctx; 2200 int idx; 2201 char *p; 2202 char idx_str[16]; 2203 2204 av_strlcpy(idx_str, arg, sizeof(idx_str)); 2205 p = strchr(idx_str, ':'); 2206 if (!p) { 2207 av_log(NULL, AV_LOG_FATAL, 2208 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n", 2209 arg, opt); 2210 exit_program(1); 2211 } 2212 *p++ = '\0'; 2213 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1); 2214 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1); 2215 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX); 2216 return 0; 2217} 2218 2219static int copy_chapters(InputFile *ifile, OutputFile *ofile, AVFormatContext *os, 2220 int copy_metadata) 2221{ 2222 AVFormatContext *is = ifile->ctx; 2223 AVChapter **tmp; 2224 int i; 2225 2226 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters)); 2227 if (!tmp) 2228 return AVERROR(ENOMEM); 2229 os->chapters = tmp; 2230 2231 for (i = 0; i < is->nb_chapters; i++) { 2232 AVChapter *in_ch = is->chapters[i], *out_ch; 2233 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time; 2234 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset, 2235 AV_TIME_BASE_Q, in_ch->time_base); 2236 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX : 2237 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base); 2238 2239 2240 if (in_ch->end < ts_off) 2241 continue; 2242 if (rt != INT64_MAX && in_ch->start > rt + ts_off) 2243 break; 2244 2245 out_ch = av_mallocz(sizeof(AVChapter)); 2246 if (!out_ch) 2247 return AVERROR(ENOMEM); 2248 2249 out_ch->id = in_ch->id; 2250 out_ch->time_base = in_ch->time_base; 2251 out_ch->start = FFMAX(0, in_ch->start - ts_off); 2252 out_ch->end = FFMIN(rt, in_ch->end - ts_off); 2253 2254 if (copy_metadata) 2255 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0); 2256 2257 os->chapters[os->nb_chapters++] = out_ch; 2258 } 2259 return 0; 2260} 2261 2262static int set_dispositions(OutputFile *of, AVFormatContext *ctx) 2263{ 2264 int nb_streams[AVMEDIA_TYPE_NB] = { 0 }; 2265 int have_default[AVMEDIA_TYPE_NB] = { 0 }; 2266 int have_manual = 0; 2267 2268 // first, copy the input dispositions 2269 for (int i = 0; i < ctx->nb_streams; i++) { 2270 OutputStream *ost = output_streams[of->ost_index + i]; 2271 2272 nb_streams[ost->st->codecpar->codec_type]++; 2273 2274 have_manual |= !!ost->disposition; 2275 2276 if (ost->source_index >= 0) { 2277 ost->st->disposition = input_streams[ost->source_index]->st->disposition; 2278 2279 if (ost->st->disposition & AV_DISPOSITION_DEFAULT) 2280 have_default[ost->st->codecpar->codec_type] = 1; 2281 } 2282 } 2283 2284 if (have_manual) { 2285 // process manually set dispositions - they override the above copy 2286 for (int i = 0; i < ctx->nb_streams; i++) { 2287 OutputStream *ost = output_streams[of->ost_index + i]; 2288 int ret; 2289 2290 if (!ost->disposition) 2291 continue; 2292 2293#if LIBAVFORMAT_VERSION_MAJOR >= 60 2294 ret = av_opt_set(ost->st, "disposition", ost->disposition, 0); 2295#else 2296 { 2297 const AVClass *class = av_stream_get_class(); 2298 const AVOption *o = av_opt_find(&class, "disposition", NULL, 0, AV_OPT_SEARCH_FAKE_OBJ); 2299 2300 av_assert0(o); 2301 ret = av_opt_eval_flags(&class, o, ost->disposition, &ost->st->disposition); 2302 } 2303#endif 2304 2305 if (ret < 0) 2306 return ret; 2307 } 2308 } else { 2309 // For each media type with more than one stream, find a suitable stream to 2310 // mark as default, unless one is already marked default. 2311 // "Suitable" means the first of that type, skipping attached pictures. 2312 for (int i = 0; i < ctx->nb_streams; i++) { 2313 OutputStream *ost = output_streams[of->ost_index + i]; 2314 enum AVMediaType type = ost->st->codecpar->codec_type; 2315 2316 if (nb_streams[type] < 2 || have_default[type] || 2317 ost->st->disposition & AV_DISPOSITION_ATTACHED_PIC) 2318 continue; 2319 2320 ost->st->disposition |= AV_DISPOSITION_DEFAULT; 2321 have_default[type] = 1; 2322 } 2323 } 2324 2325 return 0; 2326} 2327 2328static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, 2329 AVFormatContext *oc) 2330{ 2331 OutputStream *ost; 2332 2333 switch (ofilter->type) { 2334 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break; 2335 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break; 2336 default: 2337 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported " 2338 "currently.\n"); 2339 exit_program(1); 2340 } 2341 2342 ost->filter = ofilter; 2343 2344 ofilter->ost = ost; 2345 ofilter->format = -1; 2346 2347 if (ost->stream_copy) { 2348 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, " 2349 "which is fed from a complex filtergraph. Filtering and streamcopy " 2350 "cannot be used together.\n", ost->file_index, ost->index); 2351 exit_program(1); 2352 } 2353 2354 if (ost->avfilter && (ost->filters || ost->filters_script)) { 2355 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script"; 2356 av_log(NULL, AV_LOG_ERROR, 2357 "%s '%s' was specified through the %s option " 2358 "for output stream %d:%d, which is fed from a complex filtergraph.\n" 2359 "%s and -filter_complex cannot be used together for the same stream.\n", 2360 ost->filters ? "Filtergraph" : "Filtergraph script", 2361 ost->filters ? ost->filters : ost->filters_script, 2362 opt, ost->file_index, ost->index, opt); 2363 exit_program(1); 2364 } 2365 2366 avfilter_inout_free(&ofilter->out_tmp); 2367} 2368 2369static int init_complex_filters(void) 2370{ 2371 int i, ret = 0; 2372 2373 for (i = 0; i < nb_filtergraphs; i++) { 2374 ret = init_complex_filtergraph(filtergraphs[i]); 2375 if (ret < 0) 2376 return ret; 2377 } 2378 return 0; 2379} 2380 2381static void set_channel_layout(OutputFilter *f, OutputStream *ost) 2382{ 2383 int i, err; 2384 2385 if (ost->enc_ctx->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) { 2386 /* Pass the layout through for all orders but UNSPEC */ 2387 err = av_channel_layout_copy(&f->ch_layout, &ost->enc_ctx->ch_layout); 2388 if (err < 0) 2389 exit_program(1); 2390 return; 2391 } 2392 2393 /* Requested layout is of order UNSPEC */ 2394 if (!ost->enc->ch_layouts) { 2395 /* Use the default native layout for the requested amount of channels when the 2396 encoder doesn't have a list of supported layouts */ 2397 av_channel_layout_default(&f->ch_layout, ost->enc_ctx->ch_layout.nb_channels); 2398 return; 2399 } 2400 /* Encoder has a list of supported layouts. Pick the first layout in it with the 2401 same amount of channels as the requested layout */ 2402 for (i = 0; ost->enc->ch_layouts[i].nb_channels; i++) { 2403 if (ost->enc->ch_layouts[i].nb_channels == ost->enc_ctx->ch_layout.nb_channels) 2404 break; 2405 } 2406 if (ost->enc->ch_layouts[i].nb_channels) { 2407 /* Use it if one is found */ 2408 err = av_channel_layout_copy(&f->ch_layout, &ost->enc->ch_layouts[i]); 2409 if (err < 0) 2410 exit_program(1); 2411 return; 2412 } 2413 /* If no layout for the amount of channels requested was found, use the default 2414 native layout for it. */ 2415 av_channel_layout_default(&f->ch_layout, ost->enc_ctx->ch_layout.nb_channels); 2416} 2417 2418static int open_output_file(OptionsContext *o, const char *filename) 2419{ 2420 AVFormatContext *oc; 2421 int i, j, err; 2422 OutputFile *of; 2423 OutputStream *ost; 2424 InputStream *ist; 2425 AVDictionary *unused_opts = NULL; 2426 const AVDictionaryEntry *e = NULL; 2427 2428 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) { 2429 o->stop_time = INT64_MAX; 2430 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n"); 2431 } 2432 2433 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) { 2434 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time; 2435 if (o->stop_time <= start_time) { 2436 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n"); 2437 exit_program(1); 2438 } else { 2439 o->recording_time = o->stop_time - start_time; 2440 } 2441 } 2442 2443 of = ALLOC_ARRAY_ELEM(output_files, nb_output_files); 2444 2445 of->index = nb_output_files - 1; 2446 of->ost_index = nb_output_streams; 2447 of->recording_time = o->recording_time; 2448 of->start_time = o->start_time; 2449 of->limit_filesize = o->limit_filesize; 2450 of->shortest = o->shortest; 2451 av_dict_copy(&of->opts, o->g->format_opts, 0); 2452 2453 if (!strcmp(filename, "-")) 2454 filename = "pipe:"; 2455 2456 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename); 2457 if (!oc) { 2458 print_error(filename, err); 2459 exit_program(1); 2460 } 2461 2462 of->ctx = oc; 2463 of->format = oc->oformat; 2464 if (o->recording_time != INT64_MAX) 2465 oc->duration = o->recording_time; 2466 2467 oc->interrupt_callback = int_cb; 2468 2469 if (o->bitexact) { 2470 oc->flags |= AVFMT_FLAG_BITEXACT; 2471 } 2472 2473 /* create streams for all unlabeled output pads */ 2474 for (i = 0; i < nb_filtergraphs; i++) { 2475 FilterGraph *fg = filtergraphs[i]; 2476 for (j = 0; j < fg->nb_outputs; j++) { 2477 OutputFilter *ofilter = fg->outputs[j]; 2478 2479 if (!ofilter->out_tmp || ofilter->out_tmp->name) 2480 continue; 2481 2482 switch (ofilter->type) { 2483 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break; 2484 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break; 2485 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break; 2486 } 2487 init_output_filter(ofilter, o, oc); 2488 } 2489 } 2490 2491 if (!o->nb_stream_maps) { 2492 char *subtitle_codec_name = NULL; 2493 /* pick the "best" stream of each type */ 2494 2495 /* video: highest resolution */ 2496 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) { 2497 int best_score = 0, idx = -1; 2498 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0); 2499 for (j = 0; j < nb_input_files; j++) { 2500 InputFile *ifile = input_files[j]; 2501 int file_best_score = 0, file_best_idx = -1; 2502 for (i = 0; i < ifile->nb_streams; i++) { 2503 int score; 2504 ist = input_streams[ifile->ist_index + i]; 2505 score = ist->st->codecpar->width * ist->st->codecpar->height 2506 + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS) 2507 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT); 2508 if (ist->user_set_discard == AVDISCARD_ALL) 2509 continue; 2510 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC)) 2511 score = 1; 2512 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && 2513 score > file_best_score) { 2514 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC)) 2515 continue; 2516 file_best_score = score; 2517 file_best_idx = ifile->ist_index + i; 2518 } 2519 } 2520 if (file_best_idx >= 0) { 2521 if((qcr == MKTAG('A', 'P', 'I', 'C')) || !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC)) 2522 file_best_score -= 5000000*!!(input_streams[file_best_idx]->st->disposition & AV_DISPOSITION_DEFAULT); 2523 if (file_best_score > best_score) { 2524 best_score = file_best_score; 2525 idx = file_best_idx; 2526 } 2527 } 2528 } 2529 if (idx >= 0) 2530 new_video_stream(o, oc, idx); 2531 } 2532 2533 /* audio: most channels */ 2534 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) { 2535 int best_score = 0, idx = -1; 2536 for (j = 0; j < nb_input_files; j++) { 2537 InputFile *ifile = input_files[j]; 2538 int file_best_score = 0, file_best_idx = -1; 2539 for (i = 0; i < ifile->nb_streams; i++) { 2540 int score; 2541 ist = input_streams[ifile->ist_index + i]; 2542 score = ist->st->codecpar->ch_layout.nb_channels 2543 + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS) 2544 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT); 2545 if (ist->user_set_discard == AVDISCARD_ALL) 2546 continue; 2547 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && 2548 score > file_best_score) { 2549 file_best_score = score; 2550 file_best_idx = ifile->ist_index + i; 2551 } 2552 } 2553 if (file_best_idx >= 0) { 2554 file_best_score -= 5000000*!!(input_streams[file_best_idx]->st->disposition & AV_DISPOSITION_DEFAULT); 2555 if (file_best_score > best_score) { 2556 best_score = file_best_score; 2557 idx = file_best_idx; 2558 } 2559 } 2560 } 2561 if (idx >= 0) 2562 new_audio_stream(o, oc, idx); 2563 } 2564 2565 /* subtitles: pick first */ 2566 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s"); 2567 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) { 2568 for (i = 0; i < nb_input_streams; i++) 2569 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) { 2570 AVCodecDescriptor const *input_descriptor = 2571 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id); 2572 AVCodecDescriptor const *output_descriptor = NULL; 2573 AVCodec const *output_codec = 2574 avcodec_find_encoder(oc->oformat->subtitle_codec); 2575 int input_props = 0, output_props = 0; 2576 if (input_streams[i]->user_set_discard == AVDISCARD_ALL) 2577 continue; 2578 if (output_codec) 2579 output_descriptor = avcodec_descriptor_get(output_codec->id); 2580 if (input_descriptor) 2581 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB); 2582 if (output_descriptor) 2583 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB); 2584 if (subtitle_codec_name || 2585 input_props & output_props || 2586 // Map dvb teletext which has neither property to any output subtitle encoder 2587 input_descriptor && output_descriptor && 2588 (!input_descriptor->props || 2589 !output_descriptor->props)) { 2590 new_subtitle_stream(o, oc, i); 2591 break; 2592 } 2593 } 2594 } 2595 /* Data only if codec id match */ 2596 if (!o->data_disable ) { 2597 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA); 2598 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) { 2599 if (input_streams[i]->user_set_discard == AVDISCARD_ALL) 2600 continue; 2601 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA 2602 && input_streams[i]->st->codecpar->codec_id == codec_id ) 2603 new_data_stream(o, oc, i); 2604 } 2605 } 2606 } else { 2607 for (i = 0; i < o->nb_stream_maps; i++) { 2608 StreamMap *map = &o->stream_maps[i]; 2609 2610 if (map->disabled) 2611 continue; 2612 2613 if (map->linklabel) { 2614 FilterGraph *fg; 2615 OutputFilter *ofilter = NULL; 2616 int j, k; 2617 2618 for (j = 0; j < nb_filtergraphs; j++) { 2619 fg = filtergraphs[j]; 2620 for (k = 0; k < fg->nb_outputs; k++) { 2621 AVFilterInOut *out = fg->outputs[k]->out_tmp; 2622 if (out && !strcmp(out->name, map->linklabel)) { 2623 ofilter = fg->outputs[k]; 2624 goto loop_end; 2625 } 2626 } 2627 } 2628loop_end: 2629 if (!ofilter) { 2630 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist " 2631 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel); 2632 exit_program(1); 2633 } 2634 init_output_filter(ofilter, o, oc); 2635 } else { 2636 int src_idx = input_files[map->file_index]->ist_index + map->stream_index; 2637 2638 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index]; 2639 if (ist->user_set_discard == AVDISCARD_ALL) { 2640 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n", 2641 map->file_index, map->stream_index); 2642 exit_program(1); 2643 } 2644 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) 2645 continue; 2646 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) 2647 continue; 2648 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) 2649 continue; 2650 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA) 2651 continue; 2652 2653 ost = NULL; 2654 switch (ist->st->codecpar->codec_type) { 2655 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break; 2656 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break; 2657 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break; 2658 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break; 2659 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break; 2660 case AVMEDIA_TYPE_UNKNOWN: 2661 if (copy_unknown_streams) { 2662 ost = new_unknown_stream (o, oc, src_idx); 2663 break; 2664 } 2665 default: 2666 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL, 2667 "Cannot map stream #%d:%d - unsupported type.\n", 2668 map->file_index, map->stream_index); 2669 if (!ignore_unknown_streams) { 2670 av_log(NULL, AV_LOG_FATAL, 2671 "If you want unsupported types ignored instead " 2672 "of failing, please use the -ignore_unknown option\n" 2673 "If you want them copied, please use -copy_unknown\n"); 2674 exit_program(1); 2675 } 2676 } 2677 if (ost) 2678 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index 2679 + map->sync_stream_index]; 2680 } 2681 } 2682 } 2683 2684 /* handle attached files */ 2685 for (i = 0; i < o->nb_attachments; i++) { 2686 AVIOContext *pb; 2687 uint8_t *attachment; 2688 const char *p; 2689 int64_t len; 2690 2691 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) { 2692 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n", 2693 o->attachments[i]); 2694 exit_program(1); 2695 } 2696 if ((len = avio_size(pb)) <= 0) { 2697 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n", 2698 o->attachments[i]); 2699 exit_program(1); 2700 } 2701 if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE || 2702 !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) { 2703 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n", 2704 o->attachments[i]); 2705 exit_program(1); 2706 } 2707 avio_read(pb, attachment, len); 2708 memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE); 2709 2710 ost = new_attachment_stream(o, oc, -1); 2711 ost->stream_copy = 0; 2712 ost->attachment_filename = o->attachments[i]; 2713 ost->st->codecpar->extradata = attachment; 2714 ost->st->codecpar->extradata_size = len; 2715 2716 p = strrchr(o->attachments[i], '/'); 2717 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE); 2718 avio_closep(&pb); 2719 } 2720 2721 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) { 2722 av_dump_format(oc, nb_output_files - 1, oc->url, 1); 2723 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1); 2724 exit_program(1); 2725 } 2726 2727 /* check if all codec options have been used */ 2728 unused_opts = strip_specifiers(o->g->codec_opts); 2729 for (i = of->ost_index; i < nb_output_streams; i++) { 2730 e = NULL; 2731 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e, 2732 AV_DICT_IGNORE_SUFFIX))) 2733 av_dict_set(&unused_opts, e->key, NULL, 0); 2734 } 2735 2736 e = NULL; 2737 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) { 2738 const AVClass *class = avcodec_get_class(); 2739 const AVOption *option = av_opt_find(&class, e->key, NULL, 0, 2740 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ); 2741 const AVClass *fclass = avformat_get_class(); 2742 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0, 2743 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ); 2744 if (!option || foption) 2745 continue; 2746 2747 2748 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) { 2749 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for " 2750 "output file #%d (%s) is not an encoding option.\n", e->key, 2751 option->help ? option->help : "", nb_output_files - 1, 2752 filename); 2753 exit_program(1); 2754 } 2755 2756 // gop_timecode is injected by generic code but not always used 2757 if (!strcmp(e->key, "gop_timecode")) 2758 continue; 2759 2760 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for " 2761 "output file #%d (%s) has not been used for any stream. The most " 2762 "likely reason is either wrong type (e.g. a video option with " 2763 "no video streams) or that it is a private option of some encoder " 2764 "which was not actually used for any stream.\n", e->key, 2765 option->help ? option->help : "", nb_output_files - 1, filename); 2766 } 2767 av_dict_free(&unused_opts); 2768 2769 /* set the decoding_needed flags and create simple filtergraphs */ 2770 for (i = of->ost_index; i < nb_output_streams; i++) { 2771 OutputStream *ost = output_streams[i]; 2772 2773 if (ost->encoding_needed && ost->source_index >= 0) { 2774 InputStream *ist = input_streams[ost->source_index]; 2775 ist->decoding_needed |= DECODING_FOR_OST; 2776 ist->processing_needed = 1; 2777 2778 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO || 2779 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) { 2780 err = init_simple_filtergraph(ist, ost); 2781 if (err < 0) { 2782 av_log(NULL, AV_LOG_ERROR, 2783 "Error initializing a simple filtergraph between streams " 2784 "%d:%d->%d:%d\n", ist->file_index, ost->source_index, 2785 nb_output_files - 1, ost->st->index); 2786 exit_program(1); 2787 } 2788 } 2789 } else if (ost->stream_copy && ost->source_index >= 0) { 2790 InputStream *ist = input_streams[ost->source_index]; 2791 ist->processing_needed = 1; 2792 } 2793 2794 /* set the filter output constraints */ 2795 if (ost->filter) { 2796 OutputFilter *f = ost->filter; 2797 switch (ost->enc_ctx->codec_type) { 2798 case AVMEDIA_TYPE_VIDEO: 2799 f->frame_rate = ost->frame_rate; 2800 f->width = ost->enc_ctx->width; 2801 f->height = ost->enc_ctx->height; 2802 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) { 2803 f->format = ost->enc_ctx->pix_fmt; 2804 } else { 2805 f->formats = ost->enc->pix_fmts; 2806 } 2807 break; 2808 case AVMEDIA_TYPE_AUDIO: 2809 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) { 2810 f->format = ost->enc_ctx->sample_fmt; 2811 } else { 2812 f->formats = ost->enc->sample_fmts; 2813 } 2814 if (ost->enc_ctx->sample_rate) { 2815 f->sample_rate = ost->enc_ctx->sample_rate; 2816 } else { 2817 f->sample_rates = ost->enc->supported_samplerates; 2818 } 2819 if (ost->enc_ctx->ch_layout.nb_channels) { 2820 set_channel_layout(f, ost); 2821 } else if (ost->enc->ch_layouts) { 2822 f->ch_layouts = ost->enc->ch_layouts; 2823 } 2824 break; 2825 } 2826 } 2827 } 2828 2829 /* check filename in case of an image number is expected */ 2830 if (oc->oformat->flags & AVFMT_NEEDNUMBER) { 2831 if (!av_filename_number_test(oc->url)) { 2832 print_error(oc->url, AVERROR(EINVAL)); 2833 exit_program(1); 2834 } 2835 } 2836 2837 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) { 2838 av_log(NULL, AV_LOG_ERROR, 2839 "No input streams but output needs an input stream\n"); 2840 exit_program(1); 2841 } 2842 2843 if (!(oc->oformat->flags & AVFMT_NOFILE)) { 2844 /* test if it already exists to avoid losing precious files */ 2845 assert_file_overwrite(filename); 2846 2847 /* open the file */ 2848 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE, 2849 &oc->interrupt_callback, 2850 &of->opts)) < 0) { 2851 print_error(filename, err); 2852 exit_program(1); 2853 } 2854 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename)) 2855 assert_file_overwrite(filename); 2856 2857 if (o->mux_preload) { 2858 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0); 2859 } 2860 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE); 2861 2862 /* copy metadata */ 2863 for (i = 0; i < o->nb_metadata_map; i++) { 2864 char *p; 2865 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0); 2866 2867 if (in_file_index >= nb_input_files) { 2868 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index); 2869 exit_program(1); 2870 } 2871 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, 2872 in_file_index >= 0 ? 2873 input_files[in_file_index]->ctx : NULL, o); 2874 } 2875 2876 /* copy chapters */ 2877 if (o->chapters_input_file >= nb_input_files) { 2878 if (o->chapters_input_file == INT_MAX) { 2879 /* copy chapters from the first input file that has them*/ 2880 o->chapters_input_file = -1; 2881 for (i = 0; i < nb_input_files; i++) 2882 if (input_files[i]->ctx->nb_chapters) { 2883 o->chapters_input_file = i; 2884 break; 2885 } 2886 } else { 2887 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n", 2888 o->chapters_input_file); 2889 exit_program(1); 2890 } 2891 } 2892 if (o->chapters_input_file >= 0) 2893 copy_chapters(input_files[o->chapters_input_file], of, oc, 2894 !o->metadata_chapters_manual); 2895 2896 /* copy global metadata by default */ 2897 if (!o->metadata_global_manual && nb_input_files){ 2898 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata, 2899 AV_DICT_DONT_OVERWRITE); 2900 if(o->recording_time != INT64_MAX) 2901 av_dict_set(&oc->metadata, "duration", NULL, 0); 2902 av_dict_set(&oc->metadata, "creation_time", NULL, 0); 2903 av_dict_set(&oc->metadata, "company_name", NULL, 0); 2904 av_dict_set(&oc->metadata, "product_name", NULL, 0); 2905 av_dict_set(&oc->metadata, "product_version", NULL, 0); 2906 } 2907 if (!o->metadata_streams_manual) 2908 for (i = of->ost_index; i < nb_output_streams; i++) { 2909 InputStream *ist; 2910 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */ 2911 continue; 2912 ist = input_streams[output_streams[i]->source_index]; 2913 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE); 2914 if (!output_streams[i]->stream_copy) { 2915 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0); 2916 } 2917 } 2918 2919 /* process manually set programs */ 2920 for (i = 0; i < o->nb_program; i++) { 2921 const char *p = o->program[i].u.str; 2922 int progid = i+1; 2923 AVProgram *program; 2924 2925 while(*p) { 2926 const char *p2 = av_get_token(&p, ":"); 2927 const char *to_dealloc = p2; 2928 char *key; 2929 if (!p2) 2930 break; 2931 2932 if(*p) p++; 2933 2934 key = av_get_token(&p2, "="); 2935 if (!key || !*p2) { 2936 av_freep(&to_dealloc); 2937 av_freep(&key); 2938 break; 2939 } 2940 p2++; 2941 2942 if (!strcmp(key, "program_num")) 2943 progid = strtol(p2, NULL, 0); 2944 av_freep(&to_dealloc); 2945 av_freep(&key); 2946 } 2947 2948 program = av_new_program(oc, progid); 2949 2950 p = o->program[i].u.str; 2951 while(*p) { 2952 const char *p2 = av_get_token(&p, ":"); 2953 const char *to_dealloc = p2; 2954 char *key; 2955 if (!p2) 2956 break; 2957 if(*p) p++; 2958 2959 key = av_get_token(&p2, "="); 2960 if (!key) { 2961 av_log(NULL, AV_LOG_FATAL, 2962 "No '=' character in program string %s.\n", 2963 p2); 2964 exit_program(1); 2965 } 2966 if (!*p2) 2967 exit_program(1); 2968 p2++; 2969 2970 if (!strcmp(key, "title")) { 2971 av_dict_set(&program->metadata, "title", p2, 0); 2972 } else if (!strcmp(key, "program_num")) { 2973 } else if (!strcmp(key, "st")) { 2974 int st_num = strtol(p2, NULL, 0); 2975 av_program_add_stream_index(oc, progid, st_num); 2976 } else { 2977 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key); 2978 exit_program(1); 2979 } 2980 av_freep(&to_dealloc); 2981 av_freep(&key); 2982 } 2983 } 2984 2985 /* process manually set metadata */ 2986 for (i = 0; i < o->nb_metadata; i++) { 2987 AVDictionary **m; 2988 char type, *val; 2989 const char *stream_spec; 2990 int index = 0, j, ret = 0; 2991 2992 val = strchr(o->metadata[i].u.str, '='); 2993 if (!val) { 2994 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n", 2995 o->metadata[i].u.str); 2996 exit_program(1); 2997 } 2998 *val++ = 0; 2999 3000 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec); 3001 if (type == 's') { 3002 for (j = 0; j < oc->nb_streams; j++) { 3003 ost = output_streams[nb_output_streams - oc->nb_streams + j]; 3004 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) { 3005 if (!strcmp(o->metadata[i].u.str, "rotate")) { 3006 char *tail; 3007 double theta = av_strtod(val, &tail); 3008 if (!*tail) { 3009 ost->rotate_overridden = 1; 3010 ost->rotate_override_value = theta; 3011 } 3012 } else { 3013 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0); 3014 } 3015 } else if (ret < 0) 3016 exit_program(1); 3017 } 3018 } 3019 else { 3020 switch (type) { 3021 case 'g': 3022 m = &oc->metadata; 3023 break; 3024 case 'c': 3025 if (index < 0 || index >= oc->nb_chapters) { 3026 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index); 3027 exit_program(1); 3028 } 3029 m = &oc->chapters[index]->metadata; 3030 break; 3031 case 'p': 3032 if (index < 0 || index >= oc->nb_programs) { 3033 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index); 3034 exit_program(1); 3035 } 3036 m = &oc->programs[index]->metadata; 3037 break; 3038 default: 3039 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier); 3040 exit_program(1); 3041 } 3042 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0); 3043 } 3044 } 3045 3046 err = set_dispositions(of, oc); 3047 if (err < 0) { 3048 av_log(NULL, AV_LOG_FATAL, "Error setting output stream dispositions\n"); 3049 exit_program(1); 3050 } 3051 3052 return 0; 3053} 3054 3055static int opt_target(void *optctx, const char *opt, const char *arg) 3056{ 3057 OptionsContext *o = optctx; 3058 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN; 3059 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" }; 3060 3061 if (!strncmp(arg, "pal-", 4)) { 3062 norm = PAL; 3063 arg += 4; 3064 } else if (!strncmp(arg, "ntsc-", 5)) { 3065 norm = NTSC; 3066 arg += 5; 3067 } else if (!strncmp(arg, "film-", 5)) { 3068 norm = FILM; 3069 arg += 5; 3070 } else { 3071 /* Try to determine PAL/NTSC by peeking in the input files */ 3072 if (nb_input_files) { 3073 int i, j; 3074 for (j = 0; j < nb_input_files; j++) { 3075 for (i = 0; i < input_files[j]->nb_streams; i++) { 3076 AVStream *st = input_files[j]->ctx->streams[i]; 3077 int64_t fr; 3078 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) 3079 continue; 3080 fr = st->time_base.den * 1000LL / st->time_base.num; 3081 if (fr == 25000) { 3082 norm = PAL; 3083 break; 3084 } else if ((fr == 29970) || (fr == 23976)) { 3085 norm = NTSC; 3086 break; 3087 } 3088 } 3089 if (norm != UNKNOWN) 3090 break; 3091 } 3092 } 3093 if (norm != UNKNOWN) 3094 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC"); 3095 } 3096 3097 if (norm == UNKNOWN) { 3098 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n"); 3099 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n"); 3100 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n"); 3101 exit_program(1); 3102 } 3103 3104 if (!strcmp(arg, "vcd")) { 3105 opt_video_codec(o, "c:v", "mpeg1video"); 3106 opt_audio_codec(o, "c:a", "mp2"); 3107 parse_option(o, "f", "vcd", options); 3108 3109 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options); 3110 parse_option(o, "r", frame_rates[norm], options); 3111 opt_default(NULL, "g", norm == PAL ? "15" : "18"); 3112 3113 opt_default(NULL, "b:v", "1150000"); 3114 opt_default(NULL, "maxrate:v", "1150000"); 3115 opt_default(NULL, "minrate:v", "1150000"); 3116 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8; 3117 3118 opt_default(NULL, "b:a", "224000"); 3119 parse_option(o, "ar", "44100", options); 3120 parse_option(o, "ac", "2", options); 3121 3122 opt_default(NULL, "packetsize", "2324"); 3123 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8; 3124 3125 /* We have to offset the PTS, so that it is consistent with the SCR. 3126 SCR starts at 36000, but the first two packs contain only padding 3127 and the first pack from the other stream, respectively, may also have 3128 been written before. 3129 So the real data starts at SCR 36000+3*1200. */ 3130 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44 3131 } else if (!strcmp(arg, "svcd")) { 3132 3133 opt_video_codec(o, "c:v", "mpeg2video"); 3134 opt_audio_codec(o, "c:a", "mp2"); 3135 parse_option(o, "f", "svcd", options); 3136 3137 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options); 3138 parse_option(o, "r", frame_rates[norm], options); 3139 parse_option(o, "pix_fmt", "yuv420p", options); 3140 opt_default(NULL, "g", norm == PAL ? "15" : "18"); 3141 3142 opt_default(NULL, "b:v", "2040000"); 3143 opt_default(NULL, "maxrate:v", "2516000"); 3144 opt_default(NULL, "minrate:v", "0"); // 1145000; 3145 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8; 3146 opt_default(NULL, "scan_offset", "1"); 3147 3148 opt_default(NULL, "b:a", "224000"); 3149 parse_option(o, "ar", "44100", options); 3150 3151 opt_default(NULL, "packetsize", "2324"); 3152 3153 } else if (!strcmp(arg, "dvd")) { 3154 3155 opt_video_codec(o, "c:v", "mpeg2video"); 3156 opt_audio_codec(o, "c:a", "ac3"); 3157 parse_option(o, "f", "dvd", options); 3158 3159 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options); 3160 parse_option(o, "r", frame_rates[norm], options); 3161 parse_option(o, "pix_fmt", "yuv420p", options); 3162 opt_default(NULL, "g", norm == PAL ? "15" : "18"); 3163 3164 opt_default(NULL, "b:v", "6000000"); 3165 opt_default(NULL, "maxrate:v", "9000000"); 3166 opt_default(NULL, "minrate:v", "0"); // 1500000; 3167 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8; 3168 3169 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack. 3170 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8 3171 3172 opt_default(NULL, "b:a", "448000"); 3173 parse_option(o, "ar", "48000", options); 3174 3175 } else if (!strncmp(arg, "dv", 2)) { 3176 3177 parse_option(o, "f", "dv", options); 3178 3179 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options); 3180 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" : 3181 norm == PAL ? "yuv420p" : "yuv411p", options); 3182 parse_option(o, "r", frame_rates[norm], options); 3183 3184 parse_option(o, "ar", "48000", options); 3185 parse_option(o, "ac", "2", options); 3186 3187 } else { 3188 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg); 3189 return AVERROR(EINVAL); 3190 } 3191 3192 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE); 3193 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE); 3194 3195 return 0; 3196} 3197 3198static int opt_vstats_file(void *optctx, const char *opt, const char *arg) 3199{ 3200 av_free (vstats_filename); 3201 vstats_filename = av_strdup (arg); 3202 return 0; 3203} 3204 3205static int opt_vstats(void *optctx, const char *opt, const char *arg) 3206{ 3207 char filename[40]; 3208 time_t today2 = time(NULL); 3209 struct tm *today = localtime(&today2); 3210 3211 if (!today) { // maybe tomorrow 3212 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno)); 3213 exit_program(1); 3214 } 3215 3216 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min, 3217 today->tm_sec); 3218 return opt_vstats_file(NULL, opt, filename); 3219} 3220 3221static int opt_video_frames(void *optctx, const char *opt, const char *arg) 3222{ 3223 OptionsContext *o = optctx; 3224 return parse_option(o, "frames:v", arg, options); 3225} 3226 3227static int opt_audio_frames(void *optctx, const char *opt, const char *arg) 3228{ 3229 OptionsContext *o = optctx; 3230 return parse_option(o, "frames:a", arg, options); 3231} 3232 3233static int opt_data_frames(void *optctx, const char *opt, const char *arg) 3234{ 3235 OptionsContext *o = optctx; 3236 return parse_option(o, "frames:d", arg, options); 3237} 3238 3239static int opt_default_new(OptionsContext *o, const char *opt, const char *arg) 3240{ 3241 int ret; 3242 AVDictionary *cbak = codec_opts; 3243 AVDictionary *fbak = format_opts; 3244 codec_opts = NULL; 3245 format_opts = NULL; 3246 3247 ret = opt_default(NULL, opt, arg); 3248 3249 av_dict_copy(&o->g->codec_opts , codec_opts, 0); 3250 av_dict_copy(&o->g->format_opts, format_opts, 0); 3251 av_dict_free(&codec_opts); 3252 av_dict_free(&format_opts); 3253 codec_opts = cbak; 3254 format_opts = fbak; 3255 3256 return ret; 3257} 3258 3259static int opt_preset(void *optctx, const char *opt, const char *arg) 3260{ 3261 OptionsContext *o = optctx; 3262 FILE *f=NULL; 3263 char filename[1000], line[1000], tmp_line[1000]; 3264 const char *codec_name = NULL; 3265 3266 tmp_line[0] = *opt; 3267 tmp_line[1] = 0; 3268 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line); 3269 3270 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) { 3271 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){ 3272 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n"); 3273 }else 3274 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg); 3275 exit_program(1); 3276 } 3277 3278 while (fgets(line, sizeof(line), f)) { 3279 char *key = tmp_line, *value, *endptr; 3280 3281 if (strcspn(line, "#\n\r") == 0) 3282 continue; 3283 av_strlcpy(tmp_line, line, sizeof(tmp_line)); 3284 if (!av_strtok(key, "=", &value) || 3285 !av_strtok(value, "\r\n", &endptr)) { 3286 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line); 3287 exit_program(1); 3288 } 3289 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value); 3290 3291 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value); 3292 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value); 3293 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value); 3294 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value); 3295 else if (opt_default_new(o, key, value) < 0) { 3296 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", 3297 filename, line, key, value); 3298 exit_program(1); 3299 } 3300 } 3301 3302 fclose(f); 3303 3304 return 0; 3305} 3306 3307static int opt_old2new(void *optctx, const char *opt, const char *arg) 3308{ 3309 OptionsContext *o = optctx; 3310 int ret; 3311 char *s = av_asprintf("%s:%c", opt + 1, *opt); 3312 if (!s) 3313 return AVERROR(ENOMEM); 3314 ret = parse_option(o, s, arg, options); 3315 av_free(s); 3316 return ret; 3317} 3318 3319static int opt_bitrate(void *optctx, const char *opt, const char *arg) 3320{ 3321 OptionsContext *o = optctx; 3322 3323 if(!strcmp(opt, "ab")){ 3324 av_dict_set(&o->g->codec_opts, "b:a", arg, 0); 3325 return 0; 3326 } else if(!strcmp(opt, "b")){ 3327 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n"); 3328 av_dict_set(&o->g->codec_opts, "b:v", arg, 0); 3329 return 0; 3330 } 3331 av_dict_set(&o->g->codec_opts, opt, arg, 0); 3332 return 0; 3333} 3334 3335static int opt_qscale(void *optctx, const char *opt, const char *arg) 3336{ 3337 OptionsContext *o = optctx; 3338 char *s; 3339 int ret; 3340 if(!strcmp(opt, "qscale")){ 3341 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n"); 3342 return parse_option(o, "q:v", arg, options); 3343 } 3344 s = av_asprintf("q%s", opt + 6); 3345 if (!s) 3346 return AVERROR(ENOMEM); 3347 ret = parse_option(o, s, arg, options); 3348 av_free(s); 3349 return ret; 3350} 3351 3352static int opt_profile(void *optctx, const char *opt, const char *arg) 3353{ 3354 OptionsContext *o = optctx; 3355 if(!strcmp(opt, "profile")){ 3356 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n"); 3357 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0); 3358 return 0; 3359 } 3360 av_dict_set(&o->g->codec_opts, opt, arg, 0); 3361 return 0; 3362} 3363 3364static int opt_video_filters(void *optctx, const char *opt, const char *arg) 3365{ 3366 OptionsContext *o = optctx; 3367 return parse_option(o, "filter:v", arg, options); 3368} 3369 3370static int opt_audio_filters(void *optctx, const char *opt, const char *arg) 3371{ 3372 OptionsContext *o = optctx; 3373 return parse_option(o, "filter:a", arg, options); 3374} 3375 3376static int opt_vsync(void *optctx, const char *opt, const char *arg) 3377{ 3378 av_log(NULL, AV_LOG_WARNING, "-vsync is deprecated. Use -fps_mode\n"); 3379 parse_and_set_vsync(arg, &video_sync_method, -1, -1, 1); 3380 return 0; 3381} 3382 3383static int opt_timecode(void *optctx, const char *opt, const char *arg) 3384{ 3385 OptionsContext *o = optctx; 3386 int ret; 3387 char *tcr = av_asprintf("timecode=%s", arg); 3388 if (!tcr) 3389 return AVERROR(ENOMEM); 3390 ret = parse_option(o, "metadata:g", tcr, options); 3391 if (ret >= 0) 3392 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0); 3393 av_free(tcr); 3394 return ret; 3395} 3396 3397static int opt_audio_qscale(void *optctx, const char *opt, const char *arg) 3398{ 3399 OptionsContext *o = optctx; 3400 return parse_option(o, "q:a", arg, options); 3401} 3402 3403static int opt_filter_complex(void *optctx, const char *opt, const char *arg) 3404{ 3405 FilterGraph *fg = ALLOC_ARRAY_ELEM(filtergraphs, nb_filtergraphs); 3406 3407 fg->index = nb_filtergraphs - 1; 3408 fg->graph_desc = av_strdup(arg); 3409 if (!fg->graph_desc) 3410 return AVERROR(ENOMEM); 3411 3412 input_stream_potentially_available = 1; 3413 3414 return 0; 3415} 3416 3417static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg) 3418{ 3419 FilterGraph *fg; 3420 char *graph_desc = read_file(arg); 3421 if (!graph_desc) 3422 return AVERROR(EINVAL); 3423 3424 fg = ALLOC_ARRAY_ELEM(filtergraphs, nb_filtergraphs); 3425 fg->index = nb_filtergraphs - 1; 3426 fg->graph_desc = graph_desc; 3427 3428 input_stream_potentially_available = 1; 3429 3430 return 0; 3431} 3432 3433void show_help_default(const char *opt, const char *arg) 3434{ 3435 /* per-file options have at least one of those set */ 3436 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE; 3437 int show_advanced = 0, show_avoptions = 0; 3438 3439 if (opt && *opt) { 3440 if (!strcmp(opt, "long")) 3441 show_advanced = 1; 3442 else if (!strcmp(opt, "full")) 3443 show_advanced = show_avoptions = 1; 3444 else 3445 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt); 3446 } 3447 3448 show_usage(); 3449 3450 printf("Getting help:\n" 3451 " -h -- print basic options\n" 3452 " -h long -- print more options\n" 3453 " -h full -- print all options (including all format and codec specific options, very long)\n" 3454 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n" 3455 " See man %s for detailed description of the options.\n" 3456 "\n", program_name); 3457 3458 show_help_options(options, "Print help / information / capabilities:", 3459 OPT_EXIT, 0, 0); 3460 3461 show_help_options(options, "Global options (affect whole program " 3462 "instead of just one file):", 3463 0, per_file | OPT_EXIT | OPT_EXPERT, 0); 3464 if (show_advanced) 3465 show_help_options(options, "Advanced global options:", OPT_EXPERT, 3466 per_file | OPT_EXIT, 0); 3467 3468 show_help_options(options, "Per-file main options:", 0, 3469 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | 3470 OPT_EXIT, per_file); 3471 if (show_advanced) 3472 show_help_options(options, "Advanced per-file options:", 3473 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file); 3474 3475 show_help_options(options, "Video options:", 3476 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0); 3477 if (show_advanced) 3478 show_help_options(options, "Advanced Video options:", 3479 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0); 3480 3481 show_help_options(options, "Audio options:", 3482 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0); 3483 if (show_advanced) 3484 show_help_options(options, "Advanced Audio options:", 3485 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0); 3486 show_help_options(options, "Subtitle options:", 3487 OPT_SUBTITLE, 0, 0); 3488 printf("\n"); 3489 3490 if (show_avoptions) { 3491 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM; 3492 show_help_children(avcodec_get_class(), flags); 3493 show_help_children(avformat_get_class(), flags); 3494#if CONFIG_SWSCALE 3495 show_help_children(sws_get_class(), flags); 3496#endif 3497#if CONFIG_SWRESAMPLE 3498 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM); 3499#endif 3500 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM); 3501 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM); 3502 } 3503} 3504 3505void show_usage(void) 3506{ 3507 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n"); 3508 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name); 3509 av_log(NULL, AV_LOG_INFO, "\n"); 3510} 3511 3512enum OptGroup { 3513 GROUP_OUTFILE, 3514 GROUP_INFILE, 3515}; 3516 3517static const OptionGroupDef groups[] = { 3518 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT }, 3519 [GROUP_INFILE] = { "input url", "i", OPT_INPUT }, 3520}; 3521 3522static int open_files(OptionGroupList *l, const char *inout, 3523 int (*open_file)(OptionsContext*, const char*)) 3524{ 3525 int i, ret; 3526 3527 for (i = 0; i < l->nb_groups; i++) { 3528 OptionGroup *g = &l->groups[i]; 3529 OptionsContext o; 3530 3531 init_options(&o); 3532 o.g = g; 3533 3534 ret = parse_optgroup(&o, g); 3535 if (ret < 0) { 3536 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file " 3537 "%s.\n", inout, g->arg); 3538 uninit_options(&o); 3539 return ret; 3540 } 3541 3542 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg); 3543 ret = open_file(&o, g->arg); 3544 uninit_options(&o); 3545 if (ret < 0) { 3546 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n", 3547 inout, g->arg); 3548 return ret; 3549 } 3550 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n"); 3551 } 3552 3553 return 0; 3554} 3555 3556int ffmpeg_parse_options(int argc, char **argv) 3557{ 3558 OptionParseContext octx; 3559 uint8_t error[128]; 3560 int ret; 3561 3562 memset(&octx, 0, sizeof(octx)); 3563 3564 /* split the commandline into an internal representation */ 3565 ret = split_commandline(&octx, argc, argv, options, groups, 3566 FF_ARRAY_ELEMS(groups)); 3567 if (ret < 0) { 3568 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: "); 3569 goto fail; 3570 } 3571 3572 /* apply global options */ 3573 ret = parse_optgroup(NULL, &octx.global_opts); 3574 if (ret < 0) { 3575 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: "); 3576 goto fail; 3577 } 3578 3579 /* configure terminal and setup signal handlers */ 3580 term_init(); 3581 3582 /* open input files */ 3583 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file); 3584 if (ret < 0) { 3585 av_log(NULL, AV_LOG_FATAL, "Error opening input files: "); 3586 goto fail; 3587 } 3588 3589 apply_sync_offsets(); 3590 3591 /* create the complex filtergraphs */ 3592 ret = init_complex_filters(); 3593 if (ret < 0) { 3594 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n"); 3595 goto fail; 3596 } 3597 3598 /* open output files */ 3599 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file); 3600 if (ret < 0) { 3601 av_log(NULL, AV_LOG_FATAL, "Error opening output files: "); 3602 goto fail; 3603 } 3604 3605 check_filter_outputs(); 3606 3607fail: 3608 uninit_parse_context(&octx); 3609 if (ret < 0) { 3610 av_strerror(ret, error, sizeof(error)); 3611 av_log(NULL, AV_LOG_FATAL, "%s\n", error); 3612 } 3613 return ret; 3614} 3615 3616static int opt_progress(void *optctx, const char *opt, const char *arg) 3617{ 3618 AVIOContext *avio = NULL; 3619 int ret; 3620 3621 if (!strcmp(arg, "-")) 3622 arg = "pipe:"; 3623 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL); 3624 if (ret < 0) { 3625 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n", 3626 arg, av_err2str(ret)); 3627 return ret; 3628 } 3629 progress_avio = avio; 3630 return 0; 3631} 3632 3633int opt_timelimit(void *optctx, const char *opt, const char *arg) 3634{ 3635#if HAVE_SETRLIMIT 3636 int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); 3637 struct rlimit rl = { lim, lim + 1 }; 3638 if (setrlimit(RLIMIT_CPU, &rl)) 3639 perror("setrlimit"); 3640#else 3641 av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt); 3642#endif 3643 return 0; 3644} 3645 3646#define OFFSET(x) offsetof(OptionsContext, x) 3647const OptionDef options[] = { 3648 /* main options */ 3649 CMDUTILS_COMMON_OPTIONS 3650 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET | 3651 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) }, 3652 "force format", "fmt" }, 3653 { "y", OPT_BOOL, { &file_overwrite }, 3654 "overwrite output files" }, 3655 { "n", OPT_BOOL, { &no_file_overwrite }, 3656 "never overwrite output files" }, 3657 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams }, 3658 "Ignore unknown stream types" }, 3659 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams }, 3660 "Copy unknown stream types" }, 3661 { "recast_media", OPT_BOOL | OPT_EXPERT, { &recast_media }, 3662 "allow recasting stream type in order to force a decoder of different media type" }, 3663 { "c", HAS_ARG | OPT_STRING | OPT_SPEC | 3664 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) }, 3665 "codec name", "codec" }, 3666 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC | 3667 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) }, 3668 "codec name", "codec" }, 3669 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC | 3670 OPT_OUTPUT, { .off = OFFSET(presets) }, 3671 "preset name", "preset" }, 3672 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE | 3673 OPT_OUTPUT, { .func_arg = opt_map }, 3674 "set input stream mapping", 3675 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" }, 3676 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel }, 3677 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" }, 3678 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC | 3679 OPT_OUTPUT, { .off = OFFSET(metadata_map) }, 3680 "set metadata information of outfile from infile", 3681 "outfile[,metadata]:infile[,metadata]" }, 3682 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET | 3683 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) }, 3684 "set chapters mapping", "input_file_index" }, 3685 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | 3686 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) }, 3687 "record or transcode \"duration\" seconds of audio/video", 3688 "duration" }, 3689 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) }, 3690 "record or transcode stop time", "time_stop" }, 3691 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) }, 3692 "set the limit file size in bytes", "limit_size" }, 3693 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET | 3694 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) }, 3695 "set the start time offset", "time_off" }, 3696 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET | 3697 OPT_INPUT, { .off = OFFSET(start_time_eof) }, 3698 "set the start time offset relative to EOF", "time_off" }, 3699 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET | 3700 OPT_INPUT, { .off = OFFSET(seek_timestamp) }, 3701 "enable/disable seeking by timestamp with -ss" }, 3702 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT | 3703 OPT_INPUT, { .off = OFFSET(accurate_seek) }, 3704 "enable/disable accurate seeking with -ss" }, 3705 { "isync", HAS_ARG | OPT_INT | OPT_OFFSET | 3706 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_sync_ref) }, 3707 "Indicate the input index for sync reference", "sync ref" }, 3708 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | 3709 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) }, 3710 "set the input ts offset", "time_off" }, 3711 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | 3712 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) }, 3713 "set the input ts scale", "scale" }, 3714 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp }, 3715 "set the recording timestamp ('now' to set the current time)", "time" }, 3716 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) }, 3717 "add metadata", "string=string" }, 3718 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) }, 3719 "add program with specified streams", "title=string:st=number..." }, 3720 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT | 3721 OPT_OUTPUT, { .func_arg = opt_data_frames }, 3722 "set the number of data frames to output", "number" }, 3723 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark }, 3724 "add timings for benchmarking" }, 3725 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all }, 3726 "add timings for each task" }, 3727 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress }, 3728 "write program-readable progress information", "url" }, 3729 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction }, 3730 "enable or disable interaction on standard input" }, 3731 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit }, 3732 "set max runtime in seconds in CPU user time", "limit" }, 3733 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump }, 3734 "dump each input packet" }, 3735 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump }, 3736 "when dumping packets, also dump the payload" }, 3737 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET | 3738 OPT_INPUT, { .off = OFFSET(rate_emu) }, 3739 "read input at native frame rate; equivalent to -readrate 1", "" }, 3740 { "readrate", HAS_ARG | OPT_FLOAT | OPT_OFFSET | 3741 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(readrate) }, 3742 "read input at specified rate", "speed" }, 3743 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target }, 3744 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" " 3745 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" }, 3746 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync }, 3747 "set video sync method globally; deprecated, use -fps_mode", "" }, 3748 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold }, 3749 "frame drop threshold", "" }, 3750 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method }, 3751 "audio sync method", "" }, 3752 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold }, 3753 "audio drift threshold", "threshold" }, 3754 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts }, 3755 "copy timestamps" }, 3756 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero }, 3757 "shift input timestamps to start at 0 when using copyts" }, 3758 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb }, 3759 "copy input stream time base when stream copying", "mode" }, 3760 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET | 3761 OPT_OUTPUT, { .off = OFFSET(shortest) }, 3762 "finish encoding within shortest input" }, 3763 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET | 3764 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) }, 3765 "bitexact mode" }, 3766 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC | 3767 OPT_OUTPUT, { .off = OFFSET(apad) }, 3768 "audio pad", "" }, 3769 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold }, 3770 "timestamp discontinuity delta threshold", "threshold" }, 3771 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold }, 3772 "timestamp error delta threshold", "threshold" }, 3773 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error }, 3774 "exit on error", "error" }, 3775 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on }, 3776 "abort on the specified condition flags", "flags" }, 3777 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC | 3778 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) }, 3779 "copy initial non-keyframes" }, 3780 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) }, 3781 "copy or discard frames before start time" }, 3782 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) }, 3783 "set the number of frames to output", "number" }, 3784 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | 3785 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) }, 3786 "force codec tag/fourcc", "fourcc/tag" }, 3787 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | 3788 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) }, 3789 "use fixed quality scale (VBR)", "q" }, 3790 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE | 3791 OPT_OUTPUT, { .func_arg = opt_qscale }, 3792 "use fixed quality scale (VBR)", "q" }, 3793 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile }, 3794 "set profile", "profile" }, 3795 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) }, 3796 "set stream filtergraph", "filter_graph" }, 3797 { "filter_threads", HAS_ARG, { .func_arg = opt_filter_threads }, 3798 "number of non-complex filter threads" }, 3799 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) }, 3800 "read stream filtergraph description from a file", "filename" }, 3801 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) }, 3802 "reinit filtergraph on input parameter changes", "" }, 3803 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex }, 3804 "create a complex filtergraph", "graph_description" }, 3805 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads }, 3806 "number of threads for -filter_complex" }, 3807 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex }, 3808 "create a complex filtergraph", "graph_description" }, 3809 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script }, 3810 "read complex filtergraph description from a file", "filename" }, 3811 { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT, { &auto_conversion_filters }, 3812 "enable automatic conversion filters globally" }, 3813 { "stats", OPT_BOOL, { &print_stats }, 3814 "print progress report during encoding", }, 3815 { "stats_period", HAS_ARG | OPT_EXPERT, { .func_arg = opt_stats_period }, 3816 "set the period at which ffmpeg updates stats and -progress output", "time" }, 3817 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT | 3818 OPT_OUTPUT, { .func_arg = opt_attach }, 3819 "add an attachment to the output file", "filename" }, 3820 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC | 3821 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) }, 3822 "extract an attachment into a file", "filename" }, 3823 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT | 3824 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" }, 3825 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts }, 3826 "print timestamp debugging info" }, 3827 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate }, 3828 "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" }, 3829 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC | 3830 OPT_INPUT, { .off = OFFSET(discard) }, 3831 "discard", "" }, 3832 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC | 3833 OPT_OUTPUT, { .off = OFFSET(disposition) }, 3834 "disposition", "" }, 3835 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT, 3836 { .off = OFFSET(thread_queue_size) }, 3837 "set the maximum number of queued packets from the demuxer" }, 3838 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info }, 3839 "read and decode the streams to fill missing information with heuristics" }, 3840 { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, 3841 { .off = OFFSET(bits_per_raw_sample) }, 3842 "set the number of bits per raw sample", "number" }, 3843 3844 /* video options */ 3845 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames }, 3846 "set the number of video frames to output", "number" }, 3847 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC | 3848 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) }, 3849 "set frame rate (Hz value, fraction or abbreviation)", "rate" }, 3850 { "fpsmax", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC | 3851 OPT_OUTPUT, { .off = OFFSET(max_frame_rates) }, 3852 "set max frame rate (Hz value, fraction or abbreviation)", "rate" }, 3853 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC | 3854 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) }, 3855 "set frame size (WxH or abbreviation)", "size" }, 3856 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC | 3857 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) }, 3858 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" }, 3859 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC | 3860 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) }, 3861 "set pixel format", "format" }, 3862 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) }, 3863 "disable video" }, 3864 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC | 3865 OPT_OUTPUT, { .off = OFFSET(rc_overrides) }, 3866 "rate control override for specific intervals", "override" }, 3867 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT | 3868 OPT_OUTPUT, { .func_arg = opt_video_codec }, 3869 "force video codec ('copy' to copy stream)", "codec" }, 3870 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode }, 3871 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" }, 3872 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) }, 3873 "select the pass number (1 to 3)", "n" }, 3874 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | 3875 OPT_OUTPUT, { .off = OFFSET(passlogfiles) }, 3876 "select two pass log file name prefix", "prefix" }, 3877 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr }, 3878 "calculate PSNR of compressed frames" }, 3879 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats }, 3880 "dump video coding statistics to file" }, 3881 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file }, 3882 "dump video coding statistics to file", "file" }, 3883 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version }, 3884 "Version of the vstats format to use."}, 3885 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters }, 3886 "set video filters", "filter_graph" }, 3887 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC | 3888 OPT_OUTPUT, { .off = OFFSET(intra_matrices) }, 3889 "specify intra matrix coeffs", "matrix" }, 3890 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC | 3891 OPT_OUTPUT, { .off = OFFSET(inter_matrices) }, 3892 "specify inter matrix coeffs", "matrix" }, 3893 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC | 3894 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) }, 3895 "specify intra matrix coeffs", "matrix" }, 3896 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC | 3897 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) }, 3898 "top=1/bottom=0/auto=-1 field first", "" }, 3899 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE | 3900 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new }, 3901 "force video tag/fourcc", "fourcc/tag" }, 3902 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist }, 3903 "show QP histogram" }, 3904 { "fps_mode", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | 3905 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(fps_mode) }, 3906 "set framerate mode for matching video streams; overrides vsync" }, 3907 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC | 3908 OPT_OUTPUT, { .off = OFFSET(force_fps) }, 3909 "force the selected framerate, disable the best supported framerate selection" }, 3910 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE | 3911 OPT_OUTPUT, { .func_arg = opt_streamid }, 3912 "set the value of an outfile streamid", "streamIndex:value" }, 3913 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | 3914 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) }, 3915 "force key frames at specified timestamps", "timestamps" }, 3916 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate }, 3917 "audio bitrate (please use -b:a)", "bitrate" }, 3918 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate }, 3919 "video bitrate (please use -b:v)", "bitrate" }, 3920 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | 3921 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) }, 3922 "use HW accelerated decoding", "hwaccel name" }, 3923 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | 3924 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) }, 3925 "select a device for HW acceleration", "devicename" }, 3926 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | 3927 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) }, 3928 "select output format used with HW accelerated decoding", "format" }, 3929 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels }, 3930 "show available HW acceleration methods" }, 3931 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC | 3932 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) }, 3933 "automatically insert correct rotate filters" }, 3934 { "autoscale", HAS_ARG | OPT_BOOL | OPT_SPEC | 3935 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) }, 3936 "automatically insert a scale filter at the end of the filter graph" }, 3937 3938 /* audio options */ 3939 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames }, 3940 "set the number of audio frames to output", "number" }, 3941 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale }, 3942 "set audio quality (codec-specific)", "quality", }, 3943 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | 3944 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) }, 3945 "set audio sampling rate (in Hz)", "rate" }, 3946 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | 3947 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) }, 3948 "set number of audio channels", "channels" }, 3949 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) }, 3950 "disable audio" }, 3951 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE | 3952 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec }, 3953 "force audio codec ('copy' to copy stream)", "codec" }, 3954 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE | 3955 OPT_OUTPUT, { .func_arg = opt_old2new }, 3956 "force audio tag/fourcc", "fourcc/tag" }, 3957 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume }, 3958 "change audio volume (256=normal)" , "volume" }, 3959 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | 3960 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) }, 3961 "set sample format", "format" }, 3962 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | 3963 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_ch_layouts) }, 3964 "set channel layout", "layout" }, 3965 { "ch_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | 3966 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_ch_layouts) }, 3967 "set channel layout", "layout" }, 3968 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters }, 3969 "set audio filters", "filter_graph" }, 3970 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) }, 3971 "set the maximum number of channels to try to guess the channel layout" }, 3972 3973 /* subtitle options */ 3974 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) }, 3975 "disable subtitle" }, 3976 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec }, 3977 "force subtitle codec ('copy' to copy stream)", "codec" }, 3978 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new } 3979 , "force subtitle tag/fourcc", "fourcc/tag" }, 3980 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) }, 3981 "fix subtitles duration" }, 3982 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) }, 3983 "set canvas size (WxH or abbreviation)", "size" }, 3984 3985 /* muxer options */ 3986 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) }, 3987 "set the maximum demux-decode delay", "seconds" }, 3988 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) }, 3989 "set the initial demux-decode delay", "seconds" }, 3990 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file }, 3991 "specify a file in which to print sdp information", "file" }, 3992 3993 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) }, 3994 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" }, 3995 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) }, 3996 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). " 3997 "two special values are defined - " 3998 "0 = use frame rate (video) or sample rate (audio)," 3999 "-1 = match source time base", "ratio" }, 4000 4001 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) }, 4002 "A comma-separated list of bitstream filters", "bitstream_filters" }, 4003 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }, 4004 "deprecated", "audio bitstream_filters" }, 4005 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }, 4006 "deprecated", "video bitstream_filters" }, 4007 4008 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset }, 4009 "set the audio options to the indicated preset", "preset" }, 4010 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset }, 4011 "set the video options to the indicated preset", "preset" }, 4012 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset }, 4013 "set the subtitle options to the indicated preset", "preset" }, 4014 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset }, 4015 "set options from indicated preset file", "filename" }, 4016 4017 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) }, 4018 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" }, 4019 { "muxing_queue_data_threshold", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(muxing_queue_data_threshold) }, 4020 "set the threshold after which max_muxing_queue_size is taken into account", "bytes" }, 4021 4022 /* data codec support */ 4023 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec }, 4024 "force data codec ('copy' to copy stream)", "codec" }, 4025 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) }, 4026 "disable data" }, 4027 4028#if CONFIG_VAAPI 4029 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device }, 4030 "set VAAPI hardware device (DRM path or X11 display name)", "device" }, 4031#endif 4032 4033#if CONFIG_QSV 4034 { "qsv_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_qsv_device }, 4035 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"}, 4036#endif 4037 4038 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device }, 4039 "initialise hardware device", "args" }, 4040 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device }, 4041 "set hardware device used when filtering", "device" }, 4042 4043 { NULL, }, 4044}; 4045