ffmpeg.c
Go to the documentation of this file.
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"
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"
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 
77 const char program_name[] = "ffmpeg";
78 const int program_birth_year = 2000;
79 
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
82  int file_index;
83  int stream_index;
84  int sync_file_index;
86 } StreamMap;
87 
91 typedef struct MetadataMap {
92  int file;
93  char type;
94  int index;
95 } MetadataMap;
96 
97 typedef struct ChapterMap {
98  int in_file;
99  int out_file;
100 } ChapterMap;
101 
102 static const OptionDef options[];
103 
104 #define MAX_FILES 100
105 
106 static const char *last_asked_format = NULL;
107 static double *ts_scale;
108 static int nb_ts_scale;
109 
112 static int nb_output_files = 0;
113 
115 static int nb_stream_maps;
116 
117 /* first item specifies output metadata, second is input */
119 static int nb_meta_data_maps;
123 
125 static int nb_chapter_maps;
126 
127 /* indexed by output file stream index */
128 static int *streamid_map = NULL;
129 static int nb_streamid_map = 0;
130 
131 static int frame_width = 0;
132 static int frame_height = 0;
133 static float frame_aspect_ratio = 0;
136 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
138 static float video_qscale = 0;
139 static uint16_t *intra_matrix = NULL;
140 static uint16_t *inter_matrix = NULL;
141 static const char *video_rc_override_string=NULL;
142 static int video_disable = 0;
143 static int video_discard = 0;
144 static char *video_codec_name = NULL;
145 static unsigned int video_codec_tag = 0;
146 static char *video_language = NULL;
147 static int same_quality = 0;
148 static int do_deinterlace = 0;
149 static int top_field_first = -1;
150 static int me_threshold = 0;
151 static int intra_dc_precision = 8;
152 static int loop_input = 0;
153 static int loop_output = AVFMT_NOOUTPUTLOOP;
154 static int qp_hist = 0;
155 #if CONFIG_AVFILTER
156 static char *vfilters = NULL;
157 #endif
158 
159 static int intra_only = 0;
160 static int audio_sample_rate = 0;
161 #define QSCALE_NONE -99999
162 static float audio_qscale = QSCALE_NONE;
163 static int audio_disable = 0;
164 static int audio_channels = 0;
165 static char *audio_codec_name = NULL;
166 static unsigned int audio_codec_tag = 0;
167 static char *audio_language = NULL;
168 
169 static int subtitle_disable = 0;
170 static char *subtitle_codec_name = NULL;
171 static char *subtitle_language = NULL;
172 static unsigned int subtitle_codec_tag = 0;
173 
174 static int data_disable = 0;
175 static char *data_codec_name = NULL;
176 static unsigned int data_codec_tag = 0;
177 
178 static float mux_preload= 0.5;
179 static float mux_max_delay= 0.7;
180 
181 static int64_t recording_time = INT64_MAX;
182 static int64_t start_time = 0;
183 static int64_t input_ts_offset = 0;
184 static int file_overwrite = 0;
186 static int do_benchmark = 0;
187 static int do_hex_dump = 0;
188 static int do_pkt_dump = 0;
189 static int do_psnr = 0;
190 static int do_pass = 0;
192 static int audio_stream_copy = 0;
193 static int video_stream_copy = 0;
194 static int subtitle_stream_copy = 0;
195 static int data_stream_copy = 0;
196 static int video_sync_method= -1;
197 static int audio_sync_method= 0;
198 static float audio_drift_threshold= 0.1;
199 static int copy_ts= 0;
200 static int copy_tb;
201 static int opt_shortest = 0;
202 static char *vstats_filename;
203 static FILE *vstats_file;
204 static int opt_programid = 0;
206 
207 static int rate_emu = 0;
208 
209 static int audio_volume = 256;
210 
211 static int exit_on_error = 0;
212 static int using_stdin = 0;
213 static int verbose = 1;
214 static int thread_count= 1;
215 static int64_t video_size = 0;
216 static int64_t audio_size = 0;
217 static int64_t extra_size = 0;
218 static int nb_frames_dup = 0;
219 static int nb_frames_drop = 0;
220 static int input_sync;
221 static uint64_t limit_filesize = 0;
222 static int force_fps = 0;
223 static char *forced_key_frames = NULL;
224 
225 static float dts_delta_threshold = 10;
226 
227 static int64_t timer_start;
228 
229 static uint8_t *audio_buf;
230 static uint8_t *audio_out;
232 
233 static short *samples;
234 
238 
239 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
240 
241 struct InputStream;
242 
243 typedef 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
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;
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 */
278  int resample_channels;
280  int reformat_pair;
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 
295 } OutputStream;
296 
299 
300 typedef 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 */
312  double ts_scale;
313  int is_start; /* is 1 at the start and after a discontinuity */
317 } InputStream;
318 
319 typedef struct InputFile {
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 
329 static int nb_input_streams = 0;
331 static int nb_input_files = 0;
332 
333 #if CONFIG_AVFILTER
334 
335 static int configure_video_filters(InputStream *ist, OutputStream *ost)
336 {
337  AVFilterContext *last_filter, *filter;
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;
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 
419 static void term_exit(void)
420 {
421  av_log(NULL, AV_LOG_QUIET, "");
422 }
423 
424 static volatile int received_sigterm = 0;
425 static volatile int received_nb_signals = 0;
426 
427 static void
429 {
430  received_sigterm = sig;
432  term_exit();
433 }
434 
435 static 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 
444 static int decode_interrupt_cb(void)
445 {
446  return received_nb_signals > 1;
447 }
448 
449 void 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);
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 
470 
471  if (vstats_file)
472  fclose(vstats_file);
474 
476  av_free(stream_maps);
478 
479  av_freep(&input_streams);
480  av_freep(&input_files);
481 
486 
487  uninit_opts();
491  av_free(samples);
492 
493 #if CONFIG_AVFILTER
494  avfilter_uninit();
495 #endif
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 
509 {
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 
517 static void assert_codec_experimental(AVCodecContext *c, int encoder)
518 {
519  const char *codec_string = encoder ? "encoder" : "decoder";
520  AVCodec *codec;
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 
534 static 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) {
544  "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
546  codec->name,
548  st->codec->sample_fmt = codec->sample_fmts[0];
549  }
550  }
551 }
552 
560 static 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 ||
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 
593 static 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 
613 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
614 {
615  if(codec && codec->pix_fmts){
616  const enum PixelFormat *p= codec->pix_fmts;
618  if(st->codec->codec_id==CODEC_ID_MJPEG){
620  }else if(st->codec->codec_id==CODEC_ID_LJPEG){
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)
631  "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
633  codec->name,
635  st->codec->pix_fmt = codec->pix_fmts[0];
636  }
637  }
638 }
639 
640 static 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 
670 
671  ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
672  return ost;
673 }
674 
675 static 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 
715 static double
717 {
718  const InputStream *ist = ost->sync_ist;
719  return (double)(ist->pts - start_time)/AV_TIME_BASE;
720 }
721 
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 
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 
772 need_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 
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,
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)
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");
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 &&
841  if (ost->reformat_ctx)
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",
849  exit_program(1);
850  }
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);
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 
1000 static 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 
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 
1105 static int bit_buffer_size= 1024*256;
1106 static uint8_t *bit_buffer= NULL;
1107 
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) {
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,
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 */
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;
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,
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 
1281 static double psnr(double d){
1282  return -10.0*log(d)/log(10.0);
1283 }
1284 
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);
1319  }
1320 }
1321 
1322 static 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 
1423  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
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 
1444 static 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) */
1453 static 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;
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);
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) {
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))
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;
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);
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:
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 
1854 static 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 
1863 static 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 :
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 
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 
1903 static 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  */
1929 static 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 
2080  av_dict_copy(&ost->st->metadata, ist->st->metadata,
2082 
2083  ost->st->disposition = ist->st->disposition;
2084  codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
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 =
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;
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;
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
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  }
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) {
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",
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)
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) {
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);
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  }
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  }
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;
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 */
2436 
2437  for (i = 0; i < nb_output_files; i++)
2438  av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
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) {
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 
2741 static int opt_format(const char *opt, const char *arg)
2742 {
2743  last_asked_format = arg;
2744  return 0;
2745 }
2746 
2747 static int opt_video_rc_override_string(const char *opt, const char *arg)
2748 {
2750  return 0;
2751 }
2752 
2753 static 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 
2759 static 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 
2765 static 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 
2774 static 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 
2780 static 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 
2789 static 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 
2794 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2795 {
2796  if (strcmp(arg, "list")) {
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 
2809 static 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 
2834 static 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 
2849 static 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 
2859 static 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 
2865 static 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 
2875 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2876 {
2877  if (strcmp(arg, "list")) {
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 
2893 static 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 
2899 static 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 
2905 static 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 
2912 static 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 
2919 static 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 
2931 static int opt_audio_codec(const char *opt, const char *arg)
2932 {
2934 }
2935 
2936 static int opt_video_codec(const char *opt, const char *arg)
2937 {
2939 }
2940 
2941 static int opt_subtitle_codec(const char *opt, const char *arg)
2942 {
2944 }
2945 
2946 static int opt_data_codec(const char *opt, const char *arg)
2947 {
2949 }
2950 
2951 static 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 
2969 static 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;
2991  }
2992  return 0;
2993 }
2994 
2995 static 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 
3016 static int opt_map_metadata(const char *opt, const char *arg)
3017 {
3018  MetadataMap *m, *m1;
3019  char *p;
3020 
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')
3036  if (m->type == 's' || m1->type == 's')
3038  if (m->type == 'c' || m1->type == 'c')
3040 
3041  return 0;
3042 }
3043 
3044 static 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 
3051 static 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 
3067 static 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 
3083 static 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 
3089 static 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 
3095 static 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 
3108 static 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 
3114 static 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 ?
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 
3135 static int opt_input_file(const char *opt, const char *filename)
3136 {
3137  AVFormatContext *ic;
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  }
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)
3183 
3184  ic->video_codec_id =
3186  ic->audio_codec_id =
3188  ic->subtitle_codec_id=
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  }
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++){
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 */
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:
3279  if(audio_disable)
3280  st->discard= AVDISCARD_ALL;
3281  break;
3282  case AVMEDIA_TYPE_VIDEO:
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:
3312  if(subtitle_disable)
3313  st->discard = AVDISCARD_ALL;
3314  break;
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};
3335  frame_height = 0;
3336  frame_width = 0;
3337  audio_sample_rate = 0;
3338  audio_channels = 0;
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);
3349  uninit_opts();
3350  init_opts();
3351  return 0;
3352 }
3353 
3354 static 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:
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 
3397 static void new_video_stream(AVFormatContext *oc, int file_idx)
3398 {
3399  AVStream *st;
3400  OutputStream *ost;
3401  AVCodecContext *video_enc;
3403  AVCodec *codec= NULL;
3404 
3405  if(!video_stream_copy){
3406  if (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) {
3419  frame_aspect_ratio = 0;
3420 #if CONFIG_AVFILTER
3421  ost->avfilter= vfilters;
3422  vfilters = NULL;
3423 #endif
3424  }
3425 
3427  video_bitstream_filters= NULL;
3428 
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 =
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 
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);
3518  }
3519 
3520  /* reset some key parameters */
3521  video_disable = 0;
3524  video_stream_copy = 0;
3526 }
3527 
3528 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3529 {
3530  AVStream *st;
3531  OutputStream *ost;
3532  AVCodec *codec= NULL;
3533  AVCodecContext *audio_enc;
3535 
3536  if(!audio_stream_copy){
3537  if (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 
3549  audio_bitstream_filters= NULL;
3550 
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;
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);
3581  }
3582 
3583  /* reset some key parameters */
3584  audio_disable = 0;
3586  audio_stream_copy = 0;
3587 }
3588 
3589 static 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;
3617  data_stream_copy = 0;
3618 }
3619 
3620 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3621 {
3622  AVStream *st;
3623  OutputStream *ost;
3624  AVCodec *codec=NULL;
3625  AVCodecContext *subtitle_enc;
3627 
3628  if(!subtitle_stream_copy){
3629  if (subtitle_codec_name) {
3632  } else {
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 
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);
3661  }
3662 
3663  subtitle_disable = 0;
3666 }
3667 
3668 static 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". */
3687 static 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);
3704  streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3705  return 0;
3706 }
3707 
3708 static 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  }
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;
3842 
3844  uninit_opts();
3845  init_opts();
3846 }
3847 
3848 /* same option as mencoder */
3849 static 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 
3855 static 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 
3873 static 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 
3891 static 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 
3908 static void opt_inter_matrix(const char *arg)
3909 {
3910  inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3912 }
3913 
3914 static void opt_intra_matrix(const char *arg)
3915 {
3916  intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3918 }
3919 
3920 static 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 
3927 static void show_help(void)
3928 {
3929  AVCodec *c;
3930  AVOutputFormat *oformat = NULL;
3932  const AVClass *class;
3933 
3935  show_usage();
3936  show_help_options(options, "Main options:\n",
3938  show_help_options(options, "\nAdvanced options:\n",
3940  OPT_EXPERT);
3941  show_help_options(options, "\nVideo options:\n",
3943  OPT_VIDEO);
3944  show_help_options(options, "\nAdvanced Video options:\n",
3946  OPT_VIDEO | OPT_EXPERT);
3947  show_help_options(options, "\nAudio options:\n",
3949  OPT_AUDIO);
3950  show_help_options(options, "\nAdvanced Audio options:\n",
3952  OPT_AUDIO | OPT_EXPERT);
3953  show_help_options(options, "\nSubtitle options:\n",
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();
3962  printf("\n");
3963 
3964  /* individual codec options */
3965  c = NULL;
3966  while ((c = av_codec_next(c))) {
3967  if (c->priv_class) {
3969  printf("\n");
3970  }
3971  }
3972 
3973  class = avformat_get_class();
3975  printf("\n");
3976 
3977  /* individual muxer options */
3978  while ((oformat = av_oformat_next(oformat))) {
3979  if (oformat->priv_class) {
3981  printf("\n");
3982  }
3983  }
3984 
3985  /* individual demuxer options */
3986  while ((iformat = av_iformat_next(iformat))) {
3987  if (iformat->priv_class) {
3989  printf("\n");
3990  }
3991  }
3992 
3993  class = sws_get_class();
3995 }
3996 
3997 static 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 
4142 static int opt_vstats_file(const char *opt, const char *arg)
4143 {
4145  vstats_filename=av_strdup (arg);
4146  return 0;
4147 }
4148 
4149 static 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 
4160 static 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 :
4173  while(*bsfp)
4174  bsfp= &(*bsfp)->next;
4175 
4176  *bsfp= bsfc;
4177 
4178  return 0;
4179 }
4180 
4181 static 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 :
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 
4222 static 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*)&copy_ts}, "copy timestamps" },
4259  { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_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*)&copy_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 
4356 int main(int argc, char **argv)
4357 {
4358  int64_t ti;
4359 
4361  parse_loglevel(argc, argv, options);
4362 
4364 #if CONFIG_AVDEVICE
4366 #endif
4367 #if CONFIG_AVFILTER
4369 #endif
4370  av_register_all();
4372 
4373  avio_set_interrupt_cb(decode_interrupt_cb);
4374 
4375  init_opts();
4376 
4377  show_banner();
4378 
4380  "The ffmpeg program is only provided for script compatibility and will be removed\n"
4381  "in a future release. It has been deprecated in the Libav project to allow for\n"
4382  "incompatible command line syntax improvements in its replacement called avconv\n"
4383  "(see Changelog for details). Please use avconv instead.\n");
4384 
4385  /* parse options */
4386  parse_options(NULL, argc, argv, options, opt_output_file);
4387 
4388  if(nb_output_files <= 0 && nb_input_files == 0) {
4389  show_usage();
4390  fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4391  exit_program(1);
4392  }
4393 
4394  /* file converter / grab */
4395  if (nb_output_files <= 0) {
4396  fprintf(stderr, "At least one output file must be specified\n");
4397  exit_program(1);
4398  }
4399 
4400  if (nb_input_files == 0) {
4401  fprintf(stderr, "At least one input file must be specified\n");
4402  exit_program(1);
4403  }
4404 
4405  ti = getutime();
4406  if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4407  stream_maps, nb_stream_maps) < 0)
4408  exit_program(1);
4409  ti = getutime() - ti;
4410  if (do_benchmark) {
4411  int maxrss = getmaxrss() / 1024;
4412  printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4413  }
4414 
4415  exit_program(0);
4416  return 0;
4417 }