1/* 2 * ffmpeg main 3 * Copyright (c) 2000-2003 Fabrice Bellard 4 * 5 * This file is part of Libav. 6 * 7 * Libav is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * Libav is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with Libav; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22#include "config.h" 23#include <ctype.h> 24#include <string.h> 25#include <math.h> 26#include <stdlib.h> 27#include <errno.h> 28#include <signal.h> 29#include <limits.h> 30#include <unistd.h> 31#include "libavformat/avformat.h" 32#include "libavdevice/avdevice.h" 33#include "libswscale/swscale.h" 34#include "libavutil/opt.h" 35#include "libavcodec/audioconvert.h" 36#include "libavutil/audioconvert.h" 37#include "libavutil/parseutils.h" 38#include "libavutil/samplefmt.h" 39#include "libavutil/colorspace.h" 40#include "libavutil/fifo.h" 41#include "libavutil/intreadwrite.h" 42#include "libavutil/dict.h" 43#include "libavutil/mathematics.h" 44#include "libavutil/pixdesc.h" 45#include "libavutil/avstring.h" 46#include "libavutil/libm.h" 47#include "libavformat/os_support.h" 48 49#if CONFIG_AVFILTER 50# include "libavfilter/avfilter.h" 51# include "libavfilter/avfiltergraph.h" 52# include "libavfilter/vsrc_buffer.h" 53#endif 54 55#if HAVE_SYS_RESOURCE_H 56#include <sys/types.h> 57#include <sys/time.h> 58#include <sys/resource.h> 59#elif HAVE_GETPROCESSTIMES 60#include <windows.h> 61#endif 62#if HAVE_GETPROCESSMEMORYINFO 63#include <windows.h> 64#include <psapi.h> 65#endif 66 67#if HAVE_SYS_SELECT_H 68#include <sys/select.h> 69#endif 70 71#include <time.h> 72 73#include "cmdutils.h" 74 75#include "libavutil/avassert.h" 76 77const char program_name[] = "ffmpeg"; 78const int program_birth_year = 2000; 79 80/* select an input stream for an output stream */ 81typedef struct StreamMap { 82 int file_index; 83 int stream_index; 84 int sync_file_index; 85 int sync_stream_index; 86} StreamMap; 87 88/** 89 * select an input file for an output file 90 */ 91typedef struct MetadataMap { 92 int file; ///< file index 93 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram 94 int index; ///< stream/chapter/program number 95} MetadataMap; 96 97typedef struct ChapterMap { 98 int in_file; 99 int out_file; 100} ChapterMap; 101 102static const OptionDef options[]; 103 104#define MAX_FILES 100 105 106static const char *last_asked_format = NULL; 107static double *ts_scale; 108static int nb_ts_scale; 109 110static AVFormatContext *output_files[MAX_FILES]; 111static AVDictionary *output_opts[MAX_FILES]; 112static int nb_output_files = 0; 113 114static StreamMap *stream_maps = NULL; 115static int nb_stream_maps; 116 117/* first item specifies output metadata, second is input */ 118static MetadataMap (*meta_data_maps)[2] = NULL; 119static int nb_meta_data_maps; 120static int metadata_global_autocopy = 1; 121static int metadata_streams_autocopy = 1; 122static int metadata_chapters_autocopy = 1; 123 124static ChapterMap *chapter_maps = NULL; 125static int nb_chapter_maps; 126 127/* indexed by output file stream index */ 128static int *streamid_map = NULL; 129static int nb_streamid_map = 0; 130 131static int frame_width = 0; 132static int frame_height = 0; 133static float frame_aspect_ratio = 0; 134static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE; 135static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE; 136static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX}; 137static AVRational frame_rate; 138static float video_qscale = 0; 139static uint16_t *intra_matrix = NULL; 140static uint16_t *inter_matrix = NULL; 141static const char *video_rc_override_string=NULL; 142static int video_disable = 0; 143static int video_discard = 0; 144static char *video_codec_name = NULL; 145static unsigned int video_codec_tag = 0; 146static char *video_language = NULL; 147static int same_quality = 0; 148static int do_deinterlace = 0; 149static int top_field_first = -1; 150static int me_threshold = 0; 151static int intra_dc_precision = 8; 152static int loop_input = 0; 153static int loop_output = AVFMT_NOOUTPUTLOOP; 154static int qp_hist = 0; 155#if CONFIG_AVFILTER 156static char *vfilters = NULL; 157#endif 158 159static int intra_only = 0; 160static int audio_sample_rate = 0; 161#define QSCALE_NONE -99999 162static float audio_qscale = QSCALE_NONE; 163static int audio_disable = 0; 164static int audio_channels = 0; 165static char *audio_codec_name = NULL; 166static unsigned int audio_codec_tag = 0; 167static char *audio_language = NULL; 168 169static int subtitle_disable = 0; 170static char *subtitle_codec_name = NULL; 171static char *subtitle_language = NULL; 172static unsigned int subtitle_codec_tag = 0; 173 174static int data_disable = 0; 175static char *data_codec_name = NULL; 176static unsigned int data_codec_tag = 0; 177 178static float mux_preload= 0.5; 179static float mux_max_delay= 0.7; 180 181static int64_t recording_time = INT64_MAX; 182static int64_t start_time = 0; 183static int64_t input_ts_offset = 0; 184static int file_overwrite = 0; 185static AVDictionary *metadata; 186static int do_benchmark = 0; 187static int do_hex_dump = 0; 188static int do_pkt_dump = 0; 189static int do_psnr = 0; 190static int do_pass = 0; 191static char *pass_logfilename_prefix = NULL; 192static int audio_stream_copy = 0; 193static int video_stream_copy = 0; 194static int subtitle_stream_copy = 0; 195static int data_stream_copy = 0; 196static int video_sync_method= -1; 197static int audio_sync_method= 0; 198static float audio_drift_threshold= 0.1; 199static int copy_ts= 0; 200static int copy_tb; 201static int opt_shortest = 0; 202static char *vstats_filename; 203static FILE *vstats_file; 204static int opt_programid = 0; 205static int copy_initial_nonkeyframes = 0; 206 207static int rate_emu = 0; 208 209static int audio_volume = 256; 210 211static int exit_on_error = 0; 212static int using_stdin = 0; 213static int verbose = 1; 214static int thread_count= 1; 215static int64_t video_size = 0; 216static int64_t audio_size = 0; 217static int64_t extra_size = 0; 218static int nb_frames_dup = 0; 219static int nb_frames_drop = 0; 220static int input_sync; 221static uint64_t limit_filesize = 0; 222static int force_fps = 0; 223static char *forced_key_frames = NULL; 224 225static float dts_delta_threshold = 10; 226 227static int64_t timer_start; 228 229static uint8_t *audio_buf; 230static uint8_t *audio_out; 231static unsigned int allocated_audio_out_size, allocated_audio_buf_size; 232 233static short *samples; 234 235static AVBitStreamFilterContext *video_bitstream_filters=NULL; 236static AVBitStreamFilterContext *audio_bitstream_filters=NULL; 237static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL; 238 239#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass" 240 241struct InputStream; 242 243typedef struct OutputStream { 244 int file_index; /* file index */ 245 int index; /* stream index in the output file */ 246 int source_index; /* InputStream index */ 247 AVStream *st; /* stream in the output file */ 248 int encoding_needed; /* true if encoding needed for this stream */ 249 int frame_number; 250 /* input pts and corresponding output pts 251 for A/V sync */ 252 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */ 253 struct InputStream *sync_ist; /* input stream to sync against */ 254 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number 255 AVBitStreamFilterContext *bitstream_filters; 256 AVCodec *enc; 257 258 /* video only */ 259 int video_resample; 260 AVFrame pict_tmp; /* temporary image for resampling */ 261 struct SwsContext *img_resample_ctx; /* for image resampling */ 262 int resample_height; 263 int resample_width; 264 int resample_pix_fmt; 265 AVRational frame_rate; 266 267 float frame_aspect_ratio; 268 269 /* forced key frames */ 270 int64_t *forced_kf_pts; 271 int forced_kf_count; 272 int forced_kf_index; 273 274 /* audio only */ 275 int audio_resample; 276 ReSampleContext *resample; /* for audio resampling */ 277 int resample_sample_fmt; 278 int resample_channels; 279 int resample_sample_rate; 280 int reformat_pair; 281 AVAudioConvert *reformat_ctx; 282 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */ 283 FILE *logfile; 284 285#if CONFIG_AVFILTER 286 AVFilterContext *output_video_filter; 287 AVFilterContext *input_video_filter; 288 AVFilterBufferRef *picref; 289 char *avfilter; 290 AVFilterGraph *graph; 291#endif 292 293 int sws_flags; 294 AVDictionary *opts; 295} OutputStream; 296 297static OutputStream **output_streams_for_file[MAX_FILES] = { NULL }; 298static int nb_output_streams_for_file[MAX_FILES] = { 0 }; 299 300typedef struct InputStream { 301 int file_index; 302 AVStream *st; 303 int discard; /* true if stream data should be discarded */ 304 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */ 305 AVCodec *dec; 306 307 int64_t start; /* time when read started */ 308 int64_t next_pts; /* synthetic pts for cases where pkt.pts 309 is not defined */ 310 int64_t pts; /* current pts */ 311 PtsCorrectionContext pts_ctx; 312 double ts_scale; 313 int is_start; /* is 1 at the start and after a discontinuity */ 314 int showed_multi_packet_warning; 315 int is_past_recording_time; 316 AVDictionary *opts; 317} InputStream; 318 319typedef struct InputFile { 320 AVFormatContext *ctx; 321 int eof_reached; /* true if eof reached */ 322 int ist_index; /* index of first stream in ist_table */ 323 int buffer_size; /* current total buffer size */ 324 int64_t ts_offset; 325 int nb_streams; /* nb streams we are aware of */ 326} InputFile; 327 328static InputStream *input_streams = NULL; 329static int nb_input_streams = 0; 330static InputFile *input_files = NULL; 331static int nb_input_files = 0; 332 333#if CONFIG_AVFILTER 334 335static int configure_video_filters(InputStream *ist, OutputStream *ost) 336{ 337 AVFilterContext *last_filter, *filter; 338 /** filter graph containing all filters including input & output */ 339 AVCodecContext *codec = ost->st->codec; 340 AVCodecContext *icodec = ist->st->codec; 341 AVSinkContext avsink_ctx = { .pix_fmt = codec->pix_fmt }; 342 AVRational sample_aspect_ratio; 343 char args[255]; 344 int ret; 345 346 ost->graph = avfilter_graph_alloc(); 347 348 if (ist->st->sample_aspect_ratio.num){ 349 sample_aspect_ratio = ist->st->sample_aspect_ratio; 350 }else 351 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio; 352 353 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width, 354 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE, 355 sample_aspect_ratio.num, sample_aspect_ratio.den); 356 357 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"), 358 "src", args, NULL, ost->graph); 359 if (ret < 0) 360 return ret; 361 ret = avfilter_graph_create_filter(&ost->output_video_filter, &avsink, 362 "out", NULL, &avsink_ctx, ost->graph); 363 if (ret < 0) 364 return ret; 365 last_filter = ost->input_video_filter; 366 367 if (codec->width != icodec->width || codec->height != icodec->height) { 368 snprintf(args, 255, "%d:%d:flags=0x%X", 369 codec->width, 370 codec->height, 371 ost->sws_flags); 372 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"), 373 NULL, args, NULL, ost->graph)) < 0) 374 return ret; 375 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0) 376 return ret; 377 last_filter = filter; 378 } 379 380 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags); 381 ost->graph->scale_sws_opts = av_strdup(args); 382 383 if (ost->avfilter) { 384 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut)); 385 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut)); 386 387 outputs->name = av_strdup("in"); 388 outputs->filter_ctx = last_filter; 389 outputs->pad_idx = 0; 390 outputs->next = NULL; 391 392 inputs->name = av_strdup("out"); 393 inputs->filter_ctx = ost->output_video_filter; 394 inputs->pad_idx = 0; 395 inputs->next = NULL; 396 397 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0) 398 return ret; 399 av_freep(&ost->avfilter); 400 } else { 401 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0) 402 return ret; 403 } 404 405 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0) 406 return ret; 407 408 codec->width = ost->output_video_filter->inputs[0]->w; 409 codec->height = ost->output_video_filter->inputs[0]->h; 410 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio = 411 ost->frame_aspect_ratio ? // overriden by the -aspect cli option 412 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) : 413 ost->output_video_filter->inputs[0]->sample_aspect_ratio; 414 415 return 0; 416} 417#endif /* CONFIG_AVFILTER */ 418 419static void term_exit(void) 420{ 421 av_log(NULL, AV_LOG_QUIET, ""); 422} 423 424static volatile int received_sigterm = 0; 425static volatile int received_nb_signals = 0; 426 427static void 428sigterm_handler(int sig) 429{ 430 received_sigterm = sig; 431 received_nb_signals++; 432 term_exit(); 433} 434 435static void term_init(void) 436{ 437 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */ 438 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */ 439#ifdef SIGXCPU 440 signal(SIGXCPU, sigterm_handler); 441#endif 442} 443 444static int decode_interrupt_cb(void) 445{ 446 return received_nb_signals > 1; 447} 448 449void exit_program(int ret) 450{ 451 int i; 452 453 /* close files */ 454 for(i=0;i<nb_output_files;i++) { 455 AVFormatContext *s = output_files[i]; 456 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb) 457 avio_close(s->pb); 458 avformat_free_context(s); 459 av_free(output_streams_for_file[i]); 460 av_dict_free(&output_opts[i]); 461 } 462 for(i=0;i<nb_input_files;i++) { 463 av_close_input_file(input_files[i].ctx); 464 } 465 for (i = 0; i < nb_input_streams; i++) 466 av_dict_free(&input_streams[i].opts); 467 468 av_free(intra_matrix); 469 av_free(inter_matrix); 470 471 if (vstats_file) 472 fclose(vstats_file); 473 av_free(vstats_filename); 474 475 av_free(streamid_map); 476 av_free(stream_maps); 477 av_free(meta_data_maps); 478 479 av_freep(&input_streams); 480 av_freep(&input_files); 481 482 av_free(video_codec_name); 483 av_free(audio_codec_name); 484 av_free(subtitle_codec_name); 485 av_free(data_codec_name); 486 487 uninit_opts(); 488 av_free(audio_buf); 489 av_free(audio_out); 490 allocated_audio_buf_size= allocated_audio_out_size= 0; 491 av_free(samples); 492 493#if CONFIG_AVFILTER 494 avfilter_uninit(); 495#endif 496 avformat_network_deinit(); 497 498 if (received_sigterm) { 499 fprintf(stderr, 500 "Received signal %d: terminating.\n", 501 (int) received_sigterm); 502 exit (255); 503 } 504 505 exit(ret); /* not all OS-es handle main() return value */ 506} 507 508static void assert_avoptions(AVDictionary *m) 509{ 510 AVDictionaryEntry *t; 511 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) { 512 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key); 513 exit_program(1); 514 } 515} 516 517static void assert_codec_experimental(AVCodecContext *c, int encoder) 518{ 519 const char *codec_string = encoder ? "encoder" : "decoder"; 520 AVCodec *codec; 521 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL && 522 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { 523 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad " 524 "results.\nAdd '-strict experimental' if you want to use it.\n", 525 codec_string, c->codec->name); 526 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id); 527 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL)) 528 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n", 529 codec_string, codec->name); 530 exit_program(1); 531 } 532} 533 534static void choose_sample_fmt(AVStream *st, AVCodec *codec) 535{ 536 if(codec && codec->sample_fmts){ 537 const enum AVSampleFormat *p= codec->sample_fmts; 538 for(; *p!=-1; p++){ 539 if(*p == st->codec->sample_fmt) 540 break; 541 } 542 if (*p == -1) { 543 av_log(NULL, AV_LOG_WARNING, 544 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n", 545 av_get_sample_fmt_name(st->codec->sample_fmt), 546 codec->name, 547 av_get_sample_fmt_name(codec->sample_fmts[0])); 548 st->codec->sample_fmt = codec->sample_fmts[0]; 549 } 550 } 551} 552 553/** 554 * Update the requested input sample format based on the output sample format. 555 * This is currently only used to request float output from decoders which 556 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT. 557 * Ideally this will be removed in the future when decoders do not do format 558 * conversion and only output in their native format. 559 */ 560static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec, 561 AVCodecContext *enc) 562{ 563 /* if sample formats match or a decoder sample format has already been 564 requested, just return */ 565 if (enc->sample_fmt == dec->sample_fmt || 566 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE) 567 return; 568 569 /* if decoder supports more than one output format */ 570 if (dec_codec && dec_codec->sample_fmts && 571 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE && 572 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) { 573 const enum AVSampleFormat *p; 574 int min_dec = -1, min_inc = -1; 575 576 /* find a matching sample format in the encoder */ 577 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) { 578 if (*p == enc->sample_fmt) { 579 dec->request_sample_fmt = *p; 580 return; 581 } else if (*p > enc->sample_fmt) { 582 min_inc = FFMIN(min_inc, *p - enc->sample_fmt); 583 } else 584 min_dec = FFMIN(min_dec, enc->sample_fmt - *p); 585 } 586 587 /* if none match, provide the one that matches quality closest */ 588 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc : 589 enc->sample_fmt - min_dec; 590 } 591} 592 593static void choose_sample_rate(AVStream *st, AVCodec *codec) 594{ 595 if(codec && codec->supported_samplerates){ 596 const int *p= codec->supported_samplerates; 597 int best=0; 598 int best_dist=INT_MAX; 599 for(; *p; p++){ 600 int dist= abs(st->codec->sample_rate - *p); 601 if(dist < best_dist){ 602 best_dist= dist; 603 best= *p; 604 } 605 } 606 if(best_dist){ 607 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best); 608 } 609 st->codec->sample_rate= best; 610 } 611} 612 613static void choose_pixel_fmt(AVStream *st, AVCodec *codec) 614{ 615 if(codec && codec->pix_fmts){ 616 const enum PixelFormat *p= codec->pix_fmts; 617 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){ 618 if(st->codec->codec_id==CODEC_ID_MJPEG){ 619 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE}; 620 }else if(st->codec->codec_id==CODEC_ID_LJPEG){ 621 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE}; 622 } 623 } 624 for(; *p!=-1; p++){ 625 if(*p == st->codec->pix_fmt) 626 break; 627 } 628 if (*p == -1) { 629 if(st->codec->pix_fmt != PIX_FMT_NONE) 630 av_log(NULL, AV_LOG_WARNING, 631 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n", 632 av_pix_fmt_descriptors[st->codec->pix_fmt].name, 633 codec->name, 634 av_pix_fmt_descriptors[codec->pix_fmts[0]].name); 635 st->codec->pix_fmt = codec->pix_fmts[0]; 636 } 637 } 638} 639 640static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec) 641{ 642 OutputStream *ost; 643 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0); 644 int idx = oc->nb_streams - 1; 645 646 if (!st) { 647 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n"); 648 exit_program(1); 649 } 650 651 output_streams_for_file[file_idx] = 652 grow_array(output_streams_for_file[file_idx], 653 sizeof(*output_streams_for_file[file_idx]), 654 &nb_output_streams_for_file[file_idx], 655 oc->nb_streams); 656 ost = output_streams_for_file[file_idx][idx] = 657 av_mallocz(sizeof(OutputStream)); 658 if (!ost) { 659 fprintf(stderr, "Could not alloc output stream\n"); 660 exit_program(1); 661 } 662 ost->file_index = file_idx; 663 ost->index = idx; 664 ost->st = st; 665 ost->enc = codec; 666 if (codec) 667 ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st); 668 669 avcodec_get_context_defaults3(st->codec, codec); 670 671 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL); 672 return ost; 673} 674 675static int read_avserver_streams(AVFormatContext *s, const char *filename) 676{ 677 int i, err; 678 AVFormatContext *ic = NULL; 679 680 err = avformat_open_input(&ic, filename, NULL, NULL); 681 if (err < 0) 682 return err; 683 /* copy stream format */ 684 for(i=0;i<ic->nb_streams;i++) { 685 AVStream *st; 686 OutputStream *ost; 687 AVCodec *codec; 688 689 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id); 690 ost = new_output_stream(s, nb_output_files, codec); 691 st = ost->st; 692 693 // FIXME: a more elegant solution is needed 694 memcpy(st, ic->streams[i], sizeof(AVStream)); 695 st->info = NULL; 696 avcodec_copy_context(st->codec, ic->streams[i]->codec); 697 698 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 699 if (audio_stream_copy) { 700 st->stream_copy = 1; 701 } else 702 choose_sample_fmt(st, codec); 703 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 704 if (video_stream_copy) { 705 st->stream_copy = 1; 706 } else 707 choose_pixel_fmt(st, codec); 708 } 709 } 710 711 av_close_input_file(ic); 712 return 0; 713} 714 715static double 716get_sync_ipts(const OutputStream *ost) 717{ 718 const InputStream *ist = ost->sync_ist; 719 return (double)(ist->pts - start_time)/AV_TIME_BASE; 720} 721 722static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){ 723 int ret; 724 725 while(bsfc){ 726 AVPacket new_pkt= *pkt; 727 int a= av_bitstream_filter_filter(bsfc, avctx, NULL, 728 &new_pkt.data, &new_pkt.size, 729 pkt->data, pkt->size, 730 pkt->flags & AV_PKT_FLAG_KEY); 731 if(a>0){ 732 av_free_packet(pkt); 733 new_pkt.destruct= av_destruct_packet; 734 } else if(a<0){ 735 fprintf(stderr, "%s failed for stream %d, codec %s", 736 bsfc->filter->name, pkt->stream_index, 737 avctx->codec ? avctx->codec->name : "copy"); 738 print_error("", a); 739 if (exit_on_error) 740 exit_program(1); 741 } 742 *pkt= new_pkt; 743 744 bsfc= bsfc->next; 745 } 746 747 ret= av_interleaved_write_frame(s, pkt); 748 if(ret < 0){ 749 print_error("av_interleaved_write_frame()", ret); 750 exit_program(1); 751 } 752} 753 754#define MAX_AUDIO_PACKET_SIZE (128 * 1024) 755 756static void do_audio_out(AVFormatContext *s, 757 OutputStream *ost, 758 InputStream *ist, 759 unsigned char *buf, int size) 760{ 761 uint8_t *buftmp; 762 int64_t audio_out_size, audio_buf_size; 763 int64_t allocated_for_size= size; 764 765 int size_out, frame_bytes, ret, resample_changed; 766 AVCodecContext *enc= ost->st->codec; 767 AVCodecContext *dec= ist->st->codec; 768 int osize = av_get_bytes_per_sample(enc->sample_fmt); 769 int isize = av_get_bytes_per_sample(dec->sample_fmt); 770 const int coded_bps = av_get_bits_per_sample(enc->codec->id); 771 772need_realloc: 773 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels); 774 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate; 775 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API 776 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size); 777 audio_buf_size*= osize*enc->channels; 778 779 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels); 780 if(coded_bps > 8*osize) 781 audio_out_size= audio_out_size * coded_bps / (8*osize); 782 audio_out_size += FF_MIN_BUFFER_SIZE; 783 784 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){ 785 fprintf(stderr, "Buffer sizes too large\n"); 786 exit_program(1); 787 } 788 789 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size); 790 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size); 791 if (!audio_buf || !audio_out){ 792 fprintf(stderr, "Out of memory in do_audio_out\n"); 793 exit_program(1); 794 } 795 796 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate) 797 ost->audio_resample = 1; 798 799 resample_changed = ost->resample_sample_fmt != dec->sample_fmt || 800 ost->resample_channels != dec->channels || 801 ost->resample_sample_rate != dec->sample_rate; 802 803 if ((ost->audio_resample && !ost->resample) || resample_changed) { 804 if (resample_changed) { 805 av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n", 806 ist->file_index, ist->st->index, 807 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels, 808 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels); 809 ost->resample_sample_fmt = dec->sample_fmt; 810 ost->resample_channels = dec->channels; 811 ost->resample_sample_rate = dec->sample_rate; 812 if (ost->resample) 813 audio_resample_close(ost->resample); 814 } 815 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */ 816 if (audio_sync_method <= 1 && 817 ost->resample_sample_fmt == enc->sample_fmt && 818 ost->resample_channels == enc->channels && 819 ost->resample_sample_rate == enc->sample_rate) { 820 ost->resample = NULL; 821 ost->audio_resample = 0; 822 } else if (ost->audio_resample) { 823 if (dec->sample_fmt != AV_SAMPLE_FMT_S16) 824 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n"); 825 ost->resample = av_audio_resample_init(enc->channels, dec->channels, 826 enc->sample_rate, dec->sample_rate, 827 enc->sample_fmt, dec->sample_fmt, 828 16, 10, 0, 0.8); 829 if (!ost->resample) { 830 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n", 831 dec->channels, dec->sample_rate, 832 enc->channels, enc->sample_rate); 833 exit_program(1); 834 } 835 } 836 } 837 838#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b)) 839 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt && 840 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) { 841 if (ost->reformat_ctx) 842 av_audio_convert_free(ost->reformat_ctx); 843 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1, 844 dec->sample_fmt, 1, NULL, 0); 845 if (!ost->reformat_ctx) { 846 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n", 847 av_get_sample_fmt_name(dec->sample_fmt), 848 av_get_sample_fmt_name(enc->sample_fmt)); 849 exit_program(1); 850 } 851 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt); 852 } 853 854 if(audio_sync_method){ 855 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts 856 - av_fifo_size(ost->fifo)/(enc->channels * 2); 857 double idelta= delta*dec->sample_rate / enc->sample_rate; 858 int byte_delta= ((int)idelta)*2*dec->channels; 859 860 //FIXME resample delay 861 if(fabs(delta) > 50){ 862 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){ 863 if(byte_delta < 0){ 864 byte_delta= FFMAX(byte_delta, -size); 865 size += byte_delta; 866 buf -= byte_delta; 867 if(verbose > 2) 868 fprintf(stderr, "discarding %d audio samples\n", (int)-delta); 869 if(!size) 870 return; 871 ist->is_start=0; 872 }else{ 873 static uint8_t *input_tmp= NULL; 874 input_tmp= av_realloc(input_tmp, byte_delta + size); 875 876 if(byte_delta > allocated_for_size - size){ 877 allocated_for_size= byte_delta + (int64_t)size; 878 goto need_realloc; 879 } 880 ist->is_start=0; 881 882 memset(input_tmp, 0, byte_delta); 883 memcpy(input_tmp + byte_delta, buf, size); 884 buf= input_tmp; 885 size += byte_delta; 886 if(verbose > 2) 887 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta); 888 } 889 }else if(audio_sync_method>1){ 890 int comp= av_clip(delta, -audio_sync_method, audio_sync_method); 891 av_assert0(ost->audio_resample); 892 if(verbose > 2) 893 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate); 894// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2)); 895 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate); 896 } 897 } 898 }else 899 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate) 900 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong 901 902 if (ost->audio_resample) { 903 buftmp = audio_buf; 904 size_out = audio_resample(ost->resample, 905 (short *)buftmp, (short *)buf, 906 size / (dec->channels * isize)); 907 size_out = size_out * enc->channels * osize; 908 } else { 909 buftmp = buf; 910 size_out = size; 911 } 912 913 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) { 914 const void *ibuf[6]= {buftmp}; 915 void *obuf[6]= {audio_buf}; 916 int istride[6]= {isize}; 917 int ostride[6]= {osize}; 918 int len= size_out/istride[0]; 919 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) { 920 printf("av_audio_convert() failed\n"); 921 if (exit_on_error) 922 exit_program(1); 923 return; 924 } 925 buftmp = audio_buf; 926 size_out = len*osize; 927 } 928 929 /* now encode as many frames as possible */ 930 if (enc->frame_size > 1) { 931 /* output resampled raw samples */ 932 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) { 933 fprintf(stderr, "av_fifo_realloc2() failed\n"); 934 exit_program(1); 935 } 936 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL); 937 938 frame_bytes = enc->frame_size * osize * enc->channels; 939 940 while (av_fifo_size(ost->fifo) >= frame_bytes) { 941 AVPacket pkt; 942 av_init_packet(&pkt); 943 944 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL); 945 946 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio() 947 948 ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 949 (short *)audio_buf); 950 if (ret < 0) { 951 fprintf(stderr, "Audio encoding failed\n"); 952 exit_program(1); 953 } 954 audio_size += ret; 955 pkt.stream_index= ost->index; 956 pkt.data= audio_out; 957 pkt.size= ret; 958 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) 959 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); 960 pkt.flags |= AV_PKT_FLAG_KEY; 961 write_frame(s, &pkt, enc, ost->bitstream_filters); 962 963 ost->sync_opts += enc->frame_size; 964 } 965 } else { 966 AVPacket pkt; 967 av_init_packet(&pkt); 968 969 ost->sync_opts += size_out / (osize * enc->channels); 970 971 /* output a pcm frame */ 972 /* determine the size of the coded buffer */ 973 size_out /= osize; 974 if (coded_bps) 975 size_out = size_out*coded_bps/8; 976 977 if(size_out > audio_out_size){ 978 fprintf(stderr, "Internal error, buffer size too small\n"); 979 exit_program(1); 980 } 981 982 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio() 983 ret = avcodec_encode_audio(enc, audio_out, size_out, 984 (short *)buftmp); 985 if (ret < 0) { 986 fprintf(stderr, "Audio encoding failed\n"); 987 exit_program(1); 988 } 989 audio_size += ret; 990 pkt.stream_index= ost->index; 991 pkt.data= audio_out; 992 pkt.size= ret; 993 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) 994 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); 995 pkt.flags |= AV_PKT_FLAG_KEY; 996 write_frame(s, &pkt, enc, ost->bitstream_filters); 997 } 998} 999 1000static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp) 1001{ 1002 AVCodecContext *dec; 1003 AVPicture *picture2; 1004 AVPicture picture_tmp; 1005 uint8_t *buf = 0; 1006 1007 dec = ist->st->codec; 1008 1009 /* deinterlace : must be done before any resize */ 1010 if (do_deinterlace) { 1011 int size; 1012 1013 /* create temporary picture */ 1014 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height); 1015 buf = av_malloc(size); 1016 if (!buf) 1017 return; 1018 1019 picture2 = &picture_tmp; 1020 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height); 1021 1022 if(avpicture_deinterlace(picture2, picture, 1023 dec->pix_fmt, dec->width, dec->height) < 0) { 1024 /* if error, do not deinterlace */ 1025 fprintf(stderr, "Deinterlacing failed\n"); 1026 av_free(buf); 1027 buf = NULL; 1028 picture2 = picture; 1029 } 1030 } else { 1031 picture2 = picture; 1032 } 1033 1034 if (picture != picture2) 1035 *picture = *picture2; 1036 *bufp = buf; 1037} 1038 1039/* we begin to correct av delay at this threshold */ 1040#define AV_DELAY_MAX 0.100 1041 1042static void do_subtitle_out(AVFormatContext *s, 1043 OutputStream *ost, 1044 InputStream *ist, 1045 AVSubtitle *sub, 1046 int64_t pts) 1047{ 1048 static uint8_t *subtitle_out = NULL; 1049 int subtitle_out_max_size = 1024 * 1024; 1050 int subtitle_out_size, nb, i; 1051 AVCodecContext *enc; 1052 AVPacket pkt; 1053 1054 if (pts == AV_NOPTS_VALUE) { 1055 fprintf(stderr, "Subtitle packets must have a pts\n"); 1056 if (exit_on_error) 1057 exit_program(1); 1058 return; 1059 } 1060 1061 enc = ost->st->codec; 1062 1063 if (!subtitle_out) { 1064 subtitle_out = av_malloc(subtitle_out_max_size); 1065 } 1066 1067 /* Note: DVB subtitle need one packet to draw them and one other 1068 packet to clear them */ 1069 /* XXX: signal it in the codec context ? */ 1070 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) 1071 nb = 2; 1072 else 1073 nb = 1; 1074 1075 for(i = 0; i < nb; i++) { 1076 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q); 1077 // start_display_time is required to be 0 1078 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q); 1079 sub->end_display_time -= sub->start_display_time; 1080 sub->start_display_time = 0; 1081 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out, 1082 subtitle_out_max_size, sub); 1083 if (subtitle_out_size < 0) { 1084 fprintf(stderr, "Subtitle encoding failed\n"); 1085 exit_program(1); 1086 } 1087 1088 av_init_packet(&pkt); 1089 pkt.stream_index = ost->index; 1090 pkt.data = subtitle_out; 1091 pkt.size = subtitle_out_size; 1092 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base); 1093 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) { 1094 /* XXX: the pts correction is handled here. Maybe handling 1095 it in the codec would be better */ 1096 if (i == 0) 1097 pkt.pts += 90 * sub->start_display_time; 1098 else 1099 pkt.pts += 90 * sub->end_display_time; 1100 } 1101 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters); 1102 } 1103} 1104 1105static int bit_buffer_size= 1024*256; 1106static uint8_t *bit_buffer= NULL; 1107 1108static void do_video_out(AVFormatContext *s, 1109 OutputStream *ost, 1110 InputStream *ist, 1111 AVFrame *in_picture, 1112 int *frame_size, float quality) 1113{ 1114 int nb_frames, i, ret, resample_changed; 1115 AVFrame *final_picture, *formatted_picture; 1116 AVCodecContext *enc, *dec; 1117 double sync_ipts; 1118 1119 enc = ost->st->codec; 1120 dec = ist->st->codec; 1121 1122 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base); 1123 1124 /* by default, we output a single frame */ 1125 nb_frames = 1; 1126 1127 *frame_size = 0; 1128 1129 if(video_sync_method){ 1130 double vdelta = sync_ipts - ost->sync_opts; 1131 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c 1132 if (vdelta < -1.1) 1133 nb_frames = 0; 1134 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){ 1135 if(vdelta<=-0.6){ 1136 nb_frames=0; 1137 }else if(vdelta>0.6) 1138 ost->sync_opts= lrintf(sync_ipts); 1139 }else if (vdelta > 1.1) 1140 nb_frames = lrintf(vdelta); 1141//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames); 1142 if (nb_frames == 0){ 1143 ++nb_frames_drop; 1144 if (verbose>2) 1145 fprintf(stderr, "*** drop!\n"); 1146 }else if (nb_frames > 1) { 1147 nb_frames_dup += nb_frames - 1; 1148 if (verbose>2) 1149 fprintf(stderr, "*** %d dup!\n", nb_frames-1); 1150 } 1151 }else 1152 ost->sync_opts= lrintf(sync_ipts); 1153 1154 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number); 1155 if (nb_frames <= 0) 1156 return; 1157 1158 formatted_picture = in_picture; 1159 final_picture = formatted_picture; 1160 1161 resample_changed = ost->resample_width != dec->width || 1162 ost->resample_height != dec->height || 1163 ost->resample_pix_fmt != dec->pix_fmt; 1164 1165 if (resample_changed) { 1166 av_log(NULL, AV_LOG_INFO, 1167 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n", 1168 ist->file_index, ist->st->index, 1169 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt), 1170 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt)); 1171 if(!ost->video_resample) 1172 exit_program(1); 1173 } 1174 1175#if !CONFIG_AVFILTER 1176 if (ost->video_resample) { 1177 final_picture = &ost->pict_tmp; 1178 if (resample_changed) { 1179 /* initialize a new scaler context */ 1180 sws_freeContext(ost->img_resample_ctx); 1181 ost->img_resample_ctx = sws_getContext( 1182 ist->st->codec->width, 1183 ist->st->codec->height, 1184 ist->st->codec->pix_fmt, 1185 ost->st->codec->width, 1186 ost->st->codec->height, 1187 ost->st->codec->pix_fmt, 1188 ost->sws_flags, NULL, NULL, NULL); 1189 if (ost->img_resample_ctx == NULL) { 1190 fprintf(stderr, "Cannot get resampling context\n"); 1191 exit_program(1); 1192 } 1193 } 1194 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize, 1195 0, ost->resample_height, final_picture->data, final_picture->linesize); 1196 } 1197#endif 1198 1199 /* duplicates frame if needed */ 1200 for(i=0;i<nb_frames;i++) { 1201 AVPacket pkt; 1202 av_init_packet(&pkt); 1203 pkt.stream_index= ost->index; 1204 1205 if (s->oformat->flags & AVFMT_RAWPICTURE) { 1206 /* raw pictures are written as AVPicture structure to 1207 avoid any copies. We support temorarily the older 1208 method. */ 1209 AVFrame* old_frame = enc->coded_frame; 1210 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack 1211 pkt.data= (uint8_t *)final_picture; 1212 pkt.size= sizeof(AVPicture); 1213 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base); 1214 pkt.flags |= AV_PKT_FLAG_KEY; 1215 1216 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters); 1217 enc->coded_frame = old_frame; 1218 } else { 1219 AVFrame big_picture; 1220 1221 big_picture= *final_picture; 1222 /* better than nothing: use input picture interlaced 1223 settings */ 1224 big_picture.interlaced_frame = in_picture->interlaced_frame; 1225 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) { 1226 if(top_field_first == -1) 1227 big_picture.top_field_first = in_picture->top_field_first; 1228 else 1229 big_picture.top_field_first = top_field_first; 1230 } 1231 1232 /* handles sameq here. This is not correct because it may 1233 not be a global option */ 1234 big_picture.quality = quality; 1235 if(!me_threshold) 1236 big_picture.pict_type = 0; 1237// big_picture.pts = AV_NOPTS_VALUE; 1238 big_picture.pts= ost->sync_opts; 1239// big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den); 1240//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts); 1241 if (ost->forced_kf_index < ost->forced_kf_count && 1242 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) { 1243 big_picture.pict_type = AV_PICTURE_TYPE_I; 1244 ost->forced_kf_index++; 1245 } 1246 ret = avcodec_encode_video(enc, 1247 bit_buffer, bit_buffer_size, 1248 &big_picture); 1249 if (ret < 0) { 1250 fprintf(stderr, "Video encoding failed\n"); 1251 exit_program(1); 1252 } 1253 1254 if(ret>0){ 1255 pkt.data= bit_buffer; 1256 pkt.size= ret; 1257 if(enc->coded_frame->pts != AV_NOPTS_VALUE) 1258 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); 1259/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n", 1260 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1, 1261 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/ 1262 1263 if(enc->coded_frame->key_frame) 1264 pkt.flags |= AV_PKT_FLAG_KEY; 1265 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters); 1266 *frame_size = ret; 1267 video_size += ret; 1268 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d", 1269 // enc->frame_number-1, ret, enc->pict_type); 1270 /* if two pass, output log */ 1271 if (ost->logfile && enc->stats_out) { 1272 fprintf(ost->logfile, "%s", enc->stats_out); 1273 } 1274 } 1275 } 1276 ost->sync_opts++; 1277 ost->frame_number++; 1278 } 1279} 1280 1281static double psnr(double d){ 1282 return -10.0*log(d)/log(10.0); 1283} 1284 1285static void do_video_stats(AVFormatContext *os, OutputStream *ost, 1286 int frame_size) 1287{ 1288 AVCodecContext *enc; 1289 int frame_number; 1290 double ti1, bitrate, avg_bitrate; 1291 1292 /* this is executed just the first time do_video_stats is called */ 1293 if (!vstats_file) { 1294 vstats_file = fopen(vstats_filename, "w"); 1295 if (!vstats_file) { 1296 perror("fopen"); 1297 exit_program(1); 1298 } 1299 } 1300 1301 enc = ost->st->codec; 1302 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) { 1303 frame_number = ost->frame_number; 1304 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA); 1305 if (enc->flags&CODEC_FLAG_PSNR) 1306 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0))); 1307 1308 fprintf(vstats_file,"f_size= %6d ", frame_size); 1309 /* compute pts value */ 1310 ti1 = ost->sync_opts * av_q2d(enc->time_base); 1311 if (ti1 < 0.01) 1312 ti1 = 0.01; 1313 1314 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0; 1315 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0; 1316 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ", 1317 (double)video_size / 1024, ti1, bitrate, avg_bitrate); 1318 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type)); 1319 } 1320} 1321 1322static void print_report(AVFormatContext **output_files, 1323 OutputStream **ost_table, int nb_ostreams, 1324 int is_last_report) 1325{ 1326 char buf[1024]; 1327 OutputStream *ost; 1328 AVFormatContext *oc; 1329 int64_t total_size; 1330 AVCodecContext *enc; 1331 int frame_number, vid, i; 1332 double bitrate, ti1, pts; 1333 static int64_t last_time = -1; 1334 static int qp_histogram[52]; 1335 1336 if (!is_last_report) { 1337 int64_t cur_time; 1338 /* display the report every 0.5 seconds */ 1339 cur_time = av_gettime(); 1340 if (last_time == -1) { 1341 last_time = cur_time; 1342 return; 1343 } 1344 if ((cur_time - last_time) < 500000) 1345 return; 1346 last_time = cur_time; 1347 } 1348 1349 1350 oc = output_files[0]; 1351 1352 total_size = avio_size(oc->pb); 1353 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too 1354 total_size= avio_tell(oc->pb); 1355 1356 buf[0] = '\0'; 1357 ti1 = 1e10; 1358 vid = 0; 1359 for(i=0;i<nb_ostreams;i++) { 1360 float q = -1; 1361 ost = ost_table[i]; 1362 enc = ost->st->codec; 1363 if (!ost->st->stream_copy && enc->coded_frame) 1364 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA; 1365 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) { 1366 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q); 1367 } 1368 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) { 1369 float t = (av_gettime()-timer_start) / 1000000.0; 1370 1371 frame_number = ost->frame_number; 1372 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ", 1373 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q); 1374 if(is_last_report) 1375 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L"); 1376 if(qp_hist){ 1377 int j; 1378 int qp = lrintf(q); 1379 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram)) 1380 qp_histogram[qp]++; 1381 for(j=0; j<32; j++) 1382 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2))); 1383 } 1384 if (enc->flags&CODEC_FLAG_PSNR){ 1385 int j; 1386 double error, error_sum=0; 1387 double scale, scale_sum=0; 1388 char type[3]= {'Y','U','V'}; 1389 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR="); 1390 for(j=0; j<3; j++){ 1391 if(is_last_report){ 1392 error= enc->error[j]; 1393 scale= enc->width*enc->height*255.0*255.0*frame_number; 1394 }else{ 1395 error= enc->coded_frame->error[j]; 1396 scale= enc->width*enc->height*255.0*255.0; 1397 } 1398 if(j) scale/=4; 1399 error_sum += error; 1400 scale_sum += scale; 1401 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale)); 1402 } 1403 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum)); 1404 } 1405 vid = 1; 1406 } 1407 /* compute min output value */ 1408 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base); 1409 if ((pts < ti1) && (pts > 0)) 1410 ti1 = pts; 1411 } 1412 if (ti1 < 0.01) 1413 ti1 = 0.01; 1414 1415 if (verbose > 0 || is_last_report) { 1416 bitrate = (double)(total_size * 8) / ti1 / 1000.0; 1417 1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), 1419 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s", 1420 (double)total_size / 1024, ti1, bitrate); 1421 1422 if (nb_frames_dup || nb_frames_drop) 1423 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d", 1424 nb_frames_dup, nb_frames_drop); 1425 1426 if (verbose >= 0) 1427 fprintf(stderr, "%s \r", buf); 1428 1429 fflush(stderr); 1430 } 1431 1432 if (is_last_report && verbose >= 0){ 1433 int64_t raw= audio_size + video_size + extra_size; 1434 fprintf(stderr, "\n"); 1435 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n", 1436 video_size/1024.0, 1437 audio_size/1024.0, 1438 extra_size/1024.0, 1439 100.0*(total_size - raw)/raw 1440 ); 1441 } 1442} 1443 1444static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size) 1445{ 1446 int fill_char = 0x00; 1447 if (sample_fmt == AV_SAMPLE_FMT_U8) 1448 fill_char = 0x80; 1449 memset(buf, fill_char, size); 1450} 1451 1452/* pkt = NULL means EOF (needed to flush decoder buffers) */ 1453static int output_packet(InputStream *ist, int ist_index, 1454 OutputStream **ost_table, int nb_ostreams, 1455 const AVPacket *pkt) 1456{ 1457 AVFormatContext *os; 1458 OutputStream *ost; 1459 int ret, i; 1460 int got_output; 1461 AVFrame picture; 1462 void *buffer_to_free = NULL; 1463 static unsigned int samples_size= 0; 1464 AVSubtitle subtitle, *subtitle_to_free; 1465 int64_t pkt_pts = AV_NOPTS_VALUE; 1466#if CONFIG_AVFILTER 1467 int frame_available; 1468#endif 1469 float quality; 1470 1471 AVPacket avpkt; 1472 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt); 1473 1474 if(ist->next_pts == AV_NOPTS_VALUE) 1475 ist->next_pts= ist->pts; 1476 1477 if (pkt == NULL) { 1478 /* EOF handling */ 1479 av_init_packet(&avpkt); 1480 avpkt.data = NULL; 1481 avpkt.size = 0; 1482 goto handle_eof; 1483 } else { 1484 avpkt = *pkt; 1485 } 1486 1487 if(pkt->dts != AV_NOPTS_VALUE) 1488 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q); 1489 if(pkt->pts != AV_NOPTS_VALUE) 1490 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q); 1491 1492 //while we have more to decode or while the decoder did output something on EOF 1493 while (avpkt.size > 0 || (!pkt && got_output)) { 1494 uint8_t *data_buf, *decoded_data_buf; 1495 int data_size, decoded_data_size; 1496 handle_eof: 1497 ist->pts= ist->next_pts; 1498 1499 if(avpkt.size && avpkt.size != pkt->size && 1500 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){ 1501 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index); 1502 ist->showed_multi_packet_warning=1; 1503 } 1504 1505 /* decode the packet if needed */ 1506 decoded_data_buf = NULL; /* fail safe */ 1507 decoded_data_size= 0; 1508 data_buf = avpkt.data; 1509 data_size = avpkt.size; 1510 subtitle_to_free = NULL; 1511 if (ist->decoding_needed) { 1512 switch(ist->st->codec->codec_type) { 1513 case AVMEDIA_TYPE_AUDIO:{ 1514 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) { 1515 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE); 1516 av_free(samples); 1517 samples= av_malloc(samples_size); 1518 } 1519 decoded_data_size= samples_size; 1520 /* XXX: could avoid copy if PCM 16 bits with same 1521 endianness as CPU */ 1522 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size, 1523 &avpkt); 1524 if (ret < 0) 1525 return ret; 1526 avpkt.data += ret; 1527 avpkt.size -= ret; 1528 data_size = ret; 1529 got_output = decoded_data_size > 0; 1530 /* Some bug in mpeg audio decoder gives */ 1531 /* decoded_data_size < 0, it seems they are overflows */ 1532 if (!got_output) { 1533 /* no audio frame */ 1534 continue; 1535 } 1536 decoded_data_buf = (uint8_t *)samples; 1537 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) / 1538 (ist->st->codec->sample_rate * ist->st->codec->channels); 1539 break;} 1540 case AVMEDIA_TYPE_VIDEO: 1541 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2; 1542 /* XXX: allocate picture correctly */ 1543 avcodec_get_frame_defaults(&picture); 1544 avpkt.pts = pkt_pts; 1545 avpkt.dts = ist->pts; 1546 pkt_pts = AV_NOPTS_VALUE; 1547 1548 ret = avcodec_decode_video2(ist->st->codec, 1549 &picture, &got_output, &avpkt); 1550 quality = same_quality ? picture.quality : 0; 1551 if (ret < 0) 1552 return ret; 1553 if (!got_output) { 1554 /* no picture yet */ 1555 goto discard_packet; 1556 } 1557 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts); 1558 if (ist->st->codec->time_base.num != 0) { 1559 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame; 1560 ist->next_pts += ((int64_t)AV_TIME_BASE * 1561 ist->st->codec->time_base.num * ticks) / 1562 ist->st->codec->time_base.den; 1563 } 1564 avpkt.size = 0; 1565 buffer_to_free = NULL; 1566 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free); 1567 break; 1568 case AVMEDIA_TYPE_SUBTITLE: 1569 ret = avcodec_decode_subtitle2(ist->st->codec, 1570 &subtitle, &got_output, &avpkt); 1571 if (ret < 0) 1572 return ret; 1573 if (!got_output) { 1574 goto discard_packet; 1575 } 1576 subtitle_to_free = &subtitle; 1577 avpkt.size = 0; 1578 break; 1579 default: 1580 return -1; 1581 } 1582 } else { 1583 switch(ist->st->codec->codec_type) { 1584 case AVMEDIA_TYPE_AUDIO: 1585 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) / 1586 ist->st->codec->sample_rate; 1587 break; 1588 case AVMEDIA_TYPE_VIDEO: 1589 if (ist->st->codec->time_base.num != 0) { 1590 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame; 1591 ist->next_pts += ((int64_t)AV_TIME_BASE * 1592 ist->st->codec->time_base.num * ticks) / 1593 ist->st->codec->time_base.den; 1594 } 1595 break; 1596 } 1597 ret = avpkt.size; 1598 avpkt.size = 0; 1599 } 1600 1601#if CONFIG_AVFILTER 1602 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 1603 for (i = 0; i < nb_ostreams; i++) { 1604 ost = ost_table[i]; 1605 if (ost->input_video_filter && ost->source_index == ist_index) { 1606 AVRational sar; 1607 if (ist->st->sample_aspect_ratio.num) 1608 sar = ist->st->sample_aspect_ratio; 1609 else 1610 sar = ist->st->codec->sample_aspect_ratio; 1611 // add it to be filtered 1612 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, 1613 ist->pts, 1614 sar); 1615 } 1616 } 1617 } 1618#endif 1619 1620 // preprocess audio (volume) 1621 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 1622 if (audio_volume != 256) { 1623 short *volp; 1624 volp = samples; 1625 for(i=0;i<(decoded_data_size / sizeof(short));i++) { 1626 int v = ((*volp) * audio_volume + 128) >> 8; 1627 if (v < -32768) v = -32768; 1628 if (v > 32767) v = 32767; 1629 *volp++ = v; 1630 } 1631 } 1632 } 1633 1634 /* frame rate emulation */ 1635 if (rate_emu) { 1636 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE); 1637 int64_t now = av_gettime() - ist->start; 1638 if (pts > now) 1639 usleep(pts - now); 1640 } 1641 /* if output time reached then transcode raw format, 1642 encode packets and output them */ 1643 if (start_time == 0 || ist->pts >= start_time) 1644 for(i=0;i<nb_ostreams;i++) { 1645 int frame_size; 1646 1647 ost = ost_table[i]; 1648 if (ost->source_index == ist_index) { 1649#if CONFIG_AVFILTER 1650 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || 1651 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]); 1652 while (frame_available) { 1653 AVRational ist_pts_tb; 1654 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) 1655 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb); 1656 if (ost->picref) 1657 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q); 1658#endif 1659 os = output_files[ost->file_index]; 1660 1661 /* set the input output pts pairs */ 1662 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE; 1663 1664 if (ost->encoding_needed) { 1665 av_assert0(ist->decoding_needed); 1666 switch(ost->st->codec->codec_type) { 1667 case AVMEDIA_TYPE_AUDIO: 1668 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size); 1669 break; 1670 case AVMEDIA_TYPE_VIDEO: 1671#if CONFIG_AVFILTER 1672 if (ost->picref->video && !ost->frame_aspect_ratio) 1673 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect; 1674#endif 1675 do_video_out(os, ost, ist, &picture, &frame_size, 1676 same_quality ? quality : ost->st->codec->global_quality); 1677 if (vstats_filename && frame_size) 1678 do_video_stats(os, ost, frame_size); 1679 break; 1680 case AVMEDIA_TYPE_SUBTITLE: 1681 do_subtitle_out(os, ost, ist, &subtitle, 1682 pkt->pts); 1683 break; 1684 default: 1685 abort(); 1686 } 1687 } else { 1688 AVFrame avframe; //FIXME/XXX remove this 1689 AVPacket opkt; 1690 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base); 1691 1692 av_init_packet(&opkt); 1693 1694 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes) 1695#if !CONFIG_AVFILTER 1696 continue; 1697#else 1698 goto cont; 1699#endif 1700 1701 /* no reencoding needed : output the packet directly */ 1702 /* force the input stream PTS */ 1703 1704 avcodec_get_frame_defaults(&avframe); 1705 ost->st->codec->coded_frame= &avframe; 1706 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY; 1707 1708 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) 1709 audio_size += data_size; 1710 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 1711 video_size += data_size; 1712 ost->sync_opts++; 1713 } 1714 1715 opkt.stream_index= ost->index; 1716 if(pkt->pts != AV_NOPTS_VALUE) 1717 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time; 1718 else 1719 opkt.pts= AV_NOPTS_VALUE; 1720 1721 if (pkt->dts == AV_NOPTS_VALUE) 1722 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base); 1723 else 1724 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base); 1725 opkt.dts -= ost_tb_start_time; 1726 1727 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base); 1728 opkt.flags= pkt->flags; 1729 1730 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters 1731 if( ost->st->codec->codec_id != CODEC_ID_H264 1732 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO 1733 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO 1734 ) { 1735 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY)) 1736 opkt.destruct= av_destruct_packet; 1737 } else { 1738 opkt.data = data_buf; 1739 opkt.size = data_size; 1740 } 1741 1742 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters); 1743 ost->st->codec->frame_number++; 1744 ost->frame_number++; 1745 av_free_packet(&opkt); 1746 } 1747#if CONFIG_AVFILTER 1748 cont: 1749 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) && 1750 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]); 1751 if (ost->picref) 1752 avfilter_unref_buffer(ost->picref); 1753 } 1754#endif 1755 } 1756 } 1757 1758 av_free(buffer_to_free); 1759 /* XXX: allocate the subtitles in the codec ? */ 1760 if (subtitle_to_free) { 1761 avsubtitle_free(subtitle_to_free); 1762 subtitle_to_free = NULL; 1763 } 1764 } 1765 discard_packet: 1766 if (pkt == NULL) { 1767 /* EOF handling */ 1768 1769 for(i=0;i<nb_ostreams;i++) { 1770 ost = ost_table[i]; 1771 if (ost->source_index == ist_index) { 1772 AVCodecContext *enc= ost->st->codec; 1773 os = output_files[ost->file_index]; 1774 1775 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1) 1776 continue; 1777 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE)) 1778 continue; 1779 1780 if (ost->encoding_needed) { 1781 for(;;) { 1782 AVPacket pkt; 1783 int fifo_bytes; 1784 av_init_packet(&pkt); 1785 pkt.stream_index= ost->index; 1786 1787 switch(ost->st->codec->codec_type) { 1788 case AVMEDIA_TYPE_AUDIO: 1789 fifo_bytes = av_fifo_size(ost->fifo); 1790 ret = 0; 1791 /* encode any samples remaining in fifo */ 1792 if (fifo_bytes > 0) { 1793 int osize = av_get_bytes_per_sample(enc->sample_fmt); 1794 int fs_tmp = enc->frame_size; 1795 1796 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL); 1797 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) { 1798 enc->frame_size = fifo_bytes / (osize * enc->channels); 1799 } else { /* pad */ 1800 int frame_bytes = enc->frame_size*osize*enc->channels; 1801 if (allocated_audio_buf_size < frame_bytes) 1802 exit_program(1); 1803 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes); 1804 } 1805 1806 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf); 1807 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den, 1808 ost->st->time_base.num, enc->sample_rate); 1809 enc->frame_size = fs_tmp; 1810 } 1811 if(ret <= 0) { 1812 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL); 1813 } 1814 if (ret < 0) { 1815 fprintf(stderr, "Audio encoding failed\n"); 1816 exit_program(1); 1817 } 1818 audio_size += ret; 1819 pkt.flags |= AV_PKT_FLAG_KEY; 1820 break; 1821 case AVMEDIA_TYPE_VIDEO: 1822 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL); 1823 if (ret < 0) { 1824 fprintf(stderr, "Video encoding failed\n"); 1825 exit_program(1); 1826 } 1827 video_size += ret; 1828 if(enc->coded_frame && enc->coded_frame->key_frame) 1829 pkt.flags |= AV_PKT_FLAG_KEY; 1830 if (ost->logfile && enc->stats_out) { 1831 fprintf(ost->logfile, "%s", enc->stats_out); 1832 } 1833 break; 1834 default: 1835 ret=-1; 1836 } 1837 1838 if(ret<=0) 1839 break; 1840 pkt.data= bit_buffer; 1841 pkt.size= ret; 1842 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) 1843 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); 1844 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters); 1845 } 1846 } 1847 } 1848 } 1849 } 1850 1851 return 0; 1852} 1853 1854static void print_sdp(AVFormatContext **avc, int n) 1855{ 1856 char sdp[2048]; 1857 1858 av_sdp_create(avc, n, sdp, sizeof(sdp)); 1859 printf("SDP:\n%s\n", sdp); 1860 fflush(stdout); 1861} 1862 1863static int copy_chapters(int infile, int outfile) 1864{ 1865 AVFormatContext *is = input_files[infile].ctx; 1866 AVFormatContext *os = output_files[outfile]; 1867 int i; 1868 1869 for (i = 0; i < is->nb_chapters; i++) { 1870 AVChapter *in_ch = is->chapters[i], *out_ch; 1871 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset, 1872 AV_TIME_BASE_Q, in_ch->time_base); 1873 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX : 1874 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base); 1875 1876 1877 if (in_ch->end < ts_off) 1878 continue; 1879 if (rt != INT64_MAX && in_ch->start > rt + ts_off) 1880 break; 1881 1882 out_ch = av_mallocz(sizeof(AVChapter)); 1883 if (!out_ch) 1884 return AVERROR(ENOMEM); 1885 1886 out_ch->id = in_ch->id; 1887 out_ch->time_base = in_ch->time_base; 1888 out_ch->start = FFMAX(0, in_ch->start - ts_off); 1889 out_ch->end = FFMIN(rt, in_ch->end - ts_off); 1890 1891 if (metadata_chapters_autocopy) 1892 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0); 1893 1894 os->nb_chapters++; 1895 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters); 1896 if (!os->chapters) 1897 return AVERROR(ENOMEM); 1898 os->chapters[os->nb_chapters - 1] = out_ch; 1899 } 1900 return 0; 1901} 1902 1903static void parse_forced_key_frames(char *kf, OutputStream *ost, 1904 AVCodecContext *avctx) 1905{ 1906 char *p; 1907 int n = 1, i; 1908 int64_t t; 1909 1910 for (p = kf; *p; p++) 1911 if (*p == ',') 1912 n++; 1913 ost->forced_kf_count = n; 1914 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n); 1915 if (!ost->forced_kf_pts) { 1916 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n"); 1917 exit_program(1); 1918 } 1919 for (i = 0; i < n; i++) { 1920 p = i ? strchr(p, ',') + 1 : kf; 1921 t = parse_time_or_die("force_key_frames", p, 1); 1922 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base); 1923 } 1924} 1925 1926/* 1927 * The following code is the main loop of the file converter 1928 */ 1929static int transcode(AVFormatContext **output_files, 1930 int nb_output_files, 1931 InputFile *input_files, 1932 int nb_input_files, 1933 StreamMap *stream_maps, int nb_stream_maps) 1934{ 1935 int ret = 0, i, j, k, n, nb_ostreams = 0; 1936 AVFormatContext *is, *os; 1937 AVCodecContext *codec, *icodec; 1938 OutputStream *ost, **ost_table = NULL; 1939 InputStream *ist; 1940 char error[1024]; 1941 int want_sdp = 1; 1942 uint8_t no_packet[MAX_FILES]={0}; 1943 int no_packet_count=0; 1944 1945 if (rate_emu) 1946 for (i = 0; i < nb_input_streams; i++) 1947 input_streams[i].start = av_gettime(); 1948 1949 /* output stream init */ 1950 nb_ostreams = 0; 1951 for(i=0;i<nb_output_files;i++) { 1952 os = output_files[i]; 1953 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) { 1954 av_dump_format(output_files[i], i, output_files[i]->filename, 1); 1955 fprintf(stderr, "Output file #%d does not contain any stream\n", i); 1956 ret = AVERROR(EINVAL); 1957 goto fail; 1958 } 1959 nb_ostreams += os->nb_streams; 1960 } 1961 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) { 1962 fprintf(stderr, "Number of stream maps must match number of output streams\n"); 1963 ret = AVERROR(EINVAL); 1964 goto fail; 1965 } 1966 1967 /* Sanity check the mapping args -- do the input files & streams exist? */ 1968 for(i=0;i<nb_stream_maps;i++) { 1969 int fi = stream_maps[i].file_index; 1970 int si = stream_maps[i].stream_index; 1971 1972 if (fi < 0 || fi > nb_input_files - 1 || 1973 si < 0 || si > input_files[fi].nb_streams - 1) { 1974 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si); 1975 ret = AVERROR(EINVAL); 1976 goto fail; 1977 } 1978 fi = stream_maps[i].sync_file_index; 1979 si = stream_maps[i].sync_stream_index; 1980 if (fi < 0 || fi > nb_input_files - 1 || 1981 si < 0 || si > input_files[fi].nb_streams - 1) { 1982 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si); 1983 ret = AVERROR(EINVAL); 1984 goto fail; 1985 } 1986 } 1987 1988 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams); 1989 if (!ost_table) 1990 goto fail; 1991 n = 0; 1992 for(k=0;k<nb_output_files;k++) { 1993 os = output_files[k]; 1994 for(i=0;i<os->nb_streams;i++,n++) { 1995 int found; 1996 ost = ost_table[n] = output_streams_for_file[k][i]; 1997 if (nb_stream_maps > 0) { 1998 ost->source_index = input_files[stream_maps[n].file_index].ist_index + 1999 stream_maps[n].stream_index; 2000 2001 /* Sanity check that the stream types match */ 2002 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) { 2003 int i= ost->file_index; 2004 av_dump_format(output_files[i], i, output_files[i]->filename, 1); 2005 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n", 2006 stream_maps[n].file_index, stream_maps[n].stream_index, 2007 ost->file_index, ost->index); 2008 exit_program(1); 2009 } 2010 2011 } else { 2012 int best_nb_frames=-1; 2013 /* get corresponding input stream index : we select the first one with the right type */ 2014 found = 0; 2015 for (j = 0; j < nb_input_streams; j++) { 2016 int skip=0; 2017 ist = &input_streams[j]; 2018 if(opt_programid){ 2019 int pi,si; 2020 AVFormatContext *f = input_files[ist->file_index].ctx; 2021 skip=1; 2022 for(pi=0; pi<f->nb_programs; pi++){ 2023 AVProgram *p= f->programs[pi]; 2024 if(p->id == opt_programid) 2025 for(si=0; si<p->nb_stream_indexes; si++){ 2026 if(f->streams[ p->stream_index[si] ] == ist->st) 2027 skip=0; 2028 } 2029 } 2030 } 2031 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip && 2032 ist->st->codec->codec_type == ost->st->codec->codec_type) { 2033 if(best_nb_frames < ist->st->codec_info_nb_frames){ 2034 best_nb_frames= ist->st->codec_info_nb_frames; 2035 ost->source_index = j; 2036 found = 1; 2037 } 2038 } 2039 } 2040 2041 if (!found) { 2042 if(! opt_programid) { 2043 /* try again and reuse existing stream */ 2044 for (j = 0; j < nb_input_streams; j++) { 2045 ist = &input_streams[j]; 2046 if ( ist->st->codec->codec_type == ost->st->codec->codec_type 2047 && ist->st->discard != AVDISCARD_ALL) { 2048 ost->source_index = j; 2049 found = 1; 2050 } 2051 } 2052 } 2053 if (!found) { 2054 int i= ost->file_index; 2055 av_dump_format(output_files[i], i, output_files[i]->filename, 1); 2056 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n", 2057 ost->file_index, ost->index); 2058 exit_program(1); 2059 } 2060 } 2061 } 2062 ist = &input_streams[ost->source_index]; 2063 ist->discard = 0; 2064 ost->sync_ist = (nb_stream_maps > 0) ? 2065 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index + 2066 stream_maps[n].sync_stream_index] : ist; 2067 } 2068 } 2069 2070 /* for each output stream, we compute the right encoding parameters */ 2071 for(i=0;i<nb_ostreams;i++) { 2072 ost = ost_table[i]; 2073 os = output_files[ost->file_index]; 2074 ist = &input_streams[ost->source_index]; 2075 2076 codec = ost->st->codec; 2077 icodec = ist->st->codec; 2078 2079 if (metadata_streams_autocopy) 2080 av_dict_copy(&ost->st->metadata, ist->st->metadata, 2081 AV_DICT_DONT_OVERWRITE); 2082 2083 ost->st->disposition = ist->st->disposition; 2084 codec->bits_per_raw_sample= icodec->bits_per_raw_sample; 2085 codec->chroma_sample_location = icodec->chroma_sample_location; 2086 2087 if (ost->st->stream_copy) { 2088 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE; 2089 2090 if (extra_size > INT_MAX) 2091 goto fail; 2092 2093 /* if stream_copy is selected, no need to decode or encode */ 2094 codec->codec_id = icodec->codec_id; 2095 codec->codec_type = icodec->codec_type; 2096 2097 if(!codec->codec_tag){ 2098 if( !os->oformat->codec_tag 2099 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id 2100 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0) 2101 codec->codec_tag = icodec->codec_tag; 2102 } 2103 2104 codec->bit_rate = icodec->bit_rate; 2105 codec->rc_max_rate = icodec->rc_max_rate; 2106 codec->rc_buffer_size = icodec->rc_buffer_size; 2107 codec->extradata= av_mallocz(extra_size); 2108 if (!codec->extradata) 2109 goto fail; 2110 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size); 2111 codec->extradata_size= icodec->extradata_size; 2112 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){ 2113 codec->time_base = icodec->time_base; 2114 codec->time_base.num *= icodec->ticks_per_frame; 2115 av_reduce(&codec->time_base.num, &codec->time_base.den, 2116 codec->time_base.num, codec->time_base.den, INT_MAX); 2117 }else 2118 codec->time_base = ist->st->time_base; 2119 switch(codec->codec_type) { 2120 case AVMEDIA_TYPE_AUDIO: 2121 if(audio_volume != 256) { 2122 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n"); 2123 exit_program(1); 2124 } 2125 codec->channel_layout = icodec->channel_layout; 2126 codec->sample_rate = icodec->sample_rate; 2127 codec->channels = icodec->channels; 2128 codec->frame_size = icodec->frame_size; 2129 codec->audio_service_type = icodec->audio_service_type; 2130 codec->block_align= icodec->block_align; 2131 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3) 2132 codec->block_align= 0; 2133 if(codec->codec_id == CODEC_ID_AC3) 2134 codec->block_align= 0; 2135 break; 2136 case AVMEDIA_TYPE_VIDEO: 2137 codec->pix_fmt = icodec->pix_fmt; 2138 codec->width = icodec->width; 2139 codec->height = icodec->height; 2140 codec->has_b_frames = icodec->has_b_frames; 2141 if (!codec->sample_aspect_ratio.num) { 2142 codec->sample_aspect_ratio = 2143 ost->st->sample_aspect_ratio = 2144 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio : 2145 ist->st->codec->sample_aspect_ratio.num ? 2146 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1}; 2147 } 2148 break; 2149 case AVMEDIA_TYPE_SUBTITLE: 2150 codec->width = icodec->width; 2151 codec->height = icodec->height; 2152 break; 2153 case AVMEDIA_TYPE_DATA: 2154 break; 2155 default: 2156 abort(); 2157 } 2158 } else { 2159 if (!ost->enc) 2160 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id); 2161 switch(codec->codec_type) { 2162 case AVMEDIA_TYPE_AUDIO: 2163 ost->fifo= av_fifo_alloc(1024); 2164 if(!ost->fifo) 2165 goto fail; 2166 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE); 2167 if (!codec->sample_rate) { 2168 codec->sample_rate = icodec->sample_rate; 2169 if (icodec->lowres) 2170 codec->sample_rate >>= icodec->lowres; 2171 } 2172 choose_sample_rate(ost->st, ost->enc); 2173 codec->time_base = (AVRational){1, codec->sample_rate}; 2174 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE) 2175 codec->sample_fmt = icodec->sample_fmt; 2176 choose_sample_fmt(ost->st, ost->enc); 2177 if (!codec->channels) 2178 codec->channels = icodec->channels; 2179 codec->channel_layout = icodec->channel_layout; 2180 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels) 2181 codec->channel_layout = 0; 2182 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1; 2183 icodec->request_channels = codec->channels; 2184 ist->decoding_needed = 1; 2185 ost->encoding_needed = 1; 2186 ost->resample_sample_fmt = icodec->sample_fmt; 2187 ost->resample_sample_rate = icodec->sample_rate; 2188 ost->resample_channels = icodec->channels; 2189 break; 2190 case AVMEDIA_TYPE_VIDEO: 2191 if (codec->pix_fmt == PIX_FMT_NONE) 2192 codec->pix_fmt = icodec->pix_fmt; 2193 choose_pixel_fmt(ost->st, ost->enc); 2194 2195 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) { 2196 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n"); 2197 exit_program(1); 2198 } 2199 2200 if (!codec->width || !codec->height) { 2201 codec->width = icodec->width; 2202 codec->height = icodec->height; 2203 } 2204 2205 ost->video_resample = codec->width != icodec->width || 2206 codec->height != icodec->height || 2207 codec->pix_fmt != icodec->pix_fmt; 2208 if (ost->video_resample) { 2209#if !CONFIG_AVFILTER 2210 avcodec_get_frame_defaults(&ost->pict_tmp); 2211 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt, 2212 codec->width, codec->height)) { 2213 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n"); 2214 exit_program(1); 2215 } 2216 ost->img_resample_ctx = sws_getContext( 2217 icodec->width, 2218 icodec->height, 2219 icodec->pix_fmt, 2220 codec->width, 2221 codec->height, 2222 codec->pix_fmt, 2223 ost->sws_flags, NULL, NULL, NULL); 2224 if (ost->img_resample_ctx == NULL) { 2225 fprintf(stderr, "Cannot get resampling context\n"); 2226 exit_program(1); 2227 } 2228#endif 2229 codec->bits_per_raw_sample= 0; 2230 } 2231 2232 ost->resample_height = icodec->height; 2233 ost->resample_width = icodec->width; 2234 ost->resample_pix_fmt= icodec->pix_fmt; 2235 ost->encoding_needed = 1; 2236 ist->decoding_needed = 1; 2237 2238 if (!ost->frame_rate.num) 2239 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1}; 2240 if (ost->enc && ost->enc->supported_framerates && !force_fps) { 2241 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates); 2242 ost->frame_rate = ost->enc->supported_framerates[idx]; 2243 } 2244 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num}; 2245 2246#if CONFIG_AVFILTER 2247 if (configure_video_filters(ist, ost)) { 2248 fprintf(stderr, "Error opening filters!\n"); 2249 exit(1); 2250 } 2251#endif 2252 break; 2253 case AVMEDIA_TYPE_SUBTITLE: 2254 ost->encoding_needed = 1; 2255 ist->decoding_needed = 1; 2256 break; 2257 default: 2258 abort(); 2259 break; 2260 } 2261 /* two pass mode */ 2262 if (ost->encoding_needed && 2263 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) { 2264 char logfilename[1024]; 2265 FILE *f; 2266 2267 snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 2268 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX, 2269 i); 2270 if (codec->flags & CODEC_FLAG_PASS1) { 2271 f = fopen(logfilename, "wb"); 2272 if (!f) { 2273 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno)); 2274 exit_program(1); 2275 } 2276 ost->logfile = f; 2277 } else { 2278 char *logbuffer; 2279 size_t logbuffer_size; 2280 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) { 2281 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename); 2282 exit_program(1); 2283 } 2284 codec->stats_in = logbuffer; 2285 } 2286 } 2287 } 2288 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){ 2289 int size= codec->width * codec->height; 2290 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200); 2291 } 2292 } 2293 2294 if (!bit_buffer) 2295 bit_buffer = av_malloc(bit_buffer_size); 2296 if (!bit_buffer) { 2297 fprintf(stderr, "Cannot allocate %d bytes output buffer\n", 2298 bit_buffer_size); 2299 ret = AVERROR(ENOMEM); 2300 goto fail; 2301 } 2302 2303 /* open each encoder */ 2304 for(i=0;i<nb_ostreams;i++) { 2305 ost = ost_table[i]; 2306 if (ost->encoding_needed) { 2307 AVCodec *codec = ost->enc; 2308 AVCodecContext *dec = input_streams[ost->source_index].st->codec; 2309 if (!codec) { 2310 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d", 2311 ost->st->codec->codec_id, ost->file_index, ost->index); 2312 ret = AVERROR(EINVAL); 2313 goto dump_format; 2314 } 2315 if (dec->subtitle_header) { 2316 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size); 2317 if (!ost->st->codec->subtitle_header) { 2318 ret = AVERROR(ENOMEM); 2319 goto dump_format; 2320 } 2321 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size); 2322 ost->st->codec->subtitle_header_size = dec->subtitle_header_size; 2323 } 2324 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) { 2325 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height", 2326 ost->file_index, ost->index); 2327 ret = AVERROR(EINVAL); 2328 goto dump_format; 2329 } 2330 assert_codec_experimental(ost->st->codec, 1); 2331 assert_avoptions(ost->opts); 2332 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000) 2333 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low." 2334 "It takes bits/s as argument, not kbits/s\n"); 2335 extra_size += ost->st->codec->extradata_size; 2336 } 2337 } 2338 2339 /* open each decoder */ 2340 for (i = 0; i < nb_input_streams; i++) { 2341 ist = &input_streams[i]; 2342 if (ist->decoding_needed) { 2343 AVCodec *codec = ist->dec; 2344 if (!codec) 2345 codec = avcodec_find_decoder(ist->st->codec->codec_id); 2346 if (!codec) { 2347 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d", 2348 ist->st->codec->codec_id, ist->file_index, ist->st->index); 2349 ret = AVERROR(EINVAL); 2350 goto dump_format; 2351 } 2352 2353 /* update requested sample format for the decoder based on the 2354 corresponding encoder sample format */ 2355 for (j = 0; j < nb_ostreams; j++) { 2356 ost = ost_table[j]; 2357 if (ost->source_index == i) { 2358 update_sample_fmt(ist->st->codec, codec, ost->st->codec); 2359 break; 2360 } 2361 } 2362 2363 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) { 2364 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d", 2365 ist->file_index, ist->st->index); 2366 ret = AVERROR(EINVAL); 2367 goto dump_format; 2368 } 2369 assert_codec_experimental(ist->st->codec, 0); 2370 assert_avoptions(ost->opts); 2371 } 2372 } 2373 2374 /* init pts */ 2375 for (i = 0; i < nb_input_streams; i++) { 2376 AVStream *st; 2377 ist = &input_streams[i]; 2378 st= ist->st; 2379 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0; 2380 ist->next_pts = AV_NOPTS_VALUE; 2381 init_pts_correction(&ist->pts_ctx); 2382 ist->is_start = 1; 2383 } 2384 2385 /* set meta data information from input file if required */ 2386 for (i=0;i<nb_meta_data_maps;i++) { 2387 AVFormatContext *files[2]; 2388 AVDictionary **meta[2]; 2389 int j; 2390 2391#define METADATA_CHECK_INDEX(index, nb_elems, desc)\ 2392 if ((index) < 0 || (index) >= (nb_elems)) {\ 2393 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\ 2394 (desc), (index));\ 2395 ret = AVERROR(EINVAL);\ 2396 goto dump_format;\ 2397 } 2398 2399 int out_file_index = meta_data_maps[i][0].file; 2400 int in_file_index = meta_data_maps[i][1].file; 2401 if (in_file_index < 0 || out_file_index < 0) 2402 continue; 2403 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file") 2404 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file") 2405 2406 files[0] = output_files[out_file_index]; 2407 files[1] = input_files[in_file_index].ctx; 2408 2409 for (j = 0; j < 2; j++) { 2410 MetadataMap *map = &meta_data_maps[i][j]; 2411 2412 switch (map->type) { 2413 case 'g': 2414 meta[j] = &files[j]->metadata; 2415 break; 2416 case 's': 2417 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream") 2418 meta[j] = &files[j]->streams[map->index]->metadata; 2419 break; 2420 case 'c': 2421 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter") 2422 meta[j] = &files[j]->chapters[map->index]->metadata; 2423 break; 2424 case 'p': 2425 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program") 2426 meta[j] = &files[j]->programs[map->index]->metadata; 2427 break; 2428 } 2429 } 2430 2431 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE); 2432 } 2433 2434 /* copy global metadata by default */ 2435 if (metadata_global_autocopy) { 2436 2437 for (i = 0; i < nb_output_files; i++) 2438 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata, 2439 AV_DICT_DONT_OVERWRITE); 2440 } 2441 2442 /* copy chapters according to chapter maps */ 2443 for (i = 0; i < nb_chapter_maps; i++) { 2444 int infile = chapter_maps[i].in_file; 2445 int outfile = chapter_maps[i].out_file; 2446 2447 if (infile < 0 || outfile < 0) 2448 continue; 2449 if (infile >= nb_input_files) { 2450 snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile); 2451 ret = AVERROR(EINVAL); 2452 goto dump_format; 2453 } 2454 if (outfile >= nb_output_files) { 2455 snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile); 2456 ret = AVERROR(EINVAL); 2457 goto dump_format; 2458 } 2459 copy_chapters(infile, outfile); 2460 } 2461 2462 /* copy chapters from the first input file that has them*/ 2463 if (!nb_chapter_maps) 2464 for (i = 0; i < nb_input_files; i++) { 2465 if (!input_files[i].ctx->nb_chapters) 2466 continue; 2467 2468 for (j = 0; j < nb_output_files; j++) 2469 if ((ret = copy_chapters(i, j)) < 0) 2470 goto dump_format; 2471 break; 2472 } 2473 2474 /* open files and write file headers */ 2475 for(i=0;i<nb_output_files;i++) { 2476 os = output_files[i]; 2477 if (avformat_write_header(os, &output_opts[i]) < 0) { 2478 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i); 2479 ret = AVERROR(EINVAL); 2480 goto dump_format; 2481 } 2482 assert_avoptions(output_opts[i]); 2483 if (strcmp(output_files[i]->oformat->name, "rtp")) { 2484 want_sdp = 0; 2485 } 2486 } 2487 2488 dump_format: 2489 /* dump the file output parameters - cannot be done before in case 2490 of stream copy */ 2491 for(i=0;i<nb_output_files;i++) { 2492 av_dump_format(output_files[i], i, output_files[i]->filename, 1); 2493 } 2494 2495 /* dump the stream mapping */ 2496 if (verbose >= 0) { 2497 fprintf(stderr, "Stream mapping:\n"); 2498 for(i=0;i<nb_ostreams;i++) { 2499 ost = ost_table[i]; 2500 fprintf(stderr, " Stream #%d.%d -> #%d.%d", 2501 input_streams[ost->source_index].file_index, 2502 input_streams[ost->source_index].st->index, 2503 ost->file_index, 2504 ost->index); 2505 if (ost->sync_ist != &input_streams[ost->source_index]) 2506 fprintf(stderr, " [sync #%d.%d]", 2507 ost->sync_ist->file_index, 2508 ost->sync_ist->st->index); 2509 fprintf(stderr, "\n"); 2510 } 2511 } 2512 2513 if (ret) { 2514 fprintf(stderr, "%s\n", error); 2515 goto fail; 2516 } 2517 2518 if (want_sdp) { 2519 print_sdp(output_files, nb_output_files); 2520 } 2521 2522 if (verbose >= 0) 2523 fprintf(stderr, "Press ctrl-c to stop encoding\n"); 2524 term_init(); 2525 2526 timer_start = av_gettime(); 2527 2528 for(; received_sigterm == 0;) { 2529 int file_index, ist_index; 2530 AVPacket pkt; 2531 double ipts_min; 2532 double opts_min; 2533 2534 redo: 2535 ipts_min= 1e100; 2536 opts_min= 1e100; 2537 2538 /* select the stream that we must read now by looking at the 2539 smallest output pts */ 2540 file_index = -1; 2541 for(i=0;i<nb_ostreams;i++) { 2542 double ipts, opts; 2543 ost = ost_table[i]; 2544 os = output_files[ost->file_index]; 2545 ist = &input_streams[ost->source_index]; 2546 if(ist->is_past_recording_time || no_packet[ist->file_index]) 2547 continue; 2548 opts = ost->st->pts.val * av_q2d(ost->st->time_base); 2549 ipts = (double)ist->pts; 2550 if (!input_files[ist->file_index].eof_reached){ 2551 if(ipts < ipts_min) { 2552 ipts_min = ipts; 2553 if(input_sync ) file_index = ist->file_index; 2554 } 2555 if(opts < opts_min) { 2556 opts_min = opts; 2557 if(!input_sync) file_index = ist->file_index; 2558 } 2559 } 2560 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){ 2561 file_index= -1; 2562 break; 2563 } 2564 } 2565 /* if none, if is finished */ 2566 if (file_index < 0) { 2567 if(no_packet_count){ 2568 no_packet_count=0; 2569 memset(no_packet, 0, sizeof(no_packet)); 2570 usleep(10000); 2571 continue; 2572 } 2573 break; 2574 } 2575 2576 /* finish if limit size exhausted */ 2577 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb)) 2578 break; 2579 2580 /* read a frame from it and output it in the fifo */ 2581 is = input_files[file_index].ctx; 2582 ret= av_read_frame(is, &pkt); 2583 if(ret == AVERROR(EAGAIN)){ 2584 no_packet[file_index]=1; 2585 no_packet_count++; 2586 continue; 2587 } 2588 if (ret < 0) { 2589 input_files[file_index].eof_reached = 1; 2590 if (opt_shortest) 2591 break; 2592 else 2593 continue; 2594 } 2595 2596 no_packet_count=0; 2597 memset(no_packet, 0, sizeof(no_packet)); 2598 2599 if (do_pkt_dump) { 2600 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump, 2601 is->streams[pkt.stream_index]); 2602 } 2603 /* the following test is needed in case new streams appear 2604 dynamically in stream : we ignore them */ 2605 if (pkt.stream_index >= input_files[file_index].nb_streams) 2606 goto discard_packet; 2607 ist_index = input_files[file_index].ist_index + pkt.stream_index; 2608 ist = &input_streams[ist_index]; 2609 if (ist->discard) 2610 goto discard_packet; 2611 2612 if (pkt.dts != AV_NOPTS_VALUE) 2613 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base); 2614 if (pkt.pts != AV_NOPTS_VALUE) 2615 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base); 2616 2617 if (ist->ts_scale) { 2618 if(pkt.pts != AV_NOPTS_VALUE) 2619 pkt.pts *= ist->ts_scale; 2620 if(pkt.dts != AV_NOPTS_VALUE) 2621 pkt.dts *= ist->ts_scale; 2622 } 2623 2624// fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type); 2625 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE 2626 && (is->iformat->flags & AVFMT_TS_DISCONT)) { 2627 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q); 2628 int64_t delta= pkt_dts - ist->next_pts; 2629 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){ 2630 input_files[ist->file_index].ts_offset -= delta; 2631 if (verbose > 2) 2632 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", 2633 delta, input_files[ist->file_index].ts_offset); 2634 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base); 2635 if(pkt.pts != AV_NOPTS_VALUE) 2636 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base); 2637 } 2638 } 2639 2640 /* finish if recording time exhausted */ 2641 if (recording_time != INT64_MAX && 2642 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) { 2643 ist->is_past_recording_time = 1; 2644 goto discard_packet; 2645 } 2646 2647 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size); 2648 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) { 2649 2650 if (verbose >= 0) 2651 fprintf(stderr, "Error while decoding stream #%d.%d\n", 2652 ist->file_index, ist->st->index); 2653 if (exit_on_error) 2654 exit_program(1); 2655 av_free_packet(&pkt); 2656 goto redo; 2657 } 2658 2659 discard_packet: 2660 av_free_packet(&pkt); 2661 2662 /* dump report by using the output first video and audio streams */ 2663 print_report(output_files, ost_table, nb_ostreams, 0); 2664 } 2665 2666 /* at the end of stream, we must flush the decoder buffers */ 2667 for (i = 0; i < nb_input_streams; i++) { 2668 ist = &input_streams[i]; 2669 if (ist->decoding_needed) { 2670 output_packet(ist, i, ost_table, nb_ostreams, NULL); 2671 } 2672 } 2673 2674 term_exit(); 2675 2676 /* write the trailer if needed and close file */ 2677 for(i=0;i<nb_output_files;i++) { 2678 os = output_files[i]; 2679 av_write_trailer(os); 2680 } 2681 2682 /* dump report by using the first video and audio streams */ 2683 print_report(output_files, ost_table, nb_ostreams, 1); 2684 2685 /* close each encoder */ 2686 for(i=0;i<nb_ostreams;i++) { 2687 ost = ost_table[i]; 2688 if (ost->encoding_needed) { 2689 av_freep(&ost->st->codec->stats_in); 2690 avcodec_close(ost->st->codec); 2691 } 2692#if CONFIG_AVFILTER 2693 avfilter_graph_free(&ost->graph); 2694#endif 2695 } 2696 2697 /* close each decoder */ 2698 for (i = 0; i < nb_input_streams; i++) { 2699 ist = &input_streams[i]; 2700 if (ist->decoding_needed) { 2701 avcodec_close(ist->st->codec); 2702 } 2703 } 2704 2705 /* finished ! */ 2706 ret = 0; 2707 2708 fail: 2709 av_freep(&bit_buffer); 2710 2711 if (ost_table) { 2712 for(i=0;i<nb_ostreams;i++) { 2713 ost = ost_table[i]; 2714 if (ost) { 2715 if (ost->st->stream_copy) 2716 av_freep(&ost->st->codec->extradata); 2717 if (ost->logfile) { 2718 fclose(ost->logfile); 2719 ost->logfile = NULL; 2720 } 2721 av_fifo_free(ost->fifo); /* works even if fifo is not 2722 initialized but set to zero */ 2723 av_freep(&ost->st->codec->subtitle_header); 2724 av_free(ost->pict_tmp.data[0]); 2725 av_free(ost->forced_kf_pts); 2726 if (ost->video_resample) 2727 sws_freeContext(ost->img_resample_ctx); 2728 if (ost->resample) 2729 audio_resample_close(ost->resample); 2730 if (ost->reformat_ctx) 2731 av_audio_convert_free(ost->reformat_ctx); 2732 av_dict_free(&ost->opts); 2733 av_free(ost); 2734 } 2735 } 2736 av_free(ost_table); 2737 } 2738 return ret; 2739} 2740 2741static int opt_format(const char *opt, const char *arg) 2742{ 2743 last_asked_format = arg; 2744 return 0; 2745} 2746 2747static int opt_video_rc_override_string(const char *opt, const char *arg) 2748{ 2749 video_rc_override_string = arg; 2750 return 0; 2751} 2752 2753static int opt_me_threshold(const char *opt, const char *arg) 2754{ 2755 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX); 2756 return 0; 2757} 2758 2759static int opt_verbose(const char *opt, const char *arg) 2760{ 2761 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10); 2762 return 0; 2763} 2764 2765static int opt_frame_rate(const char *opt, const char *arg) 2766{ 2767 if (av_parse_video_rate(&frame_rate, arg) < 0) { 2768 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg); 2769 exit_program(1); 2770 } 2771 return 0; 2772} 2773 2774static int opt_frame_crop(const char *opt, const char *arg) 2775{ 2776 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt); 2777 return AVERROR(EINVAL); 2778} 2779 2780static int opt_frame_size(const char *opt, const char *arg) 2781{ 2782 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) { 2783 fprintf(stderr, "Incorrect frame size\n"); 2784 return AVERROR(EINVAL); 2785 } 2786 return 0; 2787} 2788 2789static int opt_pad(const char *opt, const char *arg) { 2790 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt); 2791 return -1; 2792} 2793 2794static int opt_frame_pix_fmt(const char *opt, const char *arg) 2795{ 2796 if (strcmp(arg, "list")) { 2797 frame_pix_fmt = av_get_pix_fmt(arg); 2798 if (frame_pix_fmt == PIX_FMT_NONE) { 2799 fprintf(stderr, "Unknown pixel format requested: %s\n", arg); 2800 return AVERROR(EINVAL); 2801 } 2802 } else { 2803 show_pix_fmts(); 2804 exit_program(0); 2805 } 2806 return 0; 2807} 2808 2809static int opt_frame_aspect_ratio(const char *opt, const char *arg) 2810{ 2811 int x = 0, y = 0; 2812 double ar = 0; 2813 const char *p; 2814 char *end; 2815 2816 p = strchr(arg, ':'); 2817 if (p) { 2818 x = strtol(arg, &end, 10); 2819 if (end == p) 2820 y = strtol(end+1, &end, 10); 2821 if (x > 0 && y > 0) 2822 ar = (double)x / (double)y; 2823 } else 2824 ar = strtod(arg, NULL); 2825 2826 if (!ar) { 2827 fprintf(stderr, "Incorrect aspect ratio specification.\n"); 2828 return AVERROR(EINVAL); 2829 } 2830 frame_aspect_ratio = ar; 2831 return 0; 2832} 2833 2834static int opt_metadata(const char *opt, const char *arg) 2835{ 2836 char *mid= strchr(arg, '='); 2837 2838 if(!mid){ 2839 fprintf(stderr, "Missing =\n"); 2840 exit_program(1); 2841 } 2842 *mid++= 0; 2843 2844 av_dict_set(&metadata, arg, mid, 0); 2845 2846 return 0; 2847} 2848 2849static int opt_qscale(const char *opt, const char *arg) 2850{ 2851 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255); 2852 if (video_qscale == 0) { 2853 fprintf(stderr, "qscale must be > 0.0 and <= 255\n"); 2854 return AVERROR(EINVAL); 2855 } 2856 return 0; 2857} 2858 2859static int opt_top_field_first(const char *opt, const char *arg) 2860{ 2861 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1); 2862 return 0; 2863} 2864 2865static int opt_thread_count(const char *opt, const char *arg) 2866{ 2867 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); 2868#if !HAVE_THREADS 2869 if (verbose >= 0) 2870 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n"); 2871#endif 2872 return 0; 2873} 2874 2875static int opt_audio_sample_fmt(const char *opt, const char *arg) 2876{ 2877 if (strcmp(arg, "list")) { 2878 audio_sample_fmt = av_get_sample_fmt(arg); 2879 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) { 2880 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg); 2881 return AVERROR(EINVAL); 2882 } 2883 } else { 2884 int i; 2885 char fmt_str[128]; 2886 for (i = -1; i < AV_SAMPLE_FMT_NB; i++) 2887 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i)); 2888 exit_program(0); 2889 } 2890 return 0; 2891} 2892 2893static int opt_audio_rate(const char *opt, const char *arg) 2894{ 2895 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); 2896 return 0; 2897} 2898 2899static int opt_audio_channels(const char *opt, const char *arg) 2900{ 2901 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); 2902 return 0; 2903} 2904 2905static int opt_video_channel(const char *opt, const char *arg) 2906{ 2907 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n"); 2908 opt_default("channel", arg); 2909 return 0; 2910} 2911 2912static int opt_video_standard(const char *opt, const char *arg) 2913{ 2914 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n"); 2915 opt_default("standard", arg); 2916 return 0; 2917} 2918 2919static int opt_codec(int *pstream_copy, char **pcodec_name, 2920 int codec_type, const char *arg) 2921{ 2922 av_freep(pcodec_name); 2923 if (!strcmp(arg, "copy")) { 2924 *pstream_copy = 1; 2925 } else { 2926 *pcodec_name = av_strdup(arg); 2927 } 2928 return 0; 2929} 2930 2931static int opt_audio_codec(const char *opt, const char *arg) 2932{ 2933 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg); 2934} 2935 2936static int opt_video_codec(const char *opt, const char *arg) 2937{ 2938 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg); 2939} 2940 2941static int opt_subtitle_codec(const char *opt, const char *arg) 2942{ 2943 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg); 2944} 2945 2946static int opt_data_codec(const char *opt, const char *arg) 2947{ 2948 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg); 2949} 2950 2951static int opt_codec_tag(const char *opt, const char *arg) 2952{ 2953 char *tail; 2954 uint32_t *codec_tag; 2955 2956 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag : 2957 !strcmp(opt, "vtag") ? &video_codec_tag : 2958 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL; 2959 if (!codec_tag) 2960 return -1; 2961 2962 *codec_tag = strtol(arg, &tail, 0); 2963 if (!tail || *tail) 2964 *codec_tag = AV_RL32(arg); 2965 2966 return 0; 2967} 2968 2969static int opt_map(const char *opt, const char *arg) 2970{ 2971 StreamMap *m; 2972 char *p; 2973 2974 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1); 2975 m = &stream_maps[nb_stream_maps-1]; 2976 2977 m->file_index = strtol(arg, &p, 0); 2978 if (*p) 2979 p++; 2980 2981 m->stream_index = strtol(p, &p, 0); 2982 if (*p) { 2983 p++; 2984 m->sync_file_index = strtol(p, &p, 0); 2985 if (*p) 2986 p++; 2987 m->sync_stream_index = strtol(p, &p, 0); 2988 } else { 2989 m->sync_file_index = m->file_index; 2990 m->sync_stream_index = m->stream_index; 2991 } 2992 return 0; 2993} 2994 2995static void parse_meta_type(char *arg, char *type, int *index, char **endptr) 2996{ 2997 *endptr = arg; 2998 if (*arg == ',') { 2999 *type = *(++arg); 3000 switch (*arg) { 3001 case 'g': 3002 break; 3003 case 's': 3004 case 'c': 3005 case 'p': 3006 *index = strtol(++arg, endptr, 0); 3007 break; 3008 default: 3009 fprintf(stderr, "Invalid metadata type %c.\n", *arg); 3010 exit_program(1); 3011 } 3012 } else 3013 *type = 'g'; 3014} 3015 3016static int opt_map_metadata(const char *opt, const char *arg) 3017{ 3018 MetadataMap *m, *m1; 3019 char *p; 3020 3021 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps), 3022 &nb_meta_data_maps, nb_meta_data_maps + 1); 3023 3024 m = &meta_data_maps[nb_meta_data_maps - 1][0]; 3025 m->file = strtol(arg, &p, 0); 3026 parse_meta_type(p, &m->type, &m->index, &p); 3027 if (*p) 3028 p++; 3029 3030 m1 = &meta_data_maps[nb_meta_data_maps - 1][1]; 3031 m1->file = strtol(p, &p, 0); 3032 parse_meta_type(p, &m1->type, &m1->index, &p); 3033 3034 if (m->type == 'g' || m1->type == 'g') 3035 metadata_global_autocopy = 0; 3036 if (m->type == 's' || m1->type == 's') 3037 metadata_streams_autocopy = 0; 3038 if (m->type == 'c' || m1->type == 'c') 3039 metadata_chapters_autocopy = 0; 3040 3041 return 0; 3042} 3043 3044static int opt_map_meta_data(const char *opt, const char *arg) 3045{ 3046 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. " 3047 "Use -map_metadata instead.\n"); 3048 return opt_map_metadata(opt, arg); 3049} 3050 3051static int opt_map_chapters(const char *opt, const char *arg) 3052{ 3053 ChapterMap *c; 3054 char *p; 3055 3056 chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps, 3057 nb_chapter_maps + 1); 3058 c = &chapter_maps[nb_chapter_maps - 1]; 3059 c->out_file = strtol(arg, &p, 0); 3060 if (*p) 3061 p++; 3062 3063 c->in_file = strtol(p, &p, 0); 3064 return 0; 3065} 3066 3067static int opt_input_ts_scale(const char *opt, const char *arg) 3068{ 3069 unsigned int stream; 3070 double scale; 3071 char *p; 3072 3073 stream = strtol(arg, &p, 0); 3074 if (*p) 3075 p++; 3076 scale= strtod(p, &p); 3077 3078 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1); 3079 ts_scale[stream] = scale; 3080 return 0; 3081} 3082 3083static int opt_recording_time(const char *opt, const char *arg) 3084{ 3085 recording_time = parse_time_or_die(opt, arg, 1); 3086 return 0; 3087} 3088 3089static int opt_start_time(const char *opt, const char *arg) 3090{ 3091 start_time = parse_time_or_die(opt, arg, 1); 3092 return 0; 3093} 3094 3095static int opt_recording_timestamp(const char *opt, const char *arg) 3096{ 3097 char buf[128]; 3098 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6; 3099 struct tm time = *gmtime((time_t*)&recording_timestamp); 3100 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time); 3101 opt_metadata("metadata", buf); 3102 3103 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata " 3104 "tag instead.\n", opt); 3105 return 0; 3106} 3107 3108static int opt_input_ts_offset(const char *opt, const char *arg) 3109{ 3110 input_ts_offset = parse_time_or_die(opt, arg, 1); 3111 return 0; 3112} 3113 3114static enum CodecID find_codec_or_die(const char *name, int type, int encoder) 3115{ 3116 const char *codec_string = encoder ? "encoder" : "decoder"; 3117 AVCodec *codec; 3118 3119 if(!name) 3120 return CODEC_ID_NONE; 3121 codec = encoder ? 3122 avcodec_find_encoder_by_name(name) : 3123 avcodec_find_decoder_by_name(name); 3124 if(!codec) { 3125 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name); 3126 exit_program(1); 3127 } 3128 if(codec->type != type) { 3129 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name); 3130 exit_program(1); 3131 } 3132 return codec->id; 3133} 3134 3135static int opt_input_file(const char *opt, const char *filename) 3136{ 3137 AVFormatContext *ic; 3138 AVInputFormat *file_iformat = NULL; 3139 int err, i, ret, rfps, rfps_base; 3140 int64_t timestamp; 3141 uint8_t buf[128]; 3142 AVDictionary **opts; 3143 int orig_nb_streams; // number of streams before avformat_find_stream_info 3144 3145 if (last_asked_format) { 3146 if (!(file_iformat = av_find_input_format(last_asked_format))) { 3147 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format); 3148 exit_program(1); 3149 } 3150 last_asked_format = NULL; 3151 } 3152 3153 if (!strcmp(filename, "-")) 3154 filename = "pipe:"; 3155 3156 using_stdin |= !strncmp(filename, "pipe:", 5) || 3157 !strcmp(filename, "/dev/stdin"); 3158 3159 /* get default parameters from command line */ 3160 ic = avformat_alloc_context(); 3161 if (!ic) { 3162 print_error(filename, AVERROR(ENOMEM)); 3163 exit_program(1); 3164 } 3165 if (audio_sample_rate) { 3166 snprintf(buf, sizeof(buf), "%d", audio_sample_rate); 3167 av_dict_set(&format_opts, "sample_rate", buf, 0); 3168 } 3169 if (audio_channels) { 3170 snprintf(buf, sizeof(buf), "%d", audio_channels); 3171 av_dict_set(&format_opts, "channels", buf, 0); 3172 } 3173 if (frame_rate.num) { 3174 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den); 3175 av_dict_set(&format_opts, "framerate", buf, 0); 3176 } 3177 if (frame_width && frame_height) { 3178 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height); 3179 av_dict_set(&format_opts, "video_size", buf, 0); 3180 } 3181 if (frame_pix_fmt != PIX_FMT_NONE) 3182 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0); 3183 3184 ic->video_codec_id = 3185 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0); 3186 ic->audio_codec_id = 3187 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0); 3188 ic->subtitle_codec_id= 3189 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0); 3190 ic->flags |= AVFMT_FLAG_NONBLOCK; 3191 3192 /* open the input file with generic libav function */ 3193 err = avformat_open_input(&ic, filename, file_iformat, &format_opts); 3194 if (err < 0) { 3195 print_error(filename, err); 3196 exit_program(1); 3197 } 3198 assert_avoptions(format_opts); 3199 3200 if(opt_programid) { 3201 int i, j; 3202 int found=0; 3203 for(i=0; i<ic->nb_streams; i++){ 3204 ic->streams[i]->discard= AVDISCARD_ALL; 3205 } 3206 for(i=0; i<ic->nb_programs; i++){ 3207 AVProgram *p= ic->programs[i]; 3208 if(p->id != opt_programid){ 3209 p->discard = AVDISCARD_ALL; 3210 }else{ 3211 found=1; 3212 for(j=0; j<p->nb_stream_indexes; j++){ 3213 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT; 3214 } 3215 } 3216 } 3217 if(!found){ 3218 fprintf(stderr, "Specified program id not found\n"); 3219 exit_program(1); 3220 } 3221 opt_programid=0; 3222 } 3223 3224 if (loop_input) { 3225 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n"); 3226 ic->loop_input = loop_input; 3227 } 3228 3229 /* Set AVCodecContext options for avformat_find_stream_info */ 3230 opts = setup_find_stream_info_opts(ic, codec_opts); 3231 orig_nb_streams = ic->nb_streams; 3232 3233 /* If not enough info to get the stream parameters, we decode the 3234 first frames to get it. (used in mpeg case for example) */ 3235 ret = avformat_find_stream_info(ic, opts); 3236 if (ret < 0 && verbose >= 0) { 3237 fprintf(stderr, "%s: could not find codec parameters\n", filename); 3238 av_close_input_file(ic); 3239 exit_program(1); 3240 } 3241 3242 timestamp = start_time; 3243 /* add the stream start time */ 3244 if (ic->start_time != AV_NOPTS_VALUE) 3245 timestamp += ic->start_time; 3246 3247 /* if seeking requested, we execute it */ 3248 if (start_time != 0) { 3249 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD); 3250 if (ret < 0) { 3251 fprintf(stderr, "%s: could not seek to position %0.3f\n", 3252 filename, (double)timestamp / AV_TIME_BASE); 3253 } 3254 /* reset seek info */ 3255 start_time = 0; 3256 } 3257 3258 /* update the current parameters so that they match the one of the input stream */ 3259 for(i=0;i<ic->nb_streams;i++) { 3260 AVStream *st = ic->streams[i]; 3261 AVCodecContext *dec = st->codec; 3262 InputStream *ist; 3263 3264 dec->thread_count = thread_count; 3265 3266 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1); 3267 ist = &input_streams[nb_input_streams - 1]; 3268 ist->st = st; 3269 ist->file_index = nb_input_files; 3270 ist->discard = 1; 3271 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st); 3272 3273 if (i < nb_ts_scale) 3274 ist->ts_scale = ts_scale[i]; 3275 3276 switch (dec->codec_type) { 3277 case AVMEDIA_TYPE_AUDIO: 3278 ist->dec = avcodec_find_decoder_by_name(audio_codec_name); 3279 if(audio_disable) 3280 st->discard= AVDISCARD_ALL; 3281 break; 3282 case AVMEDIA_TYPE_VIDEO: 3283 ist->dec = avcodec_find_decoder_by_name(video_codec_name); 3284 rfps = ic->streams[i]->r_frame_rate.num; 3285 rfps_base = ic->streams[i]->r_frame_rate.den; 3286 if (dec->lowres) { 3287 dec->flags |= CODEC_FLAG_EMU_EDGE; 3288 dec->height >>= dec->lowres; 3289 dec->width >>= dec->lowres; 3290 } 3291 if(me_threshold) 3292 dec->debug |= FF_DEBUG_MV; 3293 3294 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) { 3295 3296 if (verbose >= 0) 3297 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n", 3298 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num, 3299 3300 (float)rfps / rfps_base, rfps, rfps_base); 3301 } 3302 3303 if(video_disable) 3304 st->discard= AVDISCARD_ALL; 3305 else if(video_discard) 3306 st->discard= video_discard; 3307 break; 3308 case AVMEDIA_TYPE_DATA: 3309 break; 3310 case AVMEDIA_TYPE_SUBTITLE: 3311 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name); 3312 if(subtitle_disable) 3313 st->discard = AVDISCARD_ALL; 3314 break; 3315 case AVMEDIA_TYPE_ATTACHMENT: 3316 case AVMEDIA_TYPE_UNKNOWN: 3317 break; 3318 default: 3319 abort(); 3320 } 3321 } 3322 3323 /* dump the file content */ 3324 if (verbose >= 0) 3325 av_dump_format(ic, nb_input_files, filename, 0); 3326 3327 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1); 3328 input_files[nb_input_files - 1].ctx = ic; 3329 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams; 3330 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp); 3331 input_files[nb_input_files - 1].nb_streams = ic->nb_streams; 3332 3333 frame_rate = (AVRational){0, 0}; 3334 frame_pix_fmt = PIX_FMT_NONE; 3335 frame_height = 0; 3336 frame_width = 0; 3337 audio_sample_rate = 0; 3338 audio_channels = 0; 3339 audio_sample_fmt = AV_SAMPLE_FMT_NONE; 3340 av_freep(&ts_scale); 3341 nb_ts_scale = 0; 3342 3343 for (i = 0; i < orig_nb_streams; i++) 3344 av_dict_free(&opts[i]); 3345 av_freep(&opts); 3346 av_freep(&video_codec_name); 3347 av_freep(&audio_codec_name); 3348 av_freep(&subtitle_codec_name); 3349 uninit_opts(); 3350 init_opts(); 3351 return 0; 3352} 3353 3354static void check_inputs(int *has_video_ptr, 3355 int *has_audio_ptr, 3356 int *has_subtitle_ptr, 3357 int *has_data_ptr) 3358{ 3359 int has_video, has_audio, has_subtitle, has_data, i, j; 3360 AVFormatContext *ic; 3361 3362 has_video = 0; 3363 has_audio = 0; 3364 has_subtitle = 0; 3365 has_data = 0; 3366 3367 for(j=0;j<nb_input_files;j++) { 3368 ic = input_files[j].ctx; 3369 for(i=0;i<ic->nb_streams;i++) { 3370 AVCodecContext *enc = ic->streams[i]->codec; 3371 switch(enc->codec_type) { 3372 case AVMEDIA_TYPE_AUDIO: 3373 has_audio = 1; 3374 break; 3375 case AVMEDIA_TYPE_VIDEO: 3376 has_video = 1; 3377 break; 3378 case AVMEDIA_TYPE_SUBTITLE: 3379 has_subtitle = 1; 3380 break; 3381 case AVMEDIA_TYPE_DATA: 3382 case AVMEDIA_TYPE_ATTACHMENT: 3383 case AVMEDIA_TYPE_UNKNOWN: 3384 has_data = 1; 3385 break; 3386 default: 3387 abort(); 3388 } 3389 } 3390 } 3391 *has_video_ptr = has_video; 3392 *has_audio_ptr = has_audio; 3393 *has_subtitle_ptr = has_subtitle; 3394 *has_data_ptr = has_data; 3395} 3396 3397static void new_video_stream(AVFormatContext *oc, int file_idx) 3398{ 3399 AVStream *st; 3400 OutputStream *ost; 3401 AVCodecContext *video_enc; 3402 enum CodecID codec_id = CODEC_ID_NONE; 3403 AVCodec *codec= NULL; 3404 3405 if(!video_stream_copy){ 3406 if (video_codec_name) { 3407 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1); 3408 codec = avcodec_find_encoder_by_name(video_codec_name); 3409 } else { 3410 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO); 3411 codec = avcodec_find_encoder(codec_id); 3412 } 3413 } 3414 3415 ost = new_output_stream(oc, file_idx, codec); 3416 st = ost->st; 3417 if (!video_stream_copy) { 3418 ost->frame_aspect_ratio = frame_aspect_ratio; 3419 frame_aspect_ratio = 0; 3420#if CONFIG_AVFILTER 3421 ost->avfilter= vfilters; 3422 vfilters = NULL; 3423#endif 3424 } 3425 3426 ost->bitstream_filters = video_bitstream_filters; 3427 video_bitstream_filters= NULL; 3428 3429 st->codec->thread_count= thread_count; 3430 3431 video_enc = st->codec; 3432 3433 if(video_codec_tag) 3434 video_enc->codec_tag= video_codec_tag; 3435 3436 if(oc->oformat->flags & AVFMT_GLOBALHEADER) { 3437 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER; 3438 } 3439 3440 video_enc->codec_type = AVMEDIA_TYPE_VIDEO; 3441 if (video_stream_copy) { 3442 st->stream_copy = 1; 3443 video_enc->sample_aspect_ratio = 3444 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255); 3445 } else { 3446 const char *p; 3447 int i; 3448 3449 if (frame_rate.num) 3450 ost->frame_rate = frame_rate; 3451 video_enc->codec_id = codec_id; 3452 3453 video_enc->width = frame_width; 3454 video_enc->height = frame_height; 3455 video_enc->pix_fmt = frame_pix_fmt; 3456 st->sample_aspect_ratio = video_enc->sample_aspect_ratio; 3457 3458 if (intra_only) 3459 video_enc->gop_size = 0; 3460 if (video_qscale || same_quality) { 3461 video_enc->flags |= CODEC_FLAG_QSCALE; 3462 video_enc->global_quality = FF_QP2LAMBDA * video_qscale; 3463 } 3464 3465 if(intra_matrix) 3466 video_enc->intra_matrix = intra_matrix; 3467 if(inter_matrix) 3468 video_enc->inter_matrix = inter_matrix; 3469 3470 p= video_rc_override_string; 3471 for(i=0; p; i++){ 3472 int start, end, q; 3473 int e=sscanf(p, "%d,%d,%d", &start, &end, &q); 3474 if(e!=3){ 3475 fprintf(stderr, "error parsing rc_override\n"); 3476 exit_program(1); 3477 } 3478 video_enc->rc_override= 3479 av_realloc(video_enc->rc_override, 3480 sizeof(RcOverride)*(i+1)); 3481 video_enc->rc_override[i].start_frame= start; 3482 video_enc->rc_override[i].end_frame = end; 3483 if(q>0){ 3484 video_enc->rc_override[i].qscale= q; 3485 video_enc->rc_override[i].quality_factor= 1.0; 3486 } 3487 else{ 3488 video_enc->rc_override[i].qscale= 0; 3489 video_enc->rc_override[i].quality_factor= -q/100.0; 3490 } 3491 p= strchr(p, '/'); 3492 if(p) p++; 3493 } 3494 video_enc->rc_override_count=i; 3495 if (!video_enc->rc_initial_buffer_occupancy) 3496 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4; 3497 video_enc->me_threshold= me_threshold; 3498 video_enc->intra_dc_precision= intra_dc_precision - 8; 3499 3500 if (do_psnr) 3501 video_enc->flags|= CODEC_FLAG_PSNR; 3502 3503 /* two pass mode */ 3504 if (do_pass) { 3505 if (do_pass == 1) { 3506 video_enc->flags |= CODEC_FLAG_PASS1; 3507 } else { 3508 video_enc->flags |= CODEC_FLAG_PASS2; 3509 } 3510 } 3511 3512 if (forced_key_frames) 3513 parse_forced_key_frames(forced_key_frames, ost, video_enc); 3514 } 3515 if (video_language) { 3516 av_dict_set(&st->metadata, "language", video_language, 0); 3517 av_freep(&video_language); 3518 } 3519 3520 /* reset some key parameters */ 3521 video_disable = 0; 3522 av_freep(&video_codec_name); 3523 av_freep(&forced_key_frames); 3524 video_stream_copy = 0; 3525 frame_pix_fmt = PIX_FMT_NONE; 3526} 3527 3528static void new_audio_stream(AVFormatContext *oc, int file_idx) 3529{ 3530 AVStream *st; 3531 OutputStream *ost; 3532 AVCodec *codec= NULL; 3533 AVCodecContext *audio_enc; 3534 enum CodecID codec_id = CODEC_ID_NONE; 3535 3536 if(!audio_stream_copy){ 3537 if (audio_codec_name) { 3538 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1); 3539 codec = avcodec_find_encoder_by_name(audio_codec_name); 3540 } else { 3541 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO); 3542 codec = avcodec_find_encoder(codec_id); 3543 } 3544 } 3545 ost = new_output_stream(oc, file_idx, codec); 3546 st = ost->st; 3547 3548 ost->bitstream_filters = audio_bitstream_filters; 3549 audio_bitstream_filters= NULL; 3550 3551 st->codec->thread_count= thread_count; 3552 3553 audio_enc = st->codec; 3554 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO; 3555 3556 if(audio_codec_tag) 3557 audio_enc->codec_tag= audio_codec_tag; 3558 3559 if (oc->oformat->flags & AVFMT_GLOBALHEADER) { 3560 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER; 3561 } 3562 if (audio_stream_copy) { 3563 st->stream_copy = 1; 3564 } else { 3565 audio_enc->codec_id = codec_id; 3566 3567 if (audio_qscale > QSCALE_NONE) { 3568 audio_enc->flags |= CODEC_FLAG_QSCALE; 3569 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale; 3570 } 3571 if (audio_channels) 3572 audio_enc->channels = audio_channels; 3573 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE) 3574 audio_enc->sample_fmt = audio_sample_fmt; 3575 if (audio_sample_rate) 3576 audio_enc->sample_rate = audio_sample_rate; 3577 } 3578 if (audio_language) { 3579 av_dict_set(&st->metadata, "language", audio_language, 0); 3580 av_freep(&audio_language); 3581 } 3582 3583 /* reset some key parameters */ 3584 audio_disable = 0; 3585 av_freep(&audio_codec_name); 3586 audio_stream_copy = 0; 3587} 3588 3589static void new_data_stream(AVFormatContext *oc, int file_idx) 3590{ 3591 AVStream *st; 3592 OutputStream *ost; 3593 AVCodecContext *data_enc; 3594 3595 ost = new_output_stream(oc, file_idx, NULL); 3596 st = ost->st; 3597 data_enc = st->codec; 3598 if (!data_stream_copy) { 3599 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n"); 3600 exit_program(1); 3601 } 3602 3603 data_enc->codec_type = AVMEDIA_TYPE_DATA; 3604 3605 if (data_codec_tag) 3606 data_enc->codec_tag= data_codec_tag; 3607 3608 if (oc->oformat->flags & AVFMT_GLOBALHEADER) { 3609 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER; 3610 } 3611 if (data_stream_copy) { 3612 st->stream_copy = 1; 3613 } 3614 3615 data_disable = 0; 3616 av_freep(&data_codec_name); 3617 data_stream_copy = 0; 3618} 3619 3620static void new_subtitle_stream(AVFormatContext *oc, int file_idx) 3621{ 3622 AVStream *st; 3623 OutputStream *ost; 3624 AVCodec *codec=NULL; 3625 AVCodecContext *subtitle_enc; 3626 enum CodecID codec_id = CODEC_ID_NONE; 3627 3628 if(!subtitle_stream_copy){ 3629 if (subtitle_codec_name) { 3630 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1); 3631 codec = avcodec_find_encoder_by_name(subtitle_codec_name); 3632 } else { 3633 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE); 3634 codec = avcodec_find_encoder(codec_id); 3635 } 3636 } 3637 ost = new_output_stream(oc, file_idx, codec); 3638 st = ost->st; 3639 subtitle_enc = st->codec; 3640 3641 ost->bitstream_filters = subtitle_bitstream_filters; 3642 subtitle_bitstream_filters= NULL; 3643 3644 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE; 3645 3646 if(subtitle_codec_tag) 3647 subtitle_enc->codec_tag= subtitle_codec_tag; 3648 3649 if (oc->oformat->flags & AVFMT_GLOBALHEADER) { 3650 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER; 3651 } 3652 if (subtitle_stream_copy) { 3653 st->stream_copy = 1; 3654 } else { 3655 subtitle_enc->codec_id = codec_id; 3656 } 3657 3658 if (subtitle_language) { 3659 av_dict_set(&st->metadata, "language", subtitle_language, 0); 3660 av_freep(&subtitle_language); 3661 } 3662 3663 subtitle_disable = 0; 3664 av_freep(&subtitle_codec_name); 3665 subtitle_stream_copy = 0; 3666} 3667 3668static int opt_new_stream(const char *opt, const char *arg) 3669{ 3670 AVFormatContext *oc; 3671 int file_idx = nb_output_files - 1; 3672 if (nb_output_files <= 0) { 3673 fprintf(stderr, "At least one output file must be specified\n"); 3674 exit_program(1); 3675 } 3676 oc = output_files[file_idx]; 3677 3678 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx); 3679 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx); 3680 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx); 3681 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx); 3682 else av_assert0(0); 3683 return 0; 3684} 3685 3686/* arg format is "output-stream-index:streamid-value". */ 3687static int opt_streamid(const char *opt, const char *arg) 3688{ 3689 int idx; 3690 char *p; 3691 char idx_str[16]; 3692 3693 av_strlcpy(idx_str, arg, sizeof(idx_str)); 3694 p = strchr(idx_str, ':'); 3695 if (!p) { 3696 fprintf(stderr, 3697 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n", 3698 arg, opt); 3699 exit_program(1); 3700 } 3701 *p++ = '\0'; 3702 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX); 3703 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1); 3704 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX); 3705 return 0; 3706} 3707 3708static void opt_output_file(void *optctx, const char *filename) 3709{ 3710 AVFormatContext *oc; 3711 int err, use_video, use_audio, use_subtitle, use_data; 3712 int input_has_video, input_has_audio, input_has_subtitle, input_has_data; 3713 AVOutputFormat *file_oformat; 3714 3715 if (!strcmp(filename, "-")) 3716 filename = "pipe:"; 3717 3718 oc = avformat_alloc_context(); 3719 if (!oc) { 3720 print_error(filename, AVERROR(ENOMEM)); 3721 exit_program(1); 3722 } 3723 3724 if (last_asked_format) { 3725 file_oformat = av_guess_format(last_asked_format, NULL, NULL); 3726 if (!file_oformat) { 3727 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format); 3728 exit_program(1); 3729 } 3730 last_asked_format = NULL; 3731 } else { 3732 file_oformat = av_guess_format(NULL, filename, NULL); 3733 if (!file_oformat) { 3734 fprintf(stderr, "Unable to find a suitable output format for '%s'\n", 3735 filename); 3736 exit_program(1); 3737 } 3738 } 3739 3740 oc->oformat = file_oformat; 3741 av_strlcpy(oc->filename, filename, sizeof(oc->filename)); 3742 3743 if (!strcmp(file_oformat->name, "ffm") && 3744 av_strstart(filename, "http:", NULL)) { 3745 /* special case for files sent to avserver: we get the stream 3746 parameters from avserver */ 3747 int err = read_avserver_streams(oc, filename); 3748 if (err < 0) { 3749 print_error(filename, err); 3750 exit_program(1); 3751 } 3752 } else { 3753 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name; 3754 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name; 3755 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name; 3756 use_data = data_stream_copy || data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */ 3757 3758 /* disable if no corresponding type found */ 3759 check_inputs(&input_has_video, 3760 &input_has_audio, 3761 &input_has_subtitle, 3762 &input_has_data); 3763 3764 if (!input_has_video) 3765 use_video = 0; 3766 if (!input_has_audio) 3767 use_audio = 0; 3768 if (!input_has_subtitle) 3769 use_subtitle = 0; 3770 if (!input_has_data) 3771 use_data = 0; 3772 3773 /* manual disable */ 3774 if (audio_disable) use_audio = 0; 3775 if (video_disable) use_video = 0; 3776 if (subtitle_disable) use_subtitle = 0; 3777 if (data_disable) use_data = 0; 3778 3779 if (use_video) new_video_stream(oc, nb_output_files); 3780 if (use_audio) new_audio_stream(oc, nb_output_files); 3781 if (use_subtitle) new_subtitle_stream(oc, nb_output_files); 3782 if (use_data) new_data_stream(oc, nb_output_files); 3783 3784 av_dict_copy(&oc->metadata, metadata, 0); 3785 av_dict_free(&metadata); 3786 } 3787 3788 av_dict_copy(&output_opts[nb_output_files], format_opts, 0); 3789 output_files[nb_output_files++] = oc; 3790 3791 /* check filename in case of an image number is expected */ 3792 if (oc->oformat->flags & AVFMT_NEEDNUMBER) { 3793 if (!av_filename_number_test(oc->filename)) { 3794 print_error(oc->filename, AVERROR(EINVAL)); 3795 exit_program(1); 3796 } 3797 } 3798 3799 if (!(oc->oformat->flags & AVFMT_NOFILE)) { 3800 /* test if it already exists to avoid losing precious files */ 3801 if (!file_overwrite && 3802 (strchr(filename, ':') == NULL || 3803 filename[1] == ':' || 3804 av_strstart(filename, "file:", NULL))) { 3805 if (avio_check(filename, 0) == 0) { 3806 if (!using_stdin) { 3807 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename); 3808 fflush(stderr); 3809 if (!read_yesno()) { 3810 fprintf(stderr, "Not overwriting - exiting\n"); 3811 exit_program(1); 3812 } 3813 } 3814 else { 3815 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename); 3816 exit_program(1); 3817 } 3818 } 3819 } 3820 3821 /* open the file */ 3822 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) { 3823 print_error(filename, err); 3824 exit_program(1); 3825 } 3826 } 3827 3828 oc->preload= (int)(mux_preload*AV_TIME_BASE); 3829 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE); 3830 if (loop_output >= 0) { 3831 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n"); 3832 oc->loop_output = loop_output; 3833 } 3834 oc->flags |= AVFMT_FLAG_NONBLOCK; 3835 3836 frame_rate = (AVRational){0, 0}; 3837 frame_width = 0; 3838 frame_height = 0; 3839 audio_sample_rate = 0; 3840 audio_channels = 0; 3841 audio_sample_fmt = AV_SAMPLE_FMT_NONE; 3842 3843 av_freep(&forced_key_frames); 3844 uninit_opts(); 3845 init_opts(); 3846} 3847 3848/* same option as mencoder */ 3849static int opt_pass(const char *opt, const char *arg) 3850{ 3851 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2); 3852 return 0; 3853} 3854 3855static int64_t getutime(void) 3856{ 3857#if HAVE_GETRUSAGE 3858 struct rusage rusage; 3859 3860 getrusage(RUSAGE_SELF, &rusage); 3861 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec; 3862#elif HAVE_GETPROCESSTIMES 3863 HANDLE proc; 3864 FILETIME c, e, k, u; 3865 proc = GetCurrentProcess(); 3866 GetProcessTimes(proc, &c, &e, &k, &u); 3867 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10; 3868#else 3869 return av_gettime(); 3870#endif 3871} 3872 3873static int64_t getmaxrss(void) 3874{ 3875#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS 3876 struct rusage rusage; 3877 getrusage(RUSAGE_SELF, &rusage); 3878 return (int64_t)rusage.ru_maxrss * 1024; 3879#elif HAVE_GETPROCESSMEMORYINFO 3880 HANDLE proc; 3881 PROCESS_MEMORY_COUNTERS memcounters; 3882 proc = GetCurrentProcess(); 3883 memcounters.cb = sizeof(memcounters); 3884 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters)); 3885 return memcounters.PeakPagefileUsage; 3886#else 3887 return 0; 3888#endif 3889} 3890 3891static void parse_matrix_coeffs(uint16_t *dest, const char *str) 3892{ 3893 int i; 3894 const char *p = str; 3895 for(i = 0;; i++) { 3896 dest[i] = atoi(p); 3897 if(i == 63) 3898 break; 3899 p = strchr(p, ','); 3900 if(!p) { 3901 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i); 3902 exit_program(1); 3903 } 3904 p++; 3905 } 3906} 3907 3908static void opt_inter_matrix(const char *arg) 3909{ 3910 inter_matrix = av_mallocz(sizeof(uint16_t) * 64); 3911 parse_matrix_coeffs(inter_matrix, arg); 3912} 3913 3914static void opt_intra_matrix(const char *arg) 3915{ 3916 intra_matrix = av_mallocz(sizeof(uint16_t) * 64); 3917 parse_matrix_coeffs(intra_matrix, arg); 3918} 3919 3920static void show_usage(void) 3921{ 3922 printf("Hyper fast Audio and Video encoder\n"); 3923 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n"); 3924 printf("\n"); 3925} 3926 3927static void show_help(void) 3928{ 3929 AVCodec *c; 3930 AVOutputFormat *oformat = NULL; 3931 AVInputFormat *iformat = NULL; 3932 const AVClass *class; 3933 3934 av_log_set_callback(log_callback_help); 3935 show_usage(); 3936 show_help_options(options, "Main options:\n", 3937 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0); 3938 show_help_options(options, "\nAdvanced options:\n", 3939 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 3940 OPT_EXPERT); 3941 show_help_options(options, "\nVideo options:\n", 3942 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 3943 OPT_VIDEO); 3944 show_help_options(options, "\nAdvanced Video options:\n", 3945 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 3946 OPT_VIDEO | OPT_EXPERT); 3947 show_help_options(options, "\nAudio options:\n", 3948 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 3949 OPT_AUDIO); 3950 show_help_options(options, "\nAdvanced Audio options:\n", 3951 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 3952 OPT_AUDIO | OPT_EXPERT); 3953 show_help_options(options, "\nSubtitle options:\n", 3954 OPT_SUBTITLE | OPT_GRAB, 3955 OPT_SUBTITLE); 3956 show_help_options(options, "\nAudio/Video grab options:\n", 3957 OPT_GRAB, 3958 OPT_GRAB); 3959 printf("\n"); 3960 class = avcodec_get_class(); 3961 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0); 3962 printf("\n"); 3963 3964 /* individual codec options */ 3965 c = NULL; 3966 while ((c = av_codec_next(c))) { 3967 if (c->priv_class) { 3968 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0); 3969 printf("\n"); 3970 } 3971 } 3972 3973 class = avformat_get_class(); 3974 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0); 3975 printf("\n"); 3976 3977 /* individual muxer options */ 3978 while ((oformat = av_oformat_next(oformat))) { 3979 if (oformat->priv_class) { 3980 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0); 3981 printf("\n"); 3982 } 3983 } 3984 3985 /* individual demuxer options */ 3986 while ((iformat = av_iformat_next(iformat))) { 3987 if (iformat->priv_class) { 3988 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0); 3989 printf("\n"); 3990 } 3991 } 3992 3993 class = sws_get_class(); 3994 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0); 3995} 3996 3997static int opt_target(const char *opt, const char *arg) 3998{ 3999 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN; 4000 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"}; 4001 4002 if(!strncmp(arg, "pal-", 4)) { 4003 norm = PAL; 4004 arg += 4; 4005 } else if(!strncmp(arg, "ntsc-", 5)) { 4006 norm = NTSC; 4007 arg += 5; 4008 } else if(!strncmp(arg, "film-", 5)) { 4009 norm = FILM; 4010 arg += 5; 4011 } else { 4012 int fr; 4013 /* Calculate FR via float to avoid int overflow */ 4014 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den); 4015 if(fr == 25000) { 4016 norm = PAL; 4017 } else if((fr == 29970) || (fr == 23976)) { 4018 norm = NTSC; 4019 } else { 4020 /* Try to determine PAL/NTSC by peeking in the input files */ 4021 if(nb_input_files) { 4022 int i, j; 4023 for (j = 0; j < nb_input_files; j++) { 4024 for (i = 0; i < input_files[j].ctx->nb_streams; i++) { 4025 AVCodecContext *c = input_files[j].ctx->streams[i]->codec; 4026 if(c->codec_type != AVMEDIA_TYPE_VIDEO) 4027 continue; 4028 fr = c->time_base.den * 1000 / c->time_base.num; 4029 if(fr == 25000) { 4030 norm = PAL; 4031 break; 4032 } else if((fr == 29970) || (fr == 23976)) { 4033 norm = NTSC; 4034 break; 4035 } 4036 } 4037 if(norm != UNKNOWN) 4038 break; 4039 } 4040 } 4041 } 4042 if(verbose > 0 && norm != UNKNOWN) 4043 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC"); 4044 } 4045 4046 if(norm == UNKNOWN) { 4047 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n"); 4048 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n"); 4049 fprintf(stderr, "or set a framerate with \"-r xxx\".\n"); 4050 exit_program(1); 4051 } 4052 4053 if(!strcmp(arg, "vcd")) { 4054 opt_video_codec("vcodec", "mpeg1video"); 4055 opt_audio_codec("vcodec", "mp2"); 4056 opt_format("f", "vcd"); 4057 4058 opt_frame_size("s", norm == PAL ? "352x288" : "352x240"); 4059 opt_frame_rate("r", frame_rates[norm]); 4060 opt_default("g", norm == PAL ? "15" : "18"); 4061 4062 opt_default("b", "1150000"); 4063 opt_default("maxrate", "1150000"); 4064 opt_default("minrate", "1150000"); 4065 opt_default("bufsize", "327680"); // 40*1024*8; 4066 4067 opt_default("ab", "224000"); 4068 audio_sample_rate = 44100; 4069 audio_channels = 2; 4070 4071 opt_default("packetsize", "2324"); 4072 opt_default("muxrate", "1411200"); // 2352 * 75 * 8; 4073 4074 /* We have to offset the PTS, so that it is consistent with the SCR. 4075 SCR starts at 36000, but the first two packs contain only padding 4076 and the first pack from the other stream, respectively, may also have 4077 been written before. 4078 So the real data starts at SCR 36000+3*1200. */ 4079 mux_preload= (36000+3*1200) / 90000.0; //0.44 4080 } else if(!strcmp(arg, "svcd")) { 4081 4082 opt_video_codec("vcodec", "mpeg2video"); 4083 opt_audio_codec("acodec", "mp2"); 4084 opt_format("f", "svcd"); 4085 4086 opt_frame_size("s", norm == PAL ? "480x576" : "480x480"); 4087 opt_frame_rate("r", frame_rates[norm]); 4088 opt_default("g", norm == PAL ? "15" : "18"); 4089 4090 opt_default("b", "2040000"); 4091 opt_default("maxrate", "2516000"); 4092 opt_default("minrate", "0"); //1145000; 4093 opt_default("bufsize", "1835008"); //224*1024*8; 4094 opt_default("flags", "+scan_offset"); 4095 4096 4097 opt_default("ab", "224000"); 4098 audio_sample_rate = 44100; 4099 4100 opt_default("packetsize", "2324"); 4101 4102 } else if(!strcmp(arg, "dvd")) { 4103 4104 opt_video_codec("vcodec", "mpeg2video"); 4105 opt_audio_codec("vcodec", "ac3"); 4106 opt_format("f", "dvd"); 4107 4108 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480"); 4109 opt_frame_rate("r", frame_rates[norm]); 4110 opt_default("g", norm == PAL ? "15" : "18"); 4111 4112 opt_default("b", "6000000"); 4113 opt_default("maxrate", "9000000"); 4114 opt_default("minrate", "0"); //1500000; 4115 opt_default("bufsize", "1835008"); //224*1024*8; 4116 4117 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack. 4118 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8 4119 4120 opt_default("ab", "448000"); 4121 audio_sample_rate = 48000; 4122 4123 } else if(!strncmp(arg, "dv", 2)) { 4124 4125 opt_format("f", "dv"); 4126 4127 opt_frame_size("s", norm == PAL ? "720x576" : "720x480"); 4128 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" : 4129 norm == PAL ? "yuv420p" : "yuv411p"); 4130 opt_frame_rate("r", frame_rates[norm]); 4131 4132 audio_sample_rate = 48000; 4133 audio_channels = 2; 4134 4135 } else { 4136 fprintf(stderr, "Unknown target: %s\n", arg); 4137 return AVERROR(EINVAL); 4138 } 4139 return 0; 4140} 4141 4142static int opt_vstats_file(const char *opt, const char *arg) 4143{ 4144 av_free (vstats_filename); 4145 vstats_filename=av_strdup (arg); 4146 return 0; 4147} 4148 4149static int opt_vstats(const char *opt, const char *arg) 4150{ 4151 char filename[40]; 4152 time_t today2 = time(NULL); 4153 struct tm *today = localtime(&today2); 4154 4155 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min, 4156 today->tm_sec); 4157 return opt_vstats_file(opt, filename); 4158} 4159 4160static int opt_bsf(const char *opt, const char *arg) 4161{ 4162 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '=' 4163 AVBitStreamFilterContext **bsfp; 4164 4165 if(!bsfc){ 4166 fprintf(stderr, "Unknown bitstream filter %s\n", arg); 4167 exit_program(1); 4168 } 4169 4170 bsfp= *opt == 'v' ? &video_bitstream_filters : 4171 *opt == 'a' ? &audio_bitstream_filters : 4172 &subtitle_bitstream_filters; 4173 while(*bsfp) 4174 bsfp= &(*bsfp)->next; 4175 4176 *bsfp= bsfc; 4177 4178 return 0; 4179} 4180 4181static int opt_preset(const char *opt, const char *arg) 4182{ 4183 FILE *f=NULL; 4184 char filename[1000], tmp[1000], tmp2[1000], line[1000]; 4185 char *codec_name = *opt == 'v' ? video_codec_name : 4186 *opt == 'a' ? audio_codec_name : 4187 subtitle_codec_name; 4188 4189 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) { 4190 fprintf(stderr, "File for preset '%s' not found\n", arg); 4191 exit_program(1); 4192 } 4193 4194 while(!feof(f)){ 4195 int e= fscanf(f, "%999[^\n]\n", line) - 1; 4196 if(line[0] == '#' && !e) 4197 continue; 4198 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2; 4199 if(e){ 4200 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line); 4201 exit_program(1); 4202 } 4203 if(!strcmp(tmp, "acodec")){ 4204 opt_audio_codec(tmp, tmp2); 4205 }else if(!strcmp(tmp, "vcodec")){ 4206 opt_video_codec(tmp, tmp2); 4207 }else if(!strcmp(tmp, "scodec")){ 4208 opt_subtitle_codec(tmp, tmp2); 4209 }else if(!strcmp(tmp, "dcodec")){ 4210 opt_data_codec(tmp, tmp2); 4211 }else if(opt_default(tmp, tmp2) < 0){ 4212 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2); 4213 exit_program(1); 4214 } 4215 } 4216 4217 fclose(f); 4218 4219 return 0; 4220} 4221 4222static const OptionDef options[] = { 4223 /* main options */ 4224#include "cmdutils_common_opts.h" 4225 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" }, 4226 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" }, 4227 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" }, 4228 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" }, 4229 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile", 4230 "outfile[,metadata]:infile[,metadata]" }, 4231 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile", 4232 "outfile[,metadata]:infile[,metadata]" }, 4233 { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" }, 4234 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" }, 4235 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, // 4236 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" }, 4237 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" }, 4238 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" }, 4239 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" }, 4240 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" }, 4241 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" }, 4242 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 4243 "add timings for benchmarking" }, 4244 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" }, 4245 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 4246 "dump each input packet" }, 4247 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 4248 "when dumping packets, also dump the payload" }, 4249 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" }, 4250 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" }, 4251 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" }, 4252 { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" }, 4253 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" }, 4254 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" }, 4255 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" }, 4256 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" }, 4257 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" }, 4258 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" }, 4259 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" }, 4260 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, // 4261 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" }, 4262 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" }, 4263 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" }, 4264 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" }, 4265 4266 /* video options */ 4267 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" }, 4268 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" }, 4269 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" }, 4270 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" }, 4271 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" }, 4272 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" }, 4273 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" }, 4274 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" }, 4275 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" }, 4276 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" }, 4277 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" }, 4278 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" }, 4279 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" }, 4280 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" }, 4281 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"}, 4282 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" }, 4283 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" }, 4284 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" }, 4285 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" }, 4286 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" }, 4287 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" }, 4288 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 4289 "use same quantizer as source (implies VBR)" }, 4290 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" }, 4291 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" }, 4292 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 4293 "deinterlace pictures" }, 4294 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" }, 4295 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" }, 4296 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" }, 4297#if CONFIG_AVFILTER 4298 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" }, 4299#endif 4300 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" }, 4301 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" }, 4302 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" }, 4303 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" }, 4304 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" }, 4305 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" }, 4306 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" }, 4307 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" }, 4308 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" }, 4309 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" }, 4310 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" }, 4311 4312 /* audio options */ 4313 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" }, 4314 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", }, 4315 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" }, 4316 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" }, 4317 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" }, 4318 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" }, 4319 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" }, 4320 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, // 4321 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" }, 4322 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" }, 4323 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" }, 4324 4325 /* subtitle options */ 4326 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" }, 4327 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" }, 4328 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" }, 4329 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" }, 4330 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" }, 4331 4332 /* grab options */ 4333 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" }, 4334 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" }, 4335 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" }, 4336 4337 /* muxer options */ 4338 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" }, 4339 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" }, 4340 4341 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" }, 4342 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" }, 4343 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" }, 4344 4345 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" }, 4346 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" }, 4347 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" }, 4348 { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" }, 4349 /* data codec support */ 4350 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" }, 4351 4352 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" }, 4353 { NULL, }, 4354}; 4355 4356int main(int argc, char **argv) 4357{ 4358 int64_t ti; 4359 4360 av_log_set_flags(AV_LOG_SKIP_REPEATED); 4361 parse_loglevel(argc, argv, options); 4362 4363 avcodec_register_all(); 4364#if CONFIG_AVDEVICE 4365 avdevice_register_all(); 4366#endif 4367#if CONFIG_AVFILTER 4368 avfilter_register_all(); 4369#endif 4370 av_register_all(); 4371 avformat_network_init(); 4372 4373 avio_set_interrupt_cb(decode_interrupt_cb); 4374 4375 init_opts(); 4376 4377 show_banner(); 4378 4379 av_log(NULL, AV_LOG_WARNING, "This program is not developed anymore and is only " 4380 "provided for compatibility. Use avconv instead " 4381 "(see Changelog for the list of incompatible changes).\n"); 4382 4383 /* parse options */ 4384 parse_options(NULL, argc, argv, options, opt_output_file); 4385 4386 if(nb_output_files <= 0 && nb_input_files == 0) { 4387 show_usage(); 4388 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n"); 4389 exit_program(1); 4390 } 4391 4392 /* file converter / grab */ 4393 if (nb_output_files <= 0) { 4394 fprintf(stderr, "At least one output file must be specified\n"); 4395 exit_program(1); 4396 } 4397 4398 if (nb_input_files == 0) { 4399 fprintf(stderr, "At least one input file must be specified\n"); 4400 exit_program(1); 4401 } 4402 4403 ti = getutime(); 4404 if (transcode(output_files, nb_output_files, input_files, nb_input_files, 4405 stream_maps, nb_stream_maps) < 0) 4406 exit_program(1); 4407 ti = getutime() - ti; 4408 if (do_benchmark) { 4409 int maxrss = getmaxrss() / 1024; 4410 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss); 4411 } 4412 4413 exit_program(0); 4414 return 0; 4415} 4416