falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
32047 Commits
32 Branches
293MB
Tree: b3be9f4a88
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b3be9f4a88'
${ noResults }
FFmpeg/ffmpeg.c

4590 lines
167KB
Raw Blame History 

  1. /*

  2.  * ffmpeg main

  3.  * Copyright (c) 2000-2003 Fabrice Bellard

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. #include "config.h"

  23. #include <ctype.h>

  24. #include <string.h>

  25. #include <math.h>

  26. #include <stdlib.h>

  27. #include <errno.h>

  28. #include <signal.h>

  29. #include <limits.h>

  30. #include <unistd.h>

  31. #include "libavformat/avformat.h"

  32. #include "libavdevice/avdevice.h"

  33. #include "libswscale/swscale.h"

  34. #include "libavutil/opt.h"

  35. #include "libavcodec/audioconvert.h"

  36. #include "libavutil/audioconvert.h"

  37. #include "libavutil/parseutils.h"

  38. #include "libavutil/samplefmt.h"

  39. #include "libavutil/colorspace.h"

  40. #include "libavutil/fifo.h"

  41. #include "libavutil/intreadwrite.h"

  42. #include "libavutil/dict.h"

  43. #include "libavutil/mathematics.h"

  44. #include "libavutil/pixdesc.h"

  45. #include "libavutil/avstring.h"

  46. #include "libavutil/libm.h"

  47. #include "libavformat/os_support.h"

  48. 

  49. #include "libavformat/ffm.h" // not public API

  50. 

  51. #if CONFIG_AVFILTER

  52. # include "libavfilter/avcodec.h"

  53. # include "libavfilter/avfilter.h"

  54. # include "libavfilter/avfiltergraph.h"

  55. # include "libavfilter/vsink_buffer.h"

  56. # include "libavfilter/vsrc_buffer.h"

  57. #endif

  58. 

  59. #if HAVE_SYS_RESOURCE_H

  60. #include <sys/types.h>

  61. #include <sys/time.h>

  62. #include <sys/resource.h>

  63. #elif HAVE_GETPROCESSTIMES

  64. #include <windows.h>

  65. #endif

  66. #if HAVE_GETPROCESSMEMORYINFO

  67. #include <windows.h>

  68. #include <psapi.h>

  69. #endif

  70. 

  71. #if HAVE_SYS_SELECT_H

  72. #include <sys/select.h>

  73. #endif

  74. 

  75. #if HAVE_TERMIOS_H

  76. #include <fcntl.h>

  77. #include <sys/ioctl.h>

  78. #include <sys/time.h>

  79. #include <termios.h>

  80. #elif HAVE_KBHIT

  81. #include <conio.h>

  82. #endif

  83. #include <time.h>

  84. 

  85. #include "cmdutils.h"

  86. 

  87. #include "libavutil/avassert.h"

  88. 

  89. const char program_name[] = "ffmpeg";

  90. const int program_birth_year = 2000;

  91. 

  92. /* select an input stream for an output stream */

  93. typedef struct StreamMap {

  94.     int file_index;

  95.     int stream_index;

  96.     int sync_file_index;

  97.     int sync_stream_index;

  98. } StreamMap;

  99. 

  100. /**

  101.  * select an input file for an output file

  102.  */

  103. typedef struct MetadataMap {

  104.     int  file;      ///< file index

  105.     char type;      ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram

  106.     int  index;     ///< stream/chapter/program number

  107. } MetadataMap;

  108. 

  109. typedef struct ChapterMap {

  110.     int in_file;

  111.     int out_file;

  112. } ChapterMap;

  113. 

  114. static const OptionDef options[];

  115. 

  116. #define MAX_FILES 100

  117. #define MAX_STREAMS 1024    /* arbitrary sanity check value */

  118. static const char *last_asked_format = NULL;

  119. static double *ts_scale;

  120. static int  nb_ts_scale;

  121. 

  122. static AVFormatContext *output_files[MAX_FILES];

  123. static AVDictionary *output_opts[MAX_FILES];

  124. static int nb_output_files = 0;

  125. 

  126. static StreamMap *stream_maps = NULL;

  127. static int nb_stream_maps;

  128. 

  129. /* first item specifies output metadata, second is input */

  130. static MetadataMap (*meta_data_maps)[2] = NULL;

  131. static int nb_meta_data_maps;

  132. static int metadata_global_autocopy   = 1;

  133. static int metadata_streams_autocopy  = 1;

  134. static int metadata_chapters_autocopy = 1;

  135. 

  136. static ChapterMap *chapter_maps = NULL;

  137. static int nb_chapter_maps;

  138. 

  139. /* indexed by output file stream index */

  140. static int *streamid_map = NULL;

  141. static int nb_streamid_map = 0;

  142. 

  143. static int frame_width  = 0;

  144. static int frame_height = 0;

  145. static float frame_aspect_ratio = 0;

  146. static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;

  147. static int frame_bits_per_raw_sample = 0;

  148. static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;

  149. static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};

  150. static AVRational frame_rate;

  151. static float video_qscale = 0;

  152. static uint16_t *intra_matrix = NULL;

  153. static uint16_t *inter_matrix = NULL;

  154. static const char *video_rc_override_string=NULL;

  155. static int video_disable = 0;

  156. static int video_discard = 0;

  157. static char *video_codec_name = NULL;

  158. static unsigned int video_codec_tag = 0;

  159. static char *video_language = NULL;

  160. static int same_quality = 0;

  161. static int do_deinterlace = 0;

  162. static int top_field_first = -1;

  163. static int me_threshold = 0;

  164. static int intra_dc_precision = 8;

  165. static int loop_input = 0;

  166. static int loop_output = AVFMT_NOOUTPUTLOOP;

  167. static int qp_hist = 0;

  168. #if CONFIG_AVFILTER

  169. static char *vfilters = NULL;

  170. #endif

  171. 

  172. static int intra_only = 0;

  173. static int audio_sample_rate = 0;

  174. #define QSCALE_NONE -99999

  175. static float audio_qscale = QSCALE_NONE;

  176. static int audio_disable = 0;

  177. static int audio_channels = 0;

  178. static char  *audio_codec_name = NULL;

  179. static unsigned int audio_codec_tag = 0;

  180. static char *audio_language = NULL;

  181. 

  182. static int subtitle_disable = 0;

  183. static char *subtitle_codec_name = NULL;

  184. static char *subtitle_language = NULL;

  185. static unsigned int subtitle_codec_tag = 0;

  186. 

  187. static int data_disable = 0;

  188. static char *data_codec_name = NULL;

  189. static unsigned int data_codec_tag = 0;

  190. 

  191. static float mux_preload= 0.5;

  192. static float mux_max_delay= 0.7;

  193. 

  194. static int64_t recording_time = INT64_MAX;

  195. static int64_t start_time = 0;

  196. static int64_t input_ts_offset = 0;

  197. static int file_overwrite = 0;

  198. static AVDictionary *metadata;

  199. static int do_benchmark = 0;

  200. static int do_hex_dump = 0;

  201. static int do_pkt_dump = 0;

  202. static int do_psnr = 0;

  203. static int do_pass = 0;

  204. static const char *pass_logfilename_prefix;

  205. static int audio_stream_copy = 0;

  206. static int video_stream_copy = 0;

  207. static int subtitle_stream_copy = 0;

  208. static int data_stream_copy = 0;

  209. static int video_sync_method= -1;

  210. static int audio_sync_method= 0;

  211. static float audio_drift_threshold= 0.1;

  212. static int copy_ts= 0;

  213. static int copy_tb= 0;

  214. static int opt_shortest = 0;

  215. static char *vstats_filename;

  216. static FILE *vstats_file;

  217. static int opt_programid = 0;

  218. static int copy_initial_nonkeyframes = 0;

  219. 

  220. static int rate_emu = 0;

  221. 

  222. static int audio_volume = 256;

  223. 

  224. static int exit_on_error = 0;

  225. static int using_stdin = 0;

  226. static int verbose = 1;

  227. static int run_as_daemon  = 0;

  228. static int thread_count= 1;

  229. static int q_pressed = 0;

  230. static int64_t video_size = 0;

  231. static int64_t audio_size = 0;

  232. static int64_t extra_size = 0;

  233. static int nb_frames_dup = 0;

  234. static int nb_frames_drop = 0;

  235. static int input_sync;

  236. static uint64_t limit_filesize = 0;

  237. static int force_fps = 0;

  238. static char *forced_key_frames = NULL;

  239. 

  240. static float dts_delta_threshold = 10;

  241. 

  242. static int64_t timer_start;

  243. 

  244. static uint8_t *audio_buf;

  245. static uint8_t *audio_out;

  246. static unsigned int allocated_audio_out_size, allocated_audio_buf_size;

  247. 

  248. static short *samples;

  249. 

  250. static AVBitStreamFilterContext *video_bitstream_filters=NULL;

  251. static AVBitStreamFilterContext *audio_bitstream_filters=NULL;

  252. static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;

  253. 

  254. #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"

  255. 

  256. struct InputStream;

  257. 

  258. typedef struct OutputStream {

  259.     int file_index;          /* file index */

  260.     int index;               /* stream index in the output file */

  261.     int source_index;        /* InputStream index */

  262.     AVStream *st;            /* stream in the output file */

  263.     int encoding_needed;     /* true if encoding needed for this stream */

  264.     int frame_number;

  265.     /* input pts and corresponding output pts

  266.        for A/V sync */

  267.     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */

  268.     struct InputStream *sync_ist; /* input stream to sync against */

  269.     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number

  270.     AVBitStreamFilterContext *bitstream_filters;

  271.     AVCodec *enc;

  272. 

  273.     /* video only */

  274.     int video_resample;

  275.     AVFrame resample_frame;              /* temporary frame for image resampling */

  276.     struct SwsContext *img_resample_ctx; /* for image resampling */

  277.     int resample_height;

  278.     int resample_width;

  279.     int resample_pix_fmt;

  280.     AVRational frame_rate;

  281. 

  282.     float frame_aspect_ratio;

  283. 

  284.     /* forced key frames */

  285.     int64_t *forced_kf_pts;

  286.     int forced_kf_count;

  287.     int forced_kf_index;

  288. 

  289.     /* audio only */

  290.     int audio_resample;

  291.     ReSampleContext *resample; /* for audio resampling */

  292.     int resample_sample_fmt;

  293.     int resample_channels;

  294.     int resample_sample_rate;

  295.     int reformat_pair;

  296.     AVAudioConvert *reformat_ctx;

  297.     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */

  298.     FILE *logfile;

  299. 

  300. #if CONFIG_AVFILTER

  301.     AVFilterContext *output_video_filter;

  302.     AVFilterContext *input_video_filter;

  303.     AVFilterBufferRef *picref;

  304.     char *avfilter;

  305.     AVFilterGraph *graph;

  306. #endif

  307. 

  308.    int sws_flags;

  309.    AVDictionary *opts;

  310. } OutputStream;

  311. 

  312. static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };

  313. static int nb_output_streams_for_file[MAX_FILES] = { 0 };

  314. 

  315. typedef struct InputStream {

  316.     int file_index;

  317.     AVStream *st;

  318.     int discard;             /* true if stream data should be discarded */

  319.     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */

  320.     AVCodec *dec;

  321. 

  322.     int64_t       start;     /* time when read started */

  323.     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts

  324.                                 is not defined */

  325.     int64_t       pts;       /* current pts */

  326.     double ts_scale;

  327.     int is_start;            /* is 1 at the start and after a discontinuity */

  328.     int showed_multi_packet_warning;

  329.     int is_past_recording_time;

  330.     AVDictionary *opts;

  331. } InputStream;

  332. 

  333. typedef struct InputFile {

  334.     AVFormatContext *ctx;

  335.     int eof_reached;      /* true if eof reached */

  336.     int ist_index;        /* index of first stream in ist_table */

  337.     int buffer_size;      /* current total buffer size */

  338.     int nb_streams;

  339.     int64_t ts_offset;

  340. } InputFile;

  341. 

  342. #if HAVE_TERMIOS_H

  343. 

  344. /* init terminal so that we can grab keys */

  345. static struct termios oldtty;

  346. #endif

  347. 

  348. static InputStream *input_streams = NULL;

  349. static int         nb_input_streams = 0;

  350. static InputFile   *input_files   = NULL;

  351. static int         nb_input_files   = 0;

  352. 

  353. #if CONFIG_AVFILTER

  354. 

  355. static int configure_video_filters(InputStream *ist, OutputStream *ost)

  356. {

  357.     AVFilterContext *last_filter, *filter;

  358.     /** filter graph containing all filters including input & output */

  359.     AVCodecContext *codec = ost->st->codec;

  360.     AVCodecContext *icodec = ist->st->codec;

  361.     enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };

  362.     AVRational sample_aspect_ratio;

  363.     char args[255];

  364.     int ret;

  365. 

  366.     ost->graph = avfilter_graph_alloc();

  367. 

  368.     if (ist->st->sample_aspect_ratio.num){

  369.         sample_aspect_ratio = ist->st->sample_aspect_ratio;

  370.     }else

  371.         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;

  372. 

  373.     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,

  374.              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,

  375.              sample_aspect_ratio.num, sample_aspect_ratio.den);

  376. 

  377.     ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),

  378.                                        "src", args, NULL, ost->graph);

  379.     if (ret < 0)

  380.         return ret;

  381.     ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),

  382.                                        "out", NULL, pix_fmts, ost->graph);

  383.     if (ret < 0)

  384.         return ret;

  385.     last_filter = ost->input_video_filter;

  386. 

  387.     if (codec->width  != icodec->width || codec->height != icodec->height) {

  388.         snprintf(args, 255, "%d:%d:flags=0x%X",

  389.                  codec->width,

  390.                  codec->height,

  391.                  ost->sws_flags);

  392.         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),

  393.                                                 NULL, args, NULL, ost->graph)) < 0)

  394.             return ret;

  395.         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)

  396.             return ret;

  397.         last_filter = filter;

  398.     }

  399. 

  400.     snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);

  401.     ost->graph->scale_sws_opts = av_strdup(args);

  402. 

  403.     if (ost->avfilter) {

  404.         AVFilterInOut *outputs = avfilter_inout_alloc();

  405.         AVFilterInOut *inputs  = avfilter_inout_alloc();

  406. 

  407.         outputs->name    = av_strdup("in");

  408.         outputs->filter_ctx = last_filter;

  409.         outputs->pad_idx = 0;

  410.         outputs->next    = NULL;

  411. 

  412.         inputs->name    = av_strdup("out");

  413.         inputs->filter_ctx = ost->output_video_filter;

  414.         inputs->pad_idx = 0;

  415.         inputs->next    = NULL;

  416. 

  417.         if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)

  418.             return ret;

  419.         av_freep(&ost->avfilter);

  420.     } else {

  421.         if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)

  422.             return ret;

  423.     }

  424. 

  425.     if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)

  426.         return ret;

  427. 

  428.     codec->width  = ost->output_video_filter->inputs[0]->w;

  429.     codec->height = ost->output_video_filter->inputs[0]->h;

  430.     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =

  431.         ost->frame_aspect_ratio ? // overriden by the -aspect cli option

  432.         av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :

  433.         ost->output_video_filter->inputs[0]->sample_aspect_ratio;

  434. 

  435.     return 0;

  436. }

  437. #endif /* CONFIG_AVFILTER */

  438. 

  439. static void term_exit(void)

  440. {

  441.     av_log(NULL, AV_LOG_QUIET, "%s", "");

  442. #if HAVE_TERMIOS_H

  443.     if(!run_as_daemon)

  444.         tcsetattr (0, TCSANOW, &oldtty);

  445. #endif

  446. }

  447. 

  448. static volatile int received_sigterm = 0;

  449. 

  450. static void

  451. sigterm_handler(int sig)

  452. {

  453.     received_sigterm = sig;

  454.     q_pressed++;

  455.     term_exit();

  456. }

  457. 

  458. static void term_init(void)

  459. {

  460. #if HAVE_TERMIOS_H

  461.     if(!run_as_daemon){

  462.     struct termios tty;

  463. 

  464.     tcgetattr (0, &tty);

  465.     oldtty = tty;

  466.     atexit(term_exit);

  467. 

  468.     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP

  469.                           |INLCR|IGNCR|ICRNL|IXON);

  470.     tty.c_oflag |= OPOST;

  471.     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);

  472.     tty.c_cflag &= ~(CSIZE|PARENB);

  473.     tty.c_cflag |= CS8;

  474.     tty.c_cc[VMIN] = 1;

  475.     tty.c_cc[VTIME] = 0;

  476. 

  477.     tcsetattr (0, TCSANOW, &tty);

  478.     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */

  479.     }

  480. #endif

  481. 

  482.     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */

  483.     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */

  484. #ifdef SIGXCPU

  485.     signal(SIGXCPU, sigterm_handler);

  486. #endif

  487. }

  488. 

  489. /* read a key without blocking */

  490. static int read_key(void)

  491. {

  492. #if HAVE_TERMIOS_H

  493.     int n = 1;

  494.     unsigned char ch;

  495.     struct timeval tv;

  496.     fd_set rfds;

  497. 

  498.     if(run_as_daemon)

  499.         return -1;

  500. 

  501.     FD_ZERO(&rfds);

  502.     FD_SET(0, &rfds);

  503.     tv.tv_sec = 0;

  504.     tv.tv_usec = 0;

  505.     n = select(1, &rfds, NULL, NULL, &tv);

  506.     if (n > 0) {

  507.         n = read(0, &ch, 1);

  508.         if (n == 1)

  509.             return ch;

  510. 

  511.         return n;

  512.     }

  513. #elif HAVE_KBHIT

  514.     if(kbhit())

  515.         return(getch());

  516. #endif

  517.     return -1;

  518. }

  519. 

  520. static int decode_interrupt_cb(void)

  521. {

  522.     q_pressed += read_key() == 'q';

  523.     return q_pressed > 1;

  524. }

  525. 

  526. static int ffmpeg_exit(int ret)

  527. {

  528.     int i;

  529. 

  530.     /* close files */

  531.     for(i=0;i<nb_output_files;i++) {

  532.         AVFormatContext *s = output_files[i];

  533.         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)

  534.             avio_close(s->pb);

  535.         avformat_free_context(s);

  536.         av_free(output_streams_for_file[i]);

  537.         av_dict_free(&output_opts[i]);

  538.     }

  539.     for(i=0;i<nb_input_files;i++) {

  540.         av_close_input_file(input_files[i].ctx);

  541.     }

  542.     for (i = 0; i < nb_input_streams; i++)

  543.         av_dict_free(&input_streams[i].opts);

  544. 

  545.     av_free(intra_matrix);

  546.     av_free(inter_matrix);

  547. 

  548.     if (vstats_file)

  549.         fclose(vstats_file);

  550.     av_free(vstats_filename);

  551. 

  552.     av_free(streamid_map);

  553.     av_free(stream_maps);

  554.     av_free(meta_data_maps);

  555. 

  556.     av_freep(&input_streams);

  557.     av_freep(&input_files);

  558. 

  559.     av_free(video_codec_name);

  560.     av_free(audio_codec_name);

  561.     av_free(subtitle_codec_name);

  562.     av_free(data_codec_name);

  563. 

  564.     uninit_opts();

  565.     av_free(audio_buf);

  566.     av_free(audio_out);

  567.     allocated_audio_buf_size= allocated_audio_out_size= 0;

  568.     av_free(samples);

  569. 

  570. #if CONFIG_AVFILTER

  571.     avfilter_uninit();

  572. #endif

  573. 

  574.     if (received_sigterm) {

  575.         fprintf(stderr,

  576.             "Received signal %d: terminating.\n",

  577.             (int) received_sigterm);

  578.         exit (255);

  579.     }

  580. 

  581.     exit(ret); /* not all OS-es handle main() return value */

  582.     return ret;

  583. }

  584. 

  585. static void assert_avoptions(AVDictionary *m)

  586. {

  587.     AVDictionaryEntry *t;

  588.     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {

  589.         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);

  590.         ffmpeg_exit(1);

  591.     }

  592. }

  593. 

  594. static void assert_codec_experimental(AVCodecContext *c, int encoder)

  595. {

  596.     const char *codec_string = encoder ? "encoder" : "decoder";

  597.     AVCodec *codec;

  598.     if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&

  599.         c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

  600.         av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "

  601.                 "results.\nAdd '-strict experimental' if you want to use it.\n",

  602.                 codec_string, c->codec->name);

  603.         codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);

  604.         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))

  605.             av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",

  606.                    codec_string, codec->name);

  607.         ffmpeg_exit(1);

  608.     }

  609. }

  610. 

  611. /* similar to ff_dynarray_add() and av_fast_realloc() */

  612. static void *grow_array(void *array, int elem_size, int *size, int new_size)

  613. {

  614.     if (new_size >= INT_MAX / elem_size) {

  615.         fprintf(stderr, "Array too big.\n");

  616.         ffmpeg_exit(1);

  617.     }

  618.     if (*size < new_size) {

  619.         uint8_t *tmp = av_realloc(array, new_size*elem_size);

  620.         if (!tmp) {

  621.             fprintf(stderr, "Could not alloc buffer.\n");

  622.             ffmpeg_exit(1);

  623.         }

  624.         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);

  625.         *size = new_size;

  626.         return tmp;

  627.     }

  628.     return array;

  629. }

  630. 

  631. static void choose_sample_fmt(AVStream *st, AVCodec *codec)

  632. {

  633.     if(codec && codec->sample_fmts){

  634.         const enum AVSampleFormat *p= codec->sample_fmts;

  635.         for(; *p!=-1; p++){

  636.             if(*p == st->codec->sample_fmt)

  637.                 break;

  638.         }

  639.         if (*p == -1) {

  640.             if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))

  641.                 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");

  642.             if(av_get_sample_fmt_name(st->codec->sample_fmt))

  643.             av_log(NULL, AV_LOG_WARNING,

  644.                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",

  645.                    av_get_sample_fmt_name(st->codec->sample_fmt),

  646.                    codec->name,

  647.                    av_get_sample_fmt_name(codec->sample_fmts[0]));

  648.             st->codec->sample_fmt = codec->sample_fmts[0];

  649.         }

  650.     }

  651. }

  652. 

  653. static void choose_sample_rate(AVStream *st, AVCodec *codec)

  654. {

  655.     if(codec && codec->supported_samplerates){

  656.         const int *p= codec->supported_samplerates;

  657.         int best=0;

  658.         int best_dist=INT_MAX;

  659.         for(; *p; p++){

  660.             int dist= abs(st->codec->sample_rate - *p);

  661.             if(dist < best_dist){

  662.                 best_dist= dist;

  663.                 best= *p;

  664.             }

  665.         }

  666.         if(best_dist){

  667.             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);

  668.         }

  669.         st->codec->sample_rate= best;

  670.     }

  671. }

  672. 

  673. static void choose_pixel_fmt(AVStream *st, AVCodec *codec)

  674. {

  675.     if(codec && codec->pix_fmts){

  676.         const enum PixelFormat *p= codec->pix_fmts;

  677.         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){

  678.             if(st->codec->codec_id==CODEC_ID_MJPEG){

  679.                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};

  680.             }else if(st->codec->codec_id==CODEC_ID_LJPEG){

  681.                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};

  682.             }

  683.         }

  684.         for(; *p!=-1; p++){

  685.             if(*p == st->codec->pix_fmt)

  686.                 break;

  687.         }

  688.         if (*p == -1) {

  689.             if(st->codec->pix_fmt != PIX_FMT_NONE)

  690.                 av_log(NULL, AV_LOG_WARNING,

  691.                         "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",

  692.                         av_pix_fmt_descriptors[st->codec->pix_fmt].name,

  693.                         codec->name,

  694.                         av_pix_fmt_descriptors[codec->pix_fmts[0]].name);

  695.             st->codec->pix_fmt = codec->pix_fmts[0];

  696.         }

  697.     }

  698. }

  699. 

  700. static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)

  701. {

  702.     OutputStream *ost;

  703.     AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);

  704.     int idx      = oc->nb_streams - 1;

  705. 

  706.     if (!st) {

  707.         av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");

  708.         ffmpeg_exit(1);

  709.     }

  710. 

  711.     output_streams_for_file[file_idx] =

  712.         grow_array(output_streams_for_file[file_idx],

  713.                    sizeof(*output_streams_for_file[file_idx]),

  714.                    &nb_output_streams_for_file[file_idx],

  715.                    oc->nb_streams);

  716.     ost = output_streams_for_file[file_idx][idx] =

  717.         av_mallocz(sizeof(OutputStream));

  718.     if (!ost) {

  719.         fprintf(stderr, "Could not alloc output stream\n");

  720.         ffmpeg_exit(1);

  721.     }

  722.     ost->file_index = file_idx;

  723.     ost->index = idx;

  724.     ost->st    = st;

  725.     ost->enc   = codec;

  726.     if (codec)

  727.         ost->opts  = filter_codec_opts(codec_opts, codec->id, oc, st);

  728. 

  729.     avcodec_get_context_defaults3(st->codec, codec);

  730. 

  731.     ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);

  732.     return ost;

  733. }

  734. 

  735. static int read_ffserver_streams(AVFormatContext *s, const char *filename)

  736. {

  737.     int i, err;

  738.     AVFormatContext *ic = NULL;

  739. 

  740.     err = avformat_open_input(&ic, filename, NULL, NULL);

  741.     if (err < 0)

  742.         return err;

  743.     /* copy stream format */

  744.     for(i=0;i<ic->nb_streams;i++) {

  745.         AVStream *st;

  746.         OutputStream *ost;

  747.         AVCodec *codec;

  748. 

  749.         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);

  750.         ost   = new_output_stream(s, nb_output_files, codec);

  751.         st    = ost->st;

  752. 

  753.         // FIXME: a more elegant solution is needed

  754.         memcpy(st, ic->streams[i], sizeof(AVStream));

  755.         st->info = av_malloc(sizeof(*st->info));

  756.         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));

  757.         avcodec_copy_context(st->codec, ic->streams[i]->codec);

  758. 

  759.         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {

  760.             if (audio_stream_copy) {

  761.                 st->stream_copy = 1;

  762.             } else

  763.                 choose_sample_fmt(st, codec);

  764.         } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {

  765.             if (video_stream_copy) {

  766.                 st->stream_copy = 1;

  767.             } else

  768.                 choose_pixel_fmt(st, codec);

  769.         }

  770.     }

  771. 

  772.     av_close_input_file(ic);

  773.     return 0;

  774. }

  775. 

  776. static double

  777. get_sync_ipts(const OutputStream *ost)

  778. {

  779.     const InputStream *ist = ost->sync_ist;

  780.     return (double)(ist->pts - start_time)/AV_TIME_BASE;

  781. }

  782. 

  783. static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){

  784.     int ret;

  785. 

  786.     while(bsfc){

  787.         AVPacket new_pkt= *pkt;

  788.         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,

  789.                                           &new_pkt.data, &new_pkt.size,

  790.                                           pkt->data, pkt->size,

  791.                                           pkt->flags & AV_PKT_FLAG_KEY);

  792.         if(a>0){

  793.             av_free_packet(pkt);

  794.             new_pkt.destruct= av_destruct_packet;

  795.         } else if(a<0){

  796.             fprintf(stderr, "%s failed for stream %d, codec %s",

  797.                     bsfc->filter->name, pkt->stream_index,

  798.                     avctx->codec ? avctx->codec->name : "copy");

  799.             print_error("", a);

  800.             if (exit_on_error)

  801.                 ffmpeg_exit(1);

  802.         }

  803.         *pkt= new_pkt;

  804. 

  805.         bsfc= bsfc->next;

  806.     }

  807. 

  808.     ret= av_interleaved_write_frame(s, pkt);

  809.     if(ret < 0){

  810.         print_error("av_interleaved_write_frame()", ret);

  811.         ffmpeg_exit(1);

  812.     }

  813. }

  814. 

  815. #define MAX_AUDIO_PACKET_SIZE (128 * 1024)

  816. 

  817. static void do_audio_out(AVFormatContext *s,

  818.                          OutputStream *ost,

  819.                          InputStream *ist,

  820.                          unsigned char *buf, int size)

  821. {

  822.     uint8_t *buftmp;

  823.     int64_t audio_out_size, audio_buf_size;

  824.     int64_t allocated_for_size= size;

  825. 

  826.     int size_out, frame_bytes, ret, resample_changed;

  827.     AVCodecContext *enc= ost->st->codec;

  828.     AVCodecContext *dec= ist->st->codec;

  829.     int osize = av_get_bytes_per_sample(enc->sample_fmt);

  830.     int isize = av_get_bytes_per_sample(dec->sample_fmt);

  831.     const int coded_bps = av_get_bits_per_sample(enc->codec->id);

  832. 

  833. need_realloc:

  834.     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);

  835.     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;

  836.     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API

  837.     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);

  838.     audio_buf_size*= osize*enc->channels;

  839. 

  840.     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);

  841.     if(coded_bps > 8*osize)

  842.         audio_out_size= audio_out_size * coded_bps / (8*osize);

  843.     audio_out_size += FF_MIN_BUFFER_SIZE;

  844. 

  845.     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){

  846.         fprintf(stderr, "Buffer sizes too large\n");

  847.         ffmpeg_exit(1);

  848.     }

  849. 

  850.     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);

  851.     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);

  852.     if (!audio_buf || !audio_out){

  853.         fprintf(stderr, "Out of memory in do_audio_out\n");

  854.         ffmpeg_exit(1);

  855.     }

  856. 

  857.     if (enc->channels != dec->channels)

  858.         ost->audio_resample = 1;

  859. 

  860.     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||

  861.                        ost->resample_channels    != dec->channels   ||

  862.                        ost->resample_sample_rate != dec->sample_rate;

  863. 

  864.     if ((ost->audio_resample && !ost->resample) || resample_changed) {

  865.         if (resample_changed) {

  866.             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",

  867.                    ist->file_index, ist->st->index,

  868.                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,

  869.                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);

  870.             ost->resample_sample_fmt  = dec->sample_fmt;

  871.             ost->resample_channels    = dec->channels;

  872.             ost->resample_sample_rate = dec->sample_rate;

  873.             if (ost->resample)

  874.                 audio_resample_close(ost->resample);

  875.         }

  876.         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */

  877.         if (audio_sync_method <= 1 &&

  878.             ost->resample_sample_fmt  == enc->sample_fmt &&

  879.             ost->resample_channels    == enc->channels   &&

  880.             ost->resample_sample_rate == enc->sample_rate) {

  881.             ost->resample = NULL;

  882.             ost->audio_resample = 0;

  883.         } else {

  884.             if (dec->sample_fmt != AV_SAMPLE_FMT_S16)

  885.                 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");

  886.             ost->resample = av_audio_resample_init(enc->channels,    dec->channels,

  887.                                                    enc->sample_rate, dec->sample_rate,

  888.                                                    enc->sample_fmt,  dec->sample_fmt,

  889.                                                    16, 10, 0, 0.8);

  890.             if (!ost->resample) {

  891.                 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",

  892.                         dec->channels, dec->sample_rate,

  893.                         enc->channels, enc->sample_rate);

  894.                 ffmpeg_exit(1);

  895.             }

  896.         }

  897.     }

  898. 

  899. #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))

  900.     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&

  901.         MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {

  902.         if (ost->reformat_ctx)

  903.             av_audio_convert_free(ost->reformat_ctx);

  904.         ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,

  905.                                                    dec->sample_fmt, 1, NULL, 0);

  906.         if (!ost->reformat_ctx) {

  907.             fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",

  908.                 av_get_sample_fmt_name(dec->sample_fmt),

  909.                 av_get_sample_fmt_name(enc->sample_fmt));

  910.             ffmpeg_exit(1);

  911.         }

  912.         ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);

  913.     }

  914. 

  915.     if(audio_sync_method){

  916.         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts

  917.                 - av_fifo_size(ost->fifo)/(enc->channels * 2);

  918.         double idelta= delta*dec->sample_rate / enc->sample_rate;

  919.         int byte_delta= ((int)idelta)*2*dec->channels;

  920. 

  921.         //FIXME resample delay

  922.         if(fabs(delta) > 50){

  923.             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){

  924.                 if(byte_delta < 0){

  925.                     byte_delta= FFMAX(byte_delta, -size);

  926.                     size += byte_delta;

  927.                     buf  -= byte_delta;

  928.                     if(verbose > 2)

  929.                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);

  930.                     if(!size)

  931.                         return;

  932.                     ist->is_start=0;

  933.                 }else{

  934.                     static uint8_t *input_tmp= NULL;

  935.                     input_tmp= av_realloc(input_tmp, byte_delta + size);

  936. 

  937.                     if(byte_delta > allocated_for_size - size){

  938.                         allocated_for_size= byte_delta + (int64_t)size;

  939.                         goto need_realloc;

  940.                     }

  941.                     ist->is_start=0;

  942. 

  943.                     memset(input_tmp, 0, byte_delta);

  944.                     memcpy(input_tmp + byte_delta, buf, size);

  945.                     buf= input_tmp;

  946.                     size += byte_delta;

  947.                     if(verbose > 2)

  948.                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);

  949.                 }

  950.             }else if(audio_sync_method>1){

  951.                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);

  952.                 av_assert0(ost->audio_resample);

  953.                 if(verbose > 2)

  954.                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);

  955. //                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));

  956.                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);

  957.             }

  958.         }

  959.     }else

  960.         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)

  961.                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong

  962. 

  963.     if (ost->audio_resample) {

  964.         buftmp = audio_buf;

  965.         size_out = audio_resample(ost->resample,

  966.                                   (short *)buftmp, (short *)buf,

  967.                                   size / (dec->channels * isize));

  968.         size_out = size_out * enc->channels * osize;

  969.     } else {

  970.         buftmp = buf;

  971.         size_out = size;

  972.     }

  973. 

  974.     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {

  975.         const void *ibuf[6]= {buftmp};

  976.         void *obuf[6]= {audio_buf};

  977.         int istride[6]= {isize};

  978.         int ostride[6]= {osize};

  979.         int len= size_out/istride[0];

  980.         if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {

  981.             printf("av_audio_convert() failed\n");

  982.             if (exit_on_error)

  983.                 ffmpeg_exit(1);

  984.             return;

  985.         }

  986.         buftmp = audio_buf;

  987.         size_out = len*osize;

  988.     }

  989. 

  990.     /* now encode as many frames as possible */

  991.     if (enc->frame_size > 1) {

  992.         /* output resampled raw samples */

  993.         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {

  994.             fprintf(stderr, "av_fifo_realloc2() failed\n");

  995.             ffmpeg_exit(1);

  996.         }

  997.         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);

  998. 

  999.         frame_bytes = enc->frame_size * osize * enc->channels;

  1000. 

  1001.         while (av_fifo_size(ost->fifo) >= frame_bytes) {

  1002.             AVPacket pkt;

  1003.             av_init_packet(&pkt);

  1004. 

  1005.             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);

  1006. 

  1007.             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()

  1008. 

  1009.             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,

  1010.                                        (short *)audio_buf);

  1011.             if (ret < 0) {

  1012.                 fprintf(stderr, "Audio encoding failed\n");

  1013.                 ffmpeg_exit(1);

  1014.             }

  1015.             audio_size += ret;

  1016.             pkt.stream_index= ost->index;

  1017.             pkt.data= audio_out;

  1018.             pkt.size= ret;

  1019.             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

  1020.                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

  1021.             pkt.flags |= AV_PKT_FLAG_KEY;

  1022.             write_frame(s, &pkt, enc, ost->bitstream_filters);

  1023. 

  1024.             ost->sync_opts += enc->frame_size;

  1025.         }

  1026.     } else {

  1027.         AVPacket pkt;

  1028.         av_init_packet(&pkt);

  1029. 

  1030.         ost->sync_opts += size_out / (osize * enc->channels);

  1031. 

  1032.         /* output a pcm frame */

  1033.         /* determine the size of the coded buffer */

  1034.         size_out /= osize;

  1035.         if (coded_bps)

  1036.             size_out = size_out*coded_bps/8;

  1037. 

  1038.         if(size_out > audio_out_size){

  1039.             fprintf(stderr, "Internal error, buffer size too small\n");

  1040.             ffmpeg_exit(1);

  1041.         }

  1042. 

  1043.         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()

  1044.         ret = avcodec_encode_audio(enc, audio_out, size_out,

  1045.                                    (short *)buftmp);

  1046.         if (ret < 0) {

  1047.             fprintf(stderr, "Audio encoding failed\n");

  1048.             ffmpeg_exit(1);

  1049.         }

  1050.         audio_size += ret;

  1051.         pkt.stream_index= ost->index;

  1052.         pkt.data= audio_out;

  1053.         pkt.size= ret;

  1054.         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

  1055.             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

  1056.         pkt.flags |= AV_PKT_FLAG_KEY;

  1057.         write_frame(s, &pkt, enc, ost->bitstream_filters);

  1058.     }

  1059. }

  1060. 

  1061. static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)

  1062. {

  1063.     AVCodecContext *dec;

  1064.     AVPicture *picture2;

  1065.     AVPicture picture_tmp;

  1066.     uint8_t *buf = 0;

  1067. 

  1068.     dec = ist->st->codec;

  1069. 

  1070.     /* deinterlace : must be done before any resize */

  1071.     if (do_deinterlace) {

  1072.         int size;

  1073. 

  1074.         /* create temporary picture */

  1075.         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);

  1076.         buf = av_malloc(size);

  1077.         if (!buf)

  1078.             return;

  1079. 

  1080.         picture2 = &picture_tmp;

  1081.         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);

  1082. 

  1083.         if(avpicture_deinterlace(picture2, picture,

  1084.                                  dec->pix_fmt, dec->width, dec->height) < 0) {

  1085.             /* if error, do not deinterlace */

  1086.             fprintf(stderr, "Deinterlacing failed\n");

  1087.             av_free(buf);

  1088.             buf = NULL;

  1089.             picture2 = picture;

  1090.         }

  1091.     } else {

  1092.         picture2 = picture;

  1093.     }

  1094. 

  1095.     if (picture != picture2)

  1096.         *picture = *picture2;

  1097.     *bufp = buf;

  1098. }

  1099. 

  1100. /* we begin to correct av delay at this threshold */

  1101. #define AV_DELAY_MAX 0.100

  1102. 

  1103. static void do_subtitle_out(AVFormatContext *s,

  1104.                             OutputStream *ost,

  1105.                             InputStream *ist,

  1106.                             AVSubtitle *sub,

  1107.                             int64_t pts)

  1108. {

  1109.     static uint8_t *subtitle_out = NULL;

  1110.     int subtitle_out_max_size = 1024 * 1024;

  1111.     int subtitle_out_size, nb, i;

  1112.     AVCodecContext *enc;

  1113.     AVPacket pkt;

  1114. 

  1115.     if (pts == AV_NOPTS_VALUE) {

  1116.         fprintf(stderr, "Subtitle packets must have a pts\n");

  1117.         if (exit_on_error)

  1118.             ffmpeg_exit(1);

  1119.         return;

  1120.     }

  1121. 

  1122.     enc = ost->st->codec;

  1123. 

  1124.     if (!subtitle_out) {

  1125.         subtitle_out = av_malloc(subtitle_out_max_size);

  1126.     }

  1127. 

  1128.     /* Note: DVB subtitle need one packet to draw them and one other

  1129.        packet to clear them */

  1130.     /* XXX: signal it in the codec context ? */

  1131.     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)

  1132.         nb = 2;

  1133.     else

  1134.         nb = 1;

  1135. 

  1136.     for(i = 0; i < nb; i++) {

  1137.         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);

  1138.         // start_display_time is required to be 0

  1139.         sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);

  1140.         sub->end_display_time -= sub->start_display_time;

  1141.         sub->start_display_time = 0;

  1142.         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,

  1143.                                                     subtitle_out_max_size, sub);

  1144.         if (subtitle_out_size < 0) {

  1145.             fprintf(stderr, "Subtitle encoding failed\n");

  1146.             ffmpeg_exit(1);

  1147.         }

  1148. 

  1149.         av_init_packet(&pkt);

  1150.         pkt.stream_index = ost->index;

  1151.         pkt.data = subtitle_out;

  1152.         pkt.size = subtitle_out_size;

  1153.         pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);

  1154.         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {

  1155.             /* XXX: the pts correction is handled here. Maybe handling

  1156.                it in the codec would be better */

  1157.             if (i == 0)

  1158.                 pkt.pts += 90 * sub->start_display_time;

  1159.             else

  1160.                 pkt.pts += 90 * sub->end_display_time;

  1161.         }

  1162.         write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);

  1163.     }

  1164. }

  1165. 

  1166. static int bit_buffer_size= 1024*256;

  1167. static uint8_t *bit_buffer= NULL;

  1168. 

  1169. static void do_video_out(AVFormatContext *s,

  1170.                          OutputStream *ost,

  1171.                          InputStream *ist,

  1172.                          AVFrame *in_picture,

  1173.                          int *frame_size, float quality)

  1174. {

  1175.     int nb_frames, i, ret, av_unused resample_changed;

  1176.     AVFrame *final_picture, *formatted_picture;

  1177.     AVCodecContext *enc, *dec;

  1178.     double sync_ipts;

  1179. 

  1180.     enc = ost->st->codec;

  1181.     dec = ist->st->codec;

  1182. 

  1183.     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);

  1184. 

  1185.     /* by default, we output a single frame */

  1186.     nb_frames = 1;

  1187. 

  1188.     *frame_size = 0;

  1189. 

  1190.     if(video_sync_method){

  1191.         double vdelta = sync_ipts - ost->sync_opts;

  1192.         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c

  1193.         if (vdelta < -1.1)

  1194.             nb_frames = 0;

  1195.         else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){

  1196.             if(vdelta<=-0.6){

  1197.                 nb_frames=0;

  1198.             }else if(vdelta>0.6)

  1199.                 ost->sync_opts= lrintf(sync_ipts);

  1200.         }else if (vdelta > 1.1)

  1201.             nb_frames = lrintf(vdelta);

  1202. //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);

  1203.         if (nb_frames == 0){

  1204.             ++nb_frames_drop;

  1205.             if (verbose>2)

  1206.                 fprintf(stderr, "*** drop!\n");

  1207.         }else if (nb_frames > 1) {

  1208.             nb_frames_dup += nb_frames - 1;

  1209.             if (verbose>2)

  1210.                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);

  1211.         }

  1212.     }else

  1213.         ost->sync_opts= lrintf(sync_ipts);

  1214. 

  1215.     nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);

  1216.     if (nb_frames <= 0)

  1217.         return;

  1218. 

  1219.     formatted_picture = in_picture;

  1220.     final_picture = formatted_picture;

  1221. 

  1222. #if !CONFIG_AVFILTER

  1223.     resample_changed = ost->resample_width   != dec->width  ||

  1224.                        ost->resample_height  != dec->height ||

  1225.                        ost->resample_pix_fmt != dec->pix_fmt;

  1226. 

  1227.     if (resample_changed) {

  1228.         av_log(NULL, AV_LOG_INFO,

  1229.                "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",

  1230.                ist->file_index, ist->st->index,

  1231.                ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),

  1232.                dec->width         , dec->height         , av_get_pix_fmt_name(dec->pix_fmt));

  1233.         ost->resample_width   = dec->width;

  1234.         ost->resample_height  = dec->height;

  1235.         ost->resample_pix_fmt = dec->pix_fmt;

  1236.     }

  1237. 

  1238.     ost->video_resample = dec->width   != enc->width  ||

  1239.                           dec->height  != enc->height ||

  1240.                           dec->pix_fmt != enc->pix_fmt;

  1241. 

  1242.     if (ost->video_resample) {

  1243.         final_picture = &ost->resample_frame;

  1244.         if (!ost->img_resample_ctx || resample_changed) {

  1245.             /* initialize the destination picture */

  1246.             if (!ost->resample_frame.data[0]) {

  1247.                 avcodec_get_frame_defaults(&ost->resample_frame);

  1248.                 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,

  1249.                                     enc->width, enc->height)) {

  1250.                     fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");

  1251.                     ffmpeg_exit(1);

  1252.                 }

  1253.             }

  1254.             /* initialize a new scaler context */

  1255.             sws_freeContext(ost->img_resample_ctx);

  1256.             ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,

  1257.                                                    enc->width, enc->height, enc->pix_fmt,

  1258.                                                    ost->sws_flags, NULL, NULL, NULL);

  1259.             if (ost->img_resample_ctx == NULL) {

  1260.                 fprintf(stderr, "Cannot get resampling context\n");

  1261.                 ffmpeg_exit(1);

  1262.             }

  1263.         }

  1264.         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,

  1265.               0, ost->resample_height, final_picture->data, final_picture->linesize);

  1266.     }

  1267. #endif

  1268. 

  1269.     /* duplicates frame if needed */

  1270.     for(i=0;i<nb_frames;i++) {

  1271.         AVPacket pkt;

  1272.         av_init_packet(&pkt);

  1273.         pkt.stream_index= ost->index;

  1274. 

  1275.         if (s->oformat->flags & AVFMT_RAWPICTURE) {

  1276.             /* raw pictures are written as AVPicture structure to

  1277.                avoid any copies. We support temorarily the older

  1278.                method. */

  1279.             AVFrame* old_frame = enc->coded_frame;

  1280.             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack

  1281.             pkt.data= (uint8_t *)final_picture;

  1282.             pkt.size=  sizeof(AVPicture);

  1283.             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);

  1284.             pkt.flags |= AV_PKT_FLAG_KEY;

  1285. 

  1286.             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);

  1287.             enc->coded_frame = old_frame;

  1288.         } else {

  1289.             AVFrame big_picture;

  1290. 

  1291.             big_picture= *final_picture;

  1292.             /* better than nothing: use input picture interlaced

  1293.                settings */

  1294.             big_picture.interlaced_frame = in_picture->interlaced_frame;

  1295.             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {

  1296.                 if(top_field_first == -1)

  1297.                     big_picture.top_field_first = in_picture->top_field_first;

  1298.                 else

  1299.                     big_picture.top_field_first = top_field_first;

  1300.             }

  1301. 

  1302.             /* handles sameq here. This is not correct because it may

  1303.                not be a global option */

  1304.             big_picture.quality = quality;

  1305.             if(!me_threshold)

  1306.                 big_picture.pict_type = 0;

  1307. //            big_picture.pts = AV_NOPTS_VALUE;

  1308.             big_picture.pts= ost->sync_opts;

  1309. //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);

  1310. //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);

  1311.             if (ost->forced_kf_index < ost->forced_kf_count &&

  1312.                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {

  1313.                 big_picture.pict_type = AV_PICTURE_TYPE_I;

  1314.                 ost->forced_kf_index++;

  1315.             }

  1316.             ret = avcodec_encode_video(enc,

  1317.                                        bit_buffer, bit_buffer_size,

  1318.                                        &big_picture);

  1319.             if (ret < 0) {

  1320.                 fprintf(stderr, "Video encoding failed\n");

  1321.                 ffmpeg_exit(1);

  1322.             }

  1323. 

  1324.             if(ret>0){

  1325.                 pkt.data= bit_buffer;

  1326.                 pkt.size= ret;

  1327.                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)

  1328.                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

  1329. /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",

  1330.    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,

  1331.    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/

  1332. 

  1333.                 if(enc->coded_frame->key_frame)

  1334.                     pkt.flags |= AV_PKT_FLAG_KEY;

  1335.                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);

  1336.                 *frame_size = ret;

  1337.                 video_size += ret;

  1338.                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",

  1339.                 //        enc->frame_number-1, ret, enc->pict_type);

  1340.                 /* if two pass, output log */

  1341.                 if (ost->logfile && enc->stats_out) {

  1342.                     fprintf(ost->logfile, "%s", enc->stats_out);

  1343.                 }

  1344.             }

  1345.         }

  1346.         ost->sync_opts++;

  1347.         ost->frame_number++;

  1348.     }

  1349. }

  1350. 

  1351. static double psnr(double d){

  1352.     return -10.0*log(d)/log(10.0);

  1353. }

  1354. 

  1355. static void do_video_stats(AVFormatContext *os, OutputStream *ost,

  1356.                            int frame_size)

  1357. {

  1358.     AVCodecContext *enc;

  1359.     int frame_number;

  1360.     double ti1, bitrate, avg_bitrate;

  1361. 

  1362.     /* this is executed just the first time do_video_stats is called */

  1363.     if (!vstats_file) {

  1364.         vstats_file = fopen(vstats_filename, "w");

  1365.         if (!vstats_file) {

  1366.             perror("fopen");

  1367.             ffmpeg_exit(1);

  1368.         }

  1369.     }

  1370. 

  1371.     enc = ost->st->codec;

  1372.     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {

  1373.         frame_number = ost->frame_number;

  1374.         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);

  1375.         if (enc->flags&CODEC_FLAG_PSNR)

  1376.             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));

  1377. 

  1378.         fprintf(vstats_file,"f_size= %6d ", frame_size);

  1379.         /* compute pts value */

  1380.         ti1 = ost->sync_opts * av_q2d(enc->time_base);

  1381.         if (ti1 < 0.01)

  1382.             ti1 = 0.01;

  1383. 

  1384.         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;

  1385.         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;

  1386.         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",

  1387.             (double)video_size / 1024, ti1, bitrate, avg_bitrate);

  1388.         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));

  1389.     }

  1390. }

  1391. 

  1392. static void print_report(AVFormatContext **output_files,

  1393.                          OutputStream **ost_table, int nb_ostreams,

  1394.                          int is_last_report)

  1395. {

  1396.     char buf[1024];

  1397.     OutputStream *ost;

  1398.     AVFormatContext *oc;

  1399.     int64_t total_size;

  1400.     AVCodecContext *enc;

  1401.     int frame_number, vid, i;

  1402.     double bitrate;

  1403.     int64_t pts = INT64_MAX;

  1404.     static int64_t last_time = -1;

  1405.     static int qp_histogram[52];

  1406. 

  1407.     if (!is_last_report) {

  1408.         int64_t cur_time;

  1409.         /* display the report every 0.5 seconds */

  1410.         cur_time = av_gettime();

  1411.         if (last_time == -1) {

  1412.             last_time = cur_time;

  1413.             return;

  1414.         }

  1415.         if ((cur_time - last_time) < 500000)

  1416.             return;

  1417.         last_time = cur_time;

  1418.     }

  1419. 

  1420. 

  1421.     oc = output_files[0];

  1422. 

  1423.     total_size = avio_size(oc->pb);

  1424.     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too

  1425.         total_size= avio_tell(oc->pb);

  1426. 

  1427.     buf[0] = '\0';

  1428.     vid = 0;

  1429.     for(i=0;i<nb_ostreams;i++) {

  1430.         float q = -1;

  1431.         ost = ost_table[i];

  1432.         enc = ost->st->codec;

  1433.         if (!ost->st->stream_copy && enc->coded_frame)

  1434.             q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;

  1435.         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {

  1436.             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);

  1437.         }

  1438.         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {

  1439.             float t = (av_gettime()-timer_start) / 1000000.0;

  1440. 

  1441.             frame_number = ost->frame_number;

  1442.             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",

  1443.                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);

  1444.             if(is_last_report)

  1445.                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");

  1446.             if(qp_hist){

  1447.                 int j;

  1448.                 int qp = lrintf(q);

  1449.                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))

  1450.                     qp_histogram[qp]++;

  1451.                 for(j=0; j<32; j++)

  1452.                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));

  1453.             }

  1454.             if (enc->flags&CODEC_FLAG_PSNR){

  1455.                 int j;

  1456.                 double error, error_sum=0;

  1457.                 double scale, scale_sum=0;

  1458.                 char type[3]= {'Y','U','V'};

  1459.                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");

  1460.                 for(j=0; j<3; j++){

  1461.                     if(is_last_report){

  1462.                         error= enc->error[j];

  1463.                         scale= enc->width*enc->height*255.0*255.0*frame_number;

  1464.                     }else{

  1465.                         error= enc->coded_frame->error[j];

  1466.                         scale= enc->width*enc->height*255.0*255.0;

  1467.                     }

  1468.                     if(j) scale/=4;

  1469.                     error_sum += error;

  1470.                     scale_sum += scale;

  1471.                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));

  1472.                 }

  1473.                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));

  1474.             }

  1475.             vid = 1;

  1476.         }

  1477.         /* compute min output value */

  1478.         pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,

  1479.                                       ost->st->time_base, AV_TIME_BASE_Q));

  1480.     }

  1481. 

  1482.     if (verbose > 0 || is_last_report) {

  1483.         int hours, mins, secs, us;

  1484.         secs = pts / AV_TIME_BASE;

  1485.         us = pts % AV_TIME_BASE;

  1486.         mins = secs / 60;

  1487.         secs %= 60;

  1488.         hours = mins / 60;

  1489.         mins %= 60;

  1490. 

  1491.         bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;

  1492. 

  1493.         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),

  1494.                  "size=%8.0fkB time=", total_size / 1024.0);

  1495.         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),

  1496.                  "%02d:%02d:%02d.%02d ", hours, mins, secs,

  1497.                  (100 * us) / AV_TIME_BASE);

  1498.         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),

  1499.                  "bitrate=%6.1fkbits/s", bitrate);

  1500. 

  1501.         if (nb_frames_dup || nb_frames_drop)

  1502.           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",

  1503.                   nb_frames_dup, nb_frames_drop);

  1504. 

  1505.         if (verbose >= 0)

  1506.             fprintf(stderr, "%s    \r", buf);

  1507. 

  1508.         fflush(stderr);

  1509.     }

  1510. 

  1511.     if (is_last_report && verbose >= 0){

  1512.         int64_t raw= audio_size + video_size + extra_size;

  1513.         fprintf(stderr, "\n");

  1514.         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",

  1515.                 video_size/1024.0,

  1516.                 audio_size/1024.0,

  1517.                 extra_size/1024.0,

  1518.                 100.0*(total_size - raw)/raw

  1519.         );

  1520.     }

  1521. }

  1522. 

  1523. static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)

  1524. {

  1525.     int fill_char = 0x00;

  1526.     if (sample_fmt == AV_SAMPLE_FMT_U8)

  1527.         fill_char = 0x80;

  1528.     memset(buf, fill_char, size);

  1529. }

  1530. 

  1531. /* pkt = NULL means EOF (needed to flush decoder buffers) */

  1532. static int output_packet(InputStream *ist, int ist_index,

  1533.                          OutputStream **ost_table, int nb_ostreams,

  1534.                          const AVPacket *pkt)

  1535. {

  1536.     AVFormatContext *os;

  1537.     OutputStream *ost;

  1538.     int ret, i;

  1539.     int got_output;

  1540.     AVFrame picture;

  1541.     void *buffer_to_free = NULL;

  1542.     static unsigned int samples_size= 0;

  1543.     AVSubtitle subtitle, *subtitle_to_free;

  1544.     int64_t pkt_pts = AV_NOPTS_VALUE;

  1545. #if CONFIG_AVFILTER

  1546.     int frame_available;

  1547. #endif

  1548.     float quality;

  1549. 

  1550.     AVPacket avpkt;

  1551.     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);

  1552. 

  1553.     if(ist->next_pts == AV_NOPTS_VALUE)

  1554.         ist->next_pts= ist->pts;

  1555. 

  1556.     if (pkt == NULL) {

  1557.         /* EOF handling */

  1558.         av_init_packet(&avpkt);

  1559.         avpkt.data = NULL;

  1560.         avpkt.size = 0;

  1561.         goto handle_eof;

  1562.     } else {

  1563.         avpkt = *pkt;

  1564.     }

  1565. 

  1566.     if(pkt->dts != AV_NOPTS_VALUE)

  1567.         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);

  1568.     if(pkt->pts != AV_NOPTS_VALUE)

  1569.         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);

  1570. 

  1571.     //while we have more to decode or while the decoder did output something on EOF

  1572.     while (avpkt.size > 0 || (!pkt && got_output)) {

  1573.         uint8_t *data_buf, *decoded_data_buf;

  1574.         int data_size, decoded_data_size;

  1575.     handle_eof:

  1576.         ist->pts= ist->next_pts;

  1577. 

  1578.         if(avpkt.size && avpkt.size != pkt->size &&

  1579.            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){

  1580.             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);

  1581.             ist->showed_multi_packet_warning=1;

  1582.         }

  1583. 

  1584.         /* decode the packet if needed */

  1585.         decoded_data_buf = NULL; /* fail safe */

  1586.         decoded_data_size= 0;

  1587.         data_buf  = avpkt.data;

  1588.         data_size = avpkt.size;

  1589.         subtitle_to_free = NULL;

  1590.         if (ist->decoding_needed) {

  1591.             switch(ist->st->codec->codec_type) {

  1592.             case AVMEDIA_TYPE_AUDIO:{

  1593.                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {

  1594.                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);

  1595.                     av_free(samples);

  1596.                     samples= av_malloc(samples_size);

  1597.                 }

  1598.                 decoded_data_size= samples_size;

  1599.                     /* XXX: could avoid copy if PCM 16 bits with same

  1600.                        endianness as CPU */

  1601.                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,

  1602.                                             &avpkt);

  1603.                 if (ret < 0)

  1604.                     return ret;

  1605.                 avpkt.data += ret;

  1606.                 avpkt.size -= ret;

  1607.                 data_size   = ret;

  1608.                 got_output  = decoded_data_size > 0;

  1609.                 /* Some bug in mpeg audio decoder gives */

  1610.                 /* decoded_data_size < 0, it seems they are overflows */

  1611.                 if (!got_output) {

  1612.                     /* no audio frame */

  1613.                     continue;

  1614.                 }

  1615.                 decoded_data_buf = (uint8_t *)samples;

  1616.                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /

  1617.                     (ist->st->codec->sample_rate * ist->st->codec->channels);

  1618.                 break;}

  1619.             case AVMEDIA_TYPE_VIDEO:

  1620.                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;

  1621.                     /* XXX: allocate picture correctly */

  1622.                     avcodec_get_frame_defaults(&picture);

  1623.                     avpkt.pts = pkt_pts;

  1624.                     avpkt.dts = ist->pts;

  1625.                     pkt_pts = AV_NOPTS_VALUE;

  1626. 

  1627.                     ret = avcodec_decode_video2(ist->st->codec,

  1628.                                                 &picture, &got_output, &avpkt);

  1629.                     quality = same_quality ? picture.quality : 0;

  1630.                     if (ret < 0)

  1631.                         return ret;

  1632.                     if (!got_output) {

  1633.                         /* no picture yet */

  1634.                         goto discard_packet;

  1635.                     }

  1636.                     ist->next_pts = ist->pts = picture.best_effort_timestamp;

  1637.                     if (ist->st->codec->time_base.num != 0) {

  1638.                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;

  1639.                         ist->next_pts += ((int64_t)AV_TIME_BASE *

  1640.                                           ist->st->codec->time_base.num * ticks) /

  1641.                             ist->st->codec->time_base.den;

  1642.                     }

  1643.                     avpkt.size = 0;

  1644.                     buffer_to_free = NULL;

  1645.                     pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);

  1646.                     break;

  1647.             case AVMEDIA_TYPE_SUBTITLE:

  1648.                 ret = avcodec_decode_subtitle2(ist->st->codec,

  1649.                                                &subtitle, &got_output, &avpkt);

  1650.                 if (ret < 0)

  1651.                     return ret;

  1652.                 if (!got_output) {

  1653.                     goto discard_packet;

  1654.                 }

  1655.                 subtitle_to_free = &subtitle;

  1656.                 avpkt.size = 0;

  1657.                 break;

  1658.             default:

  1659.                 return -1;

  1660.             }

  1661.         } else {

  1662.             switch(ist->st->codec->codec_type) {

  1663.             case AVMEDIA_TYPE_AUDIO:

  1664.                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /

  1665.                     ist->st->codec->sample_rate;

  1666.                 break;

  1667.             case AVMEDIA_TYPE_VIDEO:

  1668.                 if (ist->st->codec->time_base.num != 0) {

  1669.                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;

  1670.                     ist->next_pts += ((int64_t)AV_TIME_BASE *

  1671.                                       ist->st->codec->time_base.num * ticks) /

  1672.                         ist->st->codec->time_base.den;

  1673.                 }

  1674.                 break;

  1675.             }

  1676.             ret = avpkt.size;

  1677.             avpkt.size = 0;

  1678.         }

  1679. 

  1680. #if CONFIG_AVFILTER

  1681.         if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)

  1682.         if (start_time == 0 || ist->pts >= start_time) {

  1683.             for(i=0;i<nb_ostreams;i++) {

  1684.                 ost = ost_table[i];

  1685.                 if (ost->input_video_filter && ost->source_index == ist_index) {

  1686.                     if (!picture.sample_aspect_ratio.num)

  1687.                         picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;

  1688.                     picture.pts = ist->pts;

  1689. 

  1690.                     av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);

  1691.                 }

  1692.             }

  1693.         }

  1694. #endif

  1695. 

  1696.         // preprocess audio (volume)

  1697.         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {

  1698.             if (audio_volume != 256) {

  1699.                 short *volp;

  1700.                 volp = samples;

  1701.                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {

  1702.                     int v = ((*volp) * audio_volume + 128) >> 8;

  1703.                     if (v < -32768) v = -32768;

  1704.                     if (v >  32767) v = 32767;

  1705.                     *volp++ = v;

  1706.                 }

  1707.             }

  1708.         }

  1709. 

  1710.         /* frame rate emulation */

  1711.         if (rate_emu) {

  1712.             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);

  1713.             int64_t now = av_gettime() - ist->start;

  1714.             if (pts > now)

  1715.                 usleep(pts - now);

  1716.         }

  1717.         /* if output time reached then transcode raw format,

  1718.            encode packets and output them */

  1719.         if (start_time == 0 || ist->pts >= start_time)

  1720.             for(i=0;i<nb_ostreams;i++) {

  1721.                 int frame_size;

  1722. 

  1723.                 ost = ost_table[i];

  1724. 

  1725.                 /* finish if recording time exhausted */

  1726.                 if (recording_time != INT64_MAX &&

  1727.                         av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})

  1728.                     >= 0) {

  1729.                     ist->is_past_recording_time = 1;

  1730.                     continue;

  1731.                 }

  1732.                 if (ost->source_index == ist_index) {

  1733. #if CONFIG_AVFILTER

  1734.                 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||

  1735.                     !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);

  1736.                 while (frame_available) {

  1737.                     if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {

  1738.                         AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;

  1739.                         if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)

  1740.                             goto cont;

  1741.                         if (ost->picref) {

  1742.                             avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);

  1743.                             ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);

  1744.                         }

  1745.                     }

  1746. #endif

  1747.                     os = output_files[ost->file_index];

  1748. 

  1749.                     /* set the input output pts pairs */

  1750.                     //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;

  1751. 

  1752.                     if (ost->encoding_needed) {

  1753.                         av_assert0(ist->decoding_needed);

  1754.                         switch(ost->st->codec->codec_type) {

  1755.                         case AVMEDIA_TYPE_AUDIO:

  1756.                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);

  1757.                             break;

  1758.                         case AVMEDIA_TYPE_VIDEO:

  1759. #if CONFIG_AVFILTER

  1760.                             if (ost->picref->video && !ost->frame_aspect_ratio)

  1761.                                 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;

  1762. #endif

  1763.                             do_video_out(os, ost, ist, &picture, &frame_size,

  1764.                                          same_quality ? quality : ost->st->codec->global_quality);

  1765.                             if (vstats_filename && frame_size)

  1766.                                 do_video_stats(os, ost, frame_size);

  1767.                             break;

  1768.                         case AVMEDIA_TYPE_SUBTITLE:

  1769.                             do_subtitle_out(os, ost, ist, &subtitle,

  1770.                                             pkt->pts);

  1771.                             break;

  1772.                         default:

  1773.                             abort();

  1774.                         }

  1775.                     } else {

  1776.                         AVFrame avframe; //FIXME/XXX remove this

  1777.                         AVPicture pict;

  1778.                         AVPacket opkt;

  1779.                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);

  1780. 

  1781.                         av_init_packet(&opkt);

  1782. 

  1783.                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)

  1784. #if !CONFIG_AVFILTER

  1785.                             continue;

  1786. #else

  1787.                             goto cont;

  1788. #endif

  1789. 

  1790.                         /* no reencoding needed : output the packet directly */

  1791.                         /* force the input stream PTS */

  1792. 

  1793.                         avcodec_get_frame_defaults(&avframe);

  1794.                         ost->st->codec->coded_frame= &avframe;

  1795.                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;

  1796. 

  1797.                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)

  1798.                             audio_size += data_size;

  1799.                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {

  1800.                             video_size += data_size;

  1801.                             ost->sync_opts++;

  1802.                         }

  1803. 

  1804.                         opkt.stream_index= ost->index;

  1805.                         if(pkt->pts != AV_NOPTS_VALUE)

  1806.                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;

  1807.                         else

  1808.                             opkt.pts= AV_NOPTS_VALUE;

  1809. 

  1810.                         if (pkt->dts == AV_NOPTS_VALUE)

  1811.                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);

  1812.                         else

  1813.                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);

  1814.                         opkt.dts -= ost_tb_start_time;

  1815. 

  1816.                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);

  1817.                         opkt.flags= pkt->flags;

  1818. 

  1819.                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters

  1820.                         if(   ost->st->codec->codec_id != CODEC_ID_H264

  1821.                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO

  1822.                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO

  1823.                            ) {

  1824.                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))

  1825.                                 opkt.destruct= av_destruct_packet;

  1826.                         } else {

  1827.                             opkt.data = data_buf;

  1828.                             opkt.size = data_size;

  1829.                         }

  1830. 

  1831.                         if (os->oformat->flags & AVFMT_RAWPICTURE) {

  1832.                             /* store AVPicture in AVPacket, as expected by the output format */

  1833.                             avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);

  1834.                             opkt.data = (uint8_t *)&pict;

  1835.                             opkt.size = sizeof(AVPicture);

  1836.                             opkt.flags |= AV_PKT_FLAG_KEY;

  1837.                         }

  1838.                         write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);

  1839.                         ost->st->codec->frame_number++;

  1840.                         ost->frame_number++;

  1841.                         av_free_packet(&opkt);

  1842.                     }

  1843. #if CONFIG_AVFILTER

  1844.                     cont:

  1845.                     frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&

  1846.                                        ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);

  1847.                     avfilter_unref_buffer(ost->picref);

  1848.                 }

  1849. #endif

  1850.                 }

  1851.             }

  1852. 

  1853.         av_free(buffer_to_free);

  1854.         /* XXX: allocate the subtitles in the codec ? */

  1855.         if (subtitle_to_free) {

  1856.             avsubtitle_free(subtitle_to_free);

  1857.             subtitle_to_free = NULL;

  1858.         }

  1859.     }

  1860.  discard_packet:

  1861.     if (pkt == NULL) {

  1862.         /* EOF handling */

  1863. 

  1864.         for(i=0;i<nb_ostreams;i++) {

  1865.             ost = ost_table[i];

  1866.             if (ost->source_index == ist_index) {

  1867.                 AVCodecContext *enc= ost->st->codec;

  1868.                 os = output_files[ost->file_index];

  1869. 

  1870.                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)

  1871.                     continue;

  1872.                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))

  1873.                     continue;

  1874. 

  1875.                 if (ost->encoding_needed) {

  1876.                     for(;;) {

  1877.                         AVPacket pkt;

  1878.                         int fifo_bytes;

  1879.                         av_init_packet(&pkt);

  1880.                         pkt.stream_index= ost->index;

  1881. 

  1882.                         switch(ost->st->codec->codec_type) {

  1883.                         case AVMEDIA_TYPE_AUDIO:

  1884.                             fifo_bytes = av_fifo_size(ost->fifo);

  1885.                             ret = 0;

  1886.                             /* encode any samples remaining in fifo */

  1887.                             if (fifo_bytes > 0) {

  1888.                                 int osize = av_get_bytes_per_sample(enc->sample_fmt);

  1889.                                 int fs_tmp = enc->frame_size;

  1890. 

  1891.                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);

  1892.                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {

  1893.                                     enc->frame_size = fifo_bytes / (osize * enc->channels);

  1894.                                 } else { /* pad */

  1895.                                     int frame_bytes = enc->frame_size*osize*enc->channels;

  1896.                                     if (allocated_audio_buf_size < frame_bytes)

  1897.                                         ffmpeg_exit(1);

  1898.                                     generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);

  1899.                                 }

  1900. 

  1901.                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);

  1902.                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,

  1903.                                                           ost->st->time_base.num, enc->sample_rate);

  1904.                                 enc->frame_size = fs_tmp;

  1905.                             }

  1906.                             if(ret <= 0) {

  1907.                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);

  1908.                             }

  1909.                             if (ret < 0) {

  1910.                                 fprintf(stderr, "Audio encoding failed\n");

  1911.                                 ffmpeg_exit(1);

  1912.                             }

  1913.                             audio_size += ret;

  1914.                             pkt.flags |= AV_PKT_FLAG_KEY;

  1915.                             break;

  1916.                         case AVMEDIA_TYPE_VIDEO:

  1917.                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);

  1918.                             if (ret < 0) {

  1919.                                 fprintf(stderr, "Video encoding failed\n");

  1920.                                 ffmpeg_exit(1);

  1921.                             }

  1922.                             video_size += ret;

  1923.                             if(enc->coded_frame && enc->coded_frame->key_frame)

  1924.                                 pkt.flags |= AV_PKT_FLAG_KEY;

  1925.                             if (ost->logfile && enc->stats_out) {

  1926.                                 fprintf(ost->logfile, "%s", enc->stats_out);

  1927.                             }

  1928.                             break;

  1929.                         default:

  1930.                             ret=-1;

  1931.                         }

  1932. 

  1933.                         if(ret<=0)

  1934.                             break;

  1935.                         pkt.data= bit_buffer;

  1936.                         pkt.size= ret;

  1937.                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

  1938.                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

  1939.                         write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);

  1940.                     }

  1941.                 }

  1942.             }

  1943.         }

  1944.     }

  1945. 

  1946.     return 0;

  1947. }

  1948. 

  1949. static void print_sdp(AVFormatContext **avc, int n)

  1950. {

  1951.     char sdp[2048];

  1952. 

  1953.     av_sdp_create(avc, n, sdp, sizeof(sdp));

  1954.     printf("SDP:\n%s\n", sdp);

  1955.     fflush(stdout);

  1956. }

  1957. 

  1958. static int copy_chapters(int infile, int outfile)

  1959. {

  1960.     AVFormatContext *is = input_files[infile].ctx;

  1961.     AVFormatContext *os = output_files[outfile];

  1962.     int i;

  1963. 

  1964.     for (i = 0; i < is->nb_chapters; i++) {

  1965.         AVChapter *in_ch = is->chapters[i], *out_ch;

  1966.         int64_t ts_off   = av_rescale_q(start_time - input_files[infile].ts_offset,

  1967.                                       AV_TIME_BASE_Q, in_ch->time_base);

  1968.         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :

  1969.                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);

  1970. 

  1971. 

  1972.         if (in_ch->end < ts_off)

  1973.             continue;

  1974.         if (rt != INT64_MAX && in_ch->start > rt + ts_off)

  1975.             break;

  1976. 

  1977.         out_ch = av_mallocz(sizeof(AVChapter));

  1978.         if (!out_ch)

  1979.             return AVERROR(ENOMEM);

  1980. 

  1981.         out_ch->id        = in_ch->id;

  1982.         out_ch->time_base = in_ch->time_base;

  1983.         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);

  1984.         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);

  1985. 

  1986.         if (metadata_chapters_autocopy)

  1987.             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);

  1988. 

  1989.         os->nb_chapters++;

  1990.         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);

  1991.         if (!os->chapters)

  1992.             return AVERROR(ENOMEM);

  1993.         os->chapters[os->nb_chapters - 1] = out_ch;

  1994.     }

  1995.     return 0;

  1996. }

  1997. 

  1998. static void parse_forced_key_frames(char *kf, OutputStream *ost,

  1999.                                     AVCodecContext *avctx)

  2000. {

  2001.     char *p;

  2002.     int n = 1, i;

  2003.     int64_t t;

  2004. 

  2005.     for (p = kf; *p; p++)

  2006.         if (*p == ',')

  2007.             n++;

  2008.     ost->forced_kf_count = n;

  2009.     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);

  2010.     if (!ost->forced_kf_pts) {

  2011.         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");

  2012.         ffmpeg_exit(1);

  2013.     }

  2014.     for (i = 0; i < n; i++) {

  2015.         p = i ? strchr(p, ',') + 1 : kf;

  2016.         t = parse_time_or_die("force_key_frames", p, 1);

  2017.         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);

  2018.     }

  2019. }

  2020. 

  2021. /*

  2022.  * The following code is the main loop of the file converter

  2023.  */

  2024. static int transcode(AVFormatContext **output_files,

  2025.                      int nb_output_files,

  2026.                      InputFile *input_files,

  2027.                      int nb_input_files,

  2028.                      StreamMap *stream_maps, int nb_stream_maps)

  2029. {

  2030.     int ret = 0, i, j, k, n, nb_ostreams = 0, step;

  2031. 

  2032.     AVFormatContext *is, *os;

  2033.     AVCodecContext *codec, *icodec;

  2034.     OutputStream *ost, **ost_table = NULL;

  2035.     InputStream *ist;

  2036.     char error[1024];

  2037.     int key;

  2038.     int want_sdp = 1;

  2039.     uint8_t no_packet[MAX_FILES]={0};

  2040.     int no_packet_count=0;

  2041.     int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};

  2042.     int nb_streams[AVMEDIA_TYPE_NB]={0};

  2043. 

  2044.     if (rate_emu)

  2045.         for (i = 0; i < nb_input_streams; i++)

  2046.             input_streams[i].start = av_gettime();

  2047. 

  2048.     /* output stream init */

  2049.     nb_ostreams = 0;

  2050.     for(i=0;i<nb_output_files;i++) {

  2051.         os = output_files[i];

  2052.         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {

  2053.             av_dump_format(output_files[i], i, output_files[i]->filename, 1);

  2054.             fprintf(stderr, "Output file #%d does not contain any stream\n", i);

  2055.             ret = AVERROR(EINVAL);

  2056.             goto fail;

  2057.         }

  2058.         nb_ostreams += os->nb_streams;

  2059.     }

  2060.     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {

  2061.         fprintf(stderr, "Number of stream maps must match number of output streams\n");

  2062.         ret = AVERROR(EINVAL);

  2063.         goto fail;

  2064.     }

  2065. 

  2066.     /* Sanity check the mapping args -- do the input files & streams exist? */

  2067.     for(i=0;i<nb_stream_maps;i++) {

  2068.         int fi = stream_maps[i].file_index;

  2069.         int si = stream_maps[i].stream_index;

  2070. 

  2071.         if (fi < 0 || fi > nb_input_files - 1 ||

  2072.             si < 0 || si > input_files[fi].nb_streams - 1) {

  2073.             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);

  2074.             ret = AVERROR(EINVAL);

  2075.             goto fail;

  2076.         }

  2077.         fi = stream_maps[i].sync_file_index;

  2078.         si = stream_maps[i].sync_stream_index;

  2079.         if (fi < 0 || fi > nb_input_files - 1 ||

  2080.             si < 0 || si > input_files[fi].ctx->nb_streams - 1) {

  2081.             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);

  2082.             ret = AVERROR(EINVAL);

  2083.             goto fail;

  2084.         }

  2085.     }

  2086. 

  2087.     ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);

  2088.     if (!ost_table)

  2089.         goto fail;

  2090. 

  2091.     for(k=0;k<nb_output_files;k++) {

  2092.         os = output_files[k];

  2093.         for(i=0;i<os->nb_streams;i++,n++) {

  2094.             nb_streams[os->streams[i]->codec->codec_type]++;

  2095.         }

  2096.     }

  2097.     for(step=1<<30; step; step>>=1){

  2098.         int found_streams[AVMEDIA_TYPE_NB]={0};

  2099.         for(j=0; j<AVMEDIA_TYPE_NB; j++)

  2100.             nb_frame_threshold[j] += step;

  2101. 

  2102.         for(j=0; j<nb_input_streams; j++) {

  2103.             int skip=0;

  2104.             ist = &input_streams[j];

  2105.             if(opt_programid){

  2106.                 int pi,si;

  2107.                 AVFormatContext *f= input_files[ ist->file_index ].ctx;

  2108.                 skip=1;

  2109.                 for(pi=0; pi<f->nb_programs; pi++){

  2110.                     AVProgram *p= f->programs[pi];

  2111.                     if(p->id == opt_programid)

  2112.                         for(si=0; si<p->nb_stream_indexes; si++){

  2113.                             if(f->streams[ p->stream_index[si] ] == ist->st)

  2114.                                 skip=0;

  2115.                         }

  2116.                 }

  2117.             }

  2118.             if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip

  2119.                 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){

  2120.                 found_streams[ist->st->codec->codec_type]++;

  2121.             }

  2122.         }

  2123.         for(j=0; j<AVMEDIA_TYPE_NB; j++)

  2124.             if(found_streams[j] < nb_streams[j])

  2125.                 nb_frame_threshold[j] -= step;

  2126.     }

  2127.     n = 0;

  2128.     for(k=0;k<nb_output_files;k++) {

  2129.         os = output_files[k];

  2130.         for(i=0;i<os->nb_streams;i++,n++) {

  2131.             int found;

  2132.             ost = ost_table[n] = output_streams_for_file[k][i];

  2133.             if (nb_stream_maps > 0) {

  2134.                 ost->source_index = input_files[stream_maps[n].file_index].ist_index +

  2135.                     stream_maps[n].stream_index;

  2136. 

  2137.                 /* Sanity check that the stream types match */

  2138.                 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {

  2139.                     int i= ost->file_index;

  2140.                     av_dump_format(output_files[i], i, output_files[i]->filename, 1);

  2141.                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",

  2142.                         stream_maps[n].file_index, stream_maps[n].stream_index,

  2143.                         ost->file_index, ost->index);

  2144.                     ffmpeg_exit(1);

  2145.                 }

  2146. 

  2147.             } else {

  2148.                 /* get corresponding input stream index : we select the first one with the right type */

  2149.                 found = 0;

  2150.                 for (j = 0; j < nb_input_streams; j++) {

  2151.                     int skip=0;

  2152.                     ist = &input_streams[j];

  2153.                     if(opt_programid){

  2154.                         int pi,si;

  2155.                         AVFormatContext *f = input_files[ist->file_index].ctx;

  2156.                         skip=1;

  2157.                         for(pi=0; pi<f->nb_programs; pi++){

  2158.                             AVProgram *p= f->programs[pi];

  2159.                             if(p->id == opt_programid)

  2160.                                 for(si=0; si<p->nb_stream_indexes; si++){

  2161.                                     if(f->streams[ p->stream_index[si] ] == ist->st)

  2162.                                         skip=0;

  2163.                                 }

  2164.                         }

  2165.                     }

  2166.                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&

  2167.                         ist->st->codec->codec_type == ost->st->codec->codec_type &&

  2168.                         nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {

  2169.                             ost->source_index = j;

  2170.                             found = 1;

  2171.                             break;

  2172.                     }

  2173.                 }

  2174. 

  2175.                 if (!found) {

  2176.                     if(! opt_programid) {

  2177.                         /* try again and reuse existing stream */

  2178.                         for (j = 0; j < nb_input_streams; j++) {

  2179.                             ist = &input_streams[j];

  2180.                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type

  2181.                                 && ist->st->discard != AVDISCARD_ALL) {

  2182.                                 ost->source_index = j;

  2183.                                 found = 1;

  2184.                             }

  2185.                         }

  2186.                     }

  2187.                     if (!found) {

  2188.                         int i= ost->file_index;

  2189.                         av_dump_format(output_files[i], i, output_files[i]->filename, 1);

  2190.                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",

  2191.                                 ost->file_index, ost->index);

  2192.                         ffmpeg_exit(1);

  2193.                     }

  2194.                 }

  2195.             }

  2196.             ist = &input_streams[ost->source_index];

  2197.             ist->discard = 0;

  2198.             ost->sync_ist = (nb_stream_maps > 0) ?

  2199.                 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +

  2200.                          stream_maps[n].sync_stream_index] : ist;

  2201.         }

  2202.     }

  2203. 

  2204.     /* for each output stream, we compute the right encoding parameters */

  2205.     for(i=0;i<nb_ostreams;i++) {

  2206.         ost = ost_table[i];

  2207.         os = output_files[ost->file_index];

  2208.         ist = &input_streams[ost->source_index];

  2209. 

  2210.         codec = ost->st->codec;

  2211.         icodec = ist->st->codec;

  2212. 

  2213.         if (metadata_streams_autocopy)

  2214.             av_dict_copy(&ost->st->metadata, ist->st->metadata,

  2215.                          AV_DICT_DONT_OVERWRITE);

  2216. 

  2217.         ost->st->disposition = ist->st->disposition;

  2218.         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;

  2219.         codec->chroma_sample_location = icodec->chroma_sample_location;

  2220. 

  2221.         if (ost->st->stream_copy) {

  2222.             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;

  2223. 

  2224.             if (extra_size > INT_MAX)

  2225.                 goto fail;

  2226. 

  2227.             /* if stream_copy is selected, no need to decode or encode */

  2228.             codec->codec_id = icodec->codec_id;

  2229.             codec->codec_type = icodec->codec_type;

  2230. 

  2231.             if(!codec->codec_tag){

  2232.                 if(   !os->oformat->codec_tag

  2233.                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id

  2234.                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)

  2235.                     codec->codec_tag = icodec->codec_tag;

  2236.             }

  2237. 

  2238.             codec->bit_rate = icodec->bit_rate;

  2239.             codec->rc_max_rate    = icodec->rc_max_rate;

  2240.             codec->rc_buffer_size = icodec->rc_buffer_size;

  2241.             codec->extradata= av_mallocz(extra_size);

  2242.             if (!codec->extradata)

  2243.                 goto fail;

  2244.             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);

  2245.             codec->extradata_size= icodec->extradata_size;

  2246. 

  2247.             codec->time_base = ist->st->time_base;

  2248.             if(!strcmp(os->oformat->name, "avi")) {

  2249.                 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){

  2250.                     codec->time_base = icodec->time_base;

  2251.                     codec->time_base.num *= icodec->ticks_per_frame;

  2252.                     codec->time_base.den *= 2;

  2253.                 }

  2254.             } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {

  2255.                 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){

  2256.                     codec->time_base = icodec->time_base;

  2257.                     codec->time_base.num *= icodec->ticks_per_frame;

  2258.                 }

  2259.             }

  2260.             av_reduce(&codec->time_base.num, &codec->time_base.den,

  2261.                         codec->time_base.num, codec->time_base.den, INT_MAX);

  2262. 

  2263.             switch(codec->codec_type) {

  2264.             case AVMEDIA_TYPE_AUDIO:

  2265.                 if(audio_volume != 256) {

  2266.                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");

  2267.                     ffmpeg_exit(1);

  2268.                 }

  2269.                 codec->channel_layout = icodec->channel_layout;

  2270.                 codec->sample_rate = icodec->sample_rate;

  2271.                 codec->channels = icodec->channels;

  2272.                 codec->frame_size = icodec->frame_size;

  2273.                 codec->audio_service_type = icodec->audio_service_type;

  2274.                 codec->block_align= icodec->block_align;

  2275.                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)

  2276.                     codec->block_align= 0;

  2277.                 if(codec->codec_id == CODEC_ID_AC3)

  2278.                     codec->block_align= 0;

  2279.                 break;

  2280.             case AVMEDIA_TYPE_VIDEO:

  2281.                 codec->pix_fmt = icodec->pix_fmt;

  2282.                 codec->width = icodec->width;

  2283.                 codec->height = icodec->height;

  2284.                 codec->has_b_frames = icodec->has_b_frames;

  2285.                 if (!codec->sample_aspect_ratio.num) {

  2286.                     codec->sample_aspect_ratio =

  2287.                     ost->st->sample_aspect_ratio =

  2288.                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :

  2289.                         ist->st->codec->sample_aspect_ratio.num ?

  2290.                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};

  2291.                 }

  2292.                 break;

  2293.             case AVMEDIA_TYPE_SUBTITLE:

  2294.                 codec->width = icodec->width;

  2295.                 codec->height = icodec->height;

  2296.                 break;

  2297.             case AVMEDIA_TYPE_DATA:

  2298.                 break;

  2299.             default:

  2300.                 abort();

  2301.             }

  2302.         } else {

  2303.             if (!ost->enc)

  2304.                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);

  2305.             switch(codec->codec_type) {

  2306.             case AVMEDIA_TYPE_AUDIO:

  2307.                 ost->fifo= av_fifo_alloc(1024);

  2308.                 if(!ost->fifo)

  2309.                     goto fail;

  2310.                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);

  2311.                 if (!codec->sample_rate) {

  2312.                     codec->sample_rate = icodec->sample_rate;

  2313.                 }

  2314.                 choose_sample_rate(ost->st, ost->enc);

  2315.                 codec->time_base = (AVRational){1, codec->sample_rate};

  2316.                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)

  2317.                     codec->sample_fmt = icodec->sample_fmt;

  2318.                 choose_sample_fmt(ost->st, ost->enc);

  2319.                 if (!codec->channels) {

  2320.                     codec->channels = icodec->channels;

  2321.                     codec->channel_layout = icodec->channel_layout;

  2322.                 }

  2323.                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)

  2324.                     codec->channel_layout = 0;

  2325.                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;

  2326.                 icodec->request_channels = codec->channels;

  2327.                 ist->decoding_needed = 1;

  2328.                 ost->encoding_needed = 1;

  2329.                 ost->resample_sample_fmt  = icodec->sample_fmt;

  2330.                 ost->resample_sample_rate = icodec->sample_rate;

  2331.                 ost->resample_channels    = icodec->channels;

  2332.                 break;

  2333.             case AVMEDIA_TYPE_VIDEO:

  2334.                 if (codec->pix_fmt == PIX_FMT_NONE)

  2335.                     codec->pix_fmt = icodec->pix_fmt;

  2336.                 choose_pixel_fmt(ost->st, ost->enc);

  2337. 

  2338.                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {

  2339.                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");

  2340.                     ffmpeg_exit(1);

  2341.                 }

  2342. 

  2343.                 if (!codec->width || !codec->height) {

  2344.                     codec->width  = icodec->width;

  2345.                     codec->height = icodec->height;

  2346.                 }

  2347. 

  2348.                 ost->video_resample = codec->width   != icodec->width  ||

  2349.                                       codec->height  != icodec->height ||

  2350.                                       codec->pix_fmt != icodec->pix_fmt;

  2351.                 if (ost->video_resample) {

  2352.                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;

  2353.                 }

  2354. 

  2355.                 ost->resample_height = icodec->height;

  2356.                 ost->resample_width  = icodec->width;

  2357.                 ost->resample_pix_fmt= icodec->pix_fmt;

  2358.                 ost->encoding_needed = 1;

  2359.                 ist->decoding_needed = 1;

  2360. 

  2361.                 if (!ost->frame_rate.num)

  2362.                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};

  2363.                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {

  2364.                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);

  2365.                     ost->frame_rate = ost->enc->supported_framerates[idx];

  2366.                 }

  2367.                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};

  2368.                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method

  2369.                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){

  2370.                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"

  2371.                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");

  2372.                 }

  2373. 

  2374. #if CONFIG_AVFILTER

  2375.                 if (configure_video_filters(ist, ost)) {

  2376.                     fprintf(stderr, "Error opening filters!\n");

  2377.                     exit(1);

  2378.                 }

  2379. #endif

  2380.                 break;

  2381.             case AVMEDIA_TYPE_SUBTITLE:

  2382.                 ost->encoding_needed = 1;

  2383.                 ist->decoding_needed = 1;

  2384.                 break;

  2385.             default:

  2386.                 abort();

  2387.                 break;

  2388.             }

  2389.             /* two pass mode */

  2390.             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&

  2391.                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {

  2392.                 char logfilename[1024];

  2393.                 FILE *f;

  2394. 

  2395.                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",

  2396.                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,

  2397.                          i);

  2398.                 if (codec->flags & CODEC_FLAG_PASS1) {

  2399.                     f = fopen(logfilename, "wb");

  2400.                     if (!f) {

  2401.                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));

  2402.                         ffmpeg_exit(1);

  2403.                     }

  2404.                     ost->logfile = f;

  2405.                 } else {

  2406.                     char  *logbuffer;

  2407.                     size_t logbuffer_size;

  2408.                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {

  2409.                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);

  2410.                         ffmpeg_exit(1);

  2411.                     }

  2412.                     codec->stats_in = logbuffer;

  2413.                 }

  2414.             }

  2415.         }

  2416.         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){

  2417.             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */

  2418.             int size= codec->width * codec->height;

  2419.             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);

  2420.         }

  2421.     }

  2422. 

  2423.     if (!bit_buffer)

  2424.         bit_buffer = av_malloc(bit_buffer_size);

  2425.     if (!bit_buffer) {

  2426.         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",

  2427.                 bit_buffer_size);

  2428.         ret = AVERROR(ENOMEM);

  2429.         goto fail;

  2430.     }

  2431. 

  2432.     /* open each encoder */

  2433.     for(i=0;i<nb_ostreams;i++) {

  2434.         ost = ost_table[i];

  2435.         if (ost->encoding_needed) {

  2436.             AVCodec *codec = ost->enc;

  2437.             AVCodecContext *dec = input_streams[ost->source_index].st->codec;

  2438.             if (!codec) {

  2439.                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",

  2440.                          ost->st->codec->codec_id, ost->file_index, ost->index);

  2441.                 ret = AVERROR(EINVAL);

  2442.                 goto dump_format;

  2443.             }

  2444.             if (dec->subtitle_header) {

  2445.                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);

  2446.                 if (!ost->st->codec->subtitle_header) {

  2447.                     ret = AVERROR(ENOMEM);

  2448.                     goto dump_format;

  2449.                 }

  2450.                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);

  2451.                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;

  2452.             }

  2453.             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {

  2454.                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",

  2455.                         ost->file_index, ost->index);

  2456.                 ret = AVERROR(EINVAL);

  2457.                 goto dump_format;

  2458.             }

  2459.             assert_codec_experimental(ost->st->codec, 1);

  2460.             assert_avoptions(ost->opts);

  2461.             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)

  2462.                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."

  2463.                                              "It takes bits/s as argument, not kbits/s\n");

  2464.             extra_size += ost->st->codec->extradata_size;

  2465.         }

  2466.     }

  2467. 

  2468.     /* open each decoder */

  2469.     for (i = 0; i < nb_input_streams; i++) {

  2470.         ist = &input_streams[i];

  2471.         if (ist->decoding_needed) {

  2472.             AVCodec *codec = ist->dec;

  2473.             if (!codec)

  2474.                 codec = avcodec_find_decoder(ist->st->codec->codec_id);

  2475.             if (!codec) {

  2476.                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",

  2477.                         ist->st->codec->codec_id, ist->file_index, ist->st->index);

  2478.                 ret = AVERROR(EINVAL);

  2479.                 goto dump_format;

  2480.             }

  2481.             if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {

  2482.                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",

  2483.                         ist->file_index, ist->st->index);

  2484.                 ret = AVERROR(EINVAL);

  2485.                 goto dump_format;

  2486.             }

  2487.             assert_codec_experimental(ist->st->codec, 0);

  2488.             assert_avoptions(ost->opts);

  2489.         }

  2490.     }

  2491. 

  2492.     /* init pts */

  2493.     for (i = 0; i < nb_input_streams; i++) {

  2494.         AVStream *st;

  2495.         ist = &input_streams[i];

  2496.         st= ist->st;

  2497.         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;

  2498.         ist->next_pts = AV_NOPTS_VALUE;

  2499.         ist->is_start = 1;

  2500.     }

  2501. 

  2502.     /* set meta data information from input file if required */

  2503.     for (i=0;i<nb_meta_data_maps;i++) {

  2504.         AVFormatContext *files[2];

  2505.         AVDictionary    **meta[2];

  2506.         int j;

  2507. 

  2508. #define METADATA_CHECK_INDEX(index, nb_elems, desc)\

  2509.         if ((index) < 0 || (index) >= (nb_elems)) {\

  2510.             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\

  2511.                      (desc), (index));\

  2512.             ret = AVERROR(EINVAL);\

  2513.             goto dump_format;\

  2514.         }

  2515. 

  2516.         int out_file_index = meta_data_maps[i][0].file;

  2517.         int in_file_index = meta_data_maps[i][1].file;

  2518.         if (in_file_index < 0 || out_file_index < 0)

  2519.             continue;

  2520.         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")

  2521.         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")

  2522. 

  2523.         files[0] = output_files[out_file_index];

  2524.         files[1] = input_files[in_file_index].ctx;

  2525. 

  2526.         for (j = 0; j < 2; j++) {

  2527.             MetadataMap *map = &meta_data_maps[i][j];

  2528. 

  2529.             switch (map->type) {

  2530.             case 'g':

  2531.                 meta[j] = &files[j]->metadata;

  2532.                 break;

  2533.             case 's':

  2534.                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")

  2535.                 meta[j] = &files[j]->streams[map->index]->metadata;

  2536.                 break;

  2537.             case 'c':

  2538.                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")

  2539.                 meta[j] = &files[j]->chapters[map->index]->metadata;

  2540.                 break;

  2541.             case 'p':

  2542.                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")

  2543.                 meta[j] = &files[j]->programs[map->index]->metadata;

  2544.                 break;

  2545.             }

  2546.         }

  2547. 

  2548.         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);

  2549.     }

  2550. 

  2551.     /* copy global metadata by default */

  2552.     if (metadata_global_autocopy) {

  2553. 

  2554.         for (i = 0; i < nb_output_files; i++)

  2555.             av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,

  2556.                          AV_DICT_DONT_OVERWRITE);

  2557.     }

  2558. 

  2559.     /* copy chapters according to chapter maps */

  2560.     for (i = 0; i < nb_chapter_maps; i++) {

  2561.         int infile  = chapter_maps[i].in_file;

  2562.         int outfile = chapter_maps[i].out_file;

  2563. 

  2564.         if (infile < 0 || outfile < 0)

  2565.             continue;

  2566.         if (infile >= nb_input_files) {

  2567.             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);

  2568.             ret = AVERROR(EINVAL);

  2569.             goto dump_format;

  2570.         }

  2571.         if (outfile >= nb_output_files) {

  2572.             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);

  2573.             ret = AVERROR(EINVAL);

  2574.             goto dump_format;

  2575.         }

  2576.         copy_chapters(infile, outfile);

  2577.     }

  2578. 

  2579.     /* copy chapters from the first input file that has them*/

  2580.     if (!nb_chapter_maps)

  2581.         for (i = 0; i < nb_input_files; i++) {

  2582.             if (!input_files[i].ctx->nb_chapters)

  2583.                 continue;

  2584. 

  2585.             for (j = 0; j < nb_output_files; j++)

  2586.                 if ((ret = copy_chapters(i, j)) < 0)

  2587.                     goto dump_format;

  2588.             break;

  2589.         }

  2590. 

  2591.     /* open files and write file headers */

  2592.     for(i=0;i<nb_output_files;i++) {

  2593.         os = output_files[i];

  2594.         if (avformat_write_header(os, &output_opts[i]) < 0) {

  2595.             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);

  2596.             ret = AVERROR(EINVAL);

  2597.             goto dump_format;

  2598.         }

  2599. //        assert_avoptions(output_opts[i]);

  2600.         if (strcmp(output_files[i]->oformat->name, "rtp")) {

  2601.             want_sdp = 0;

  2602.         }

  2603.     }

  2604. 

  2605.  dump_format:

  2606.     /* dump the file output parameters - cannot be done before in case

  2607.        of stream copy */

  2608.     for(i=0;i<nb_output_files;i++) {

  2609.         av_dump_format(output_files[i], i, output_files[i]->filename, 1);

  2610.     }

  2611. 

  2612.     /* dump the stream mapping */

  2613.     if (verbose >= 0) {

  2614.         fprintf(stderr, "Stream mapping:\n");

  2615.         for(i=0;i<nb_ostreams;i++) {

  2616.             ost = ost_table[i];

  2617.             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",

  2618.                     input_streams[ost->source_index].file_index,

  2619.                     input_streams[ost->source_index].st->index,

  2620.                     ost->file_index,

  2621.                     ost->index);

  2622.             if (ost->sync_ist != &input_streams[ost->source_index])

  2623.                 fprintf(stderr, " [sync #%d.%d]",

  2624.                         ost->sync_ist->file_index,

  2625.                         ost->sync_ist->st->index);

  2626.             if(ost->encoding_needed)

  2627.                 fprintf(stderr, ": %s -> %s",

  2628.                     input_streams[ost->source_index].dec ?

  2629.                         input_streams[ost->source_index].dec->name : "?",

  2630.                     ost->enc ? ost->enc->name : "?");

  2631.             else

  2632.                 fprintf(stderr, ": copy");

  2633.             fprintf(stderr, "\n");

  2634.         }

  2635.     }

  2636. 

  2637.     if (ret) {

  2638.         fprintf(stderr, "%s\n", error);

  2639.         goto fail;

  2640.     }

  2641. 

  2642.     if (want_sdp) {

  2643.         print_sdp(output_files, nb_output_files);

  2644.     }

  2645. 

  2646.     if (!using_stdin) {

  2647.         if(verbose >= 0)

  2648.             fprintf(stderr, "Press [q] to stop, [?] for help\n");

  2649.         avio_set_interrupt_cb(decode_interrupt_cb);

  2650.     }

  2651.     term_init();

  2652. 

  2653.     timer_start = av_gettime();

  2654. 

  2655.     for(; received_sigterm == 0;) {

  2656.         int file_index, ist_index;

  2657.         AVPacket pkt;

  2658.         double ipts_min;

  2659.         double opts_min;

  2660. 

  2661.     redo:

  2662.         ipts_min= 1e100;

  2663.         opts_min= 1e100;

  2664.         /* if 'q' pressed, exits */

  2665.         if (!using_stdin) {

  2666.             if (q_pressed)

  2667.                 break;

  2668.             /* read_key() returns 0 on EOF */

  2669.             key = read_key();

  2670.             if (key == 'q')

  2671.                 break;

  2672.             if (key == '+') verbose++;

  2673.             if (key == '-') verbose--;

  2674.             if (key == 's') qp_hist     ^= 1;

  2675.             if (key == 'h'){

  2676.                 if (do_hex_dump){

  2677.                     do_hex_dump = do_pkt_dump = 0;

  2678.                 } else if(do_pkt_dump){

  2679.                     do_hex_dump = 1;

  2680.                 } else

  2681.                     do_pkt_dump = 1;

  2682.                 av_log_set_level(AV_LOG_DEBUG);

  2683.             }

  2684.             if (key == 'd' || key == 'D'){

  2685.                 int debug=0;

  2686.                 if(key == 'D') {

  2687.                     debug = input_streams[0].st->codec->debug<<1;

  2688.                     if(!debug) debug = 1;

  2689.                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash

  2690.                         debug += debug;

  2691.                 }else

  2692.                     scanf("%d", &debug);

  2693.                 for(i=0;i<nb_input_streams;i++) {

  2694.                     input_streams[i].st->codec->debug = debug;

  2695.                 }

  2696.                 for(i=0;i<nb_ostreams;i++) {

  2697.                     ost = ost_table[i];

  2698.                     ost->st->codec->debug = debug;

  2699.                 }

  2700.                 if(debug) av_log_set_level(AV_LOG_DEBUG);

  2701.                 fprintf(stderr,"debug=%d\n", debug);

  2702.             }

  2703.             if (key == '?'){

  2704.                 fprintf(stderr, "key    function\n"

  2705.                                 "?      show this help\n"

  2706.                                 "+      increase verbosity\n"

  2707.                                 "-      decrease verbosity\n"

  2708.                                 "D      cycle through available debug modes\n"

  2709.                                 "h      dump packets/hex press to cycle through the 3 states\n"

  2710.                                 "q      quit\n"

  2711.                                 "s      Show QP histogram\n"

  2712.                 );

  2713.             }

  2714.         }

  2715. 

  2716.         /* select the stream that we must read now by looking at the

  2717.            smallest output pts */

  2718.         file_index = -1;

  2719.         for(i=0;i<nb_ostreams;i++) {

  2720.             double ipts, opts;

  2721.             ost = ost_table[i];

  2722.             os = output_files[ost->file_index];

  2723.             ist = &input_streams[ost->source_index];

  2724.             if(ist->is_past_recording_time || no_packet[ist->file_index])

  2725.                 continue;

  2726.                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);

  2727.             ipts = (double)ist->pts;

  2728.             if (!input_files[ist->file_index].eof_reached){

  2729.                 if(ipts < ipts_min) {

  2730.                     ipts_min = ipts;

  2731.                     if(input_sync ) file_index = ist->file_index;

  2732.                 }

  2733.                 if(opts < opts_min) {

  2734.                     opts_min = opts;

  2735.                     if(!input_sync) file_index = ist->file_index;

  2736.                 }

  2737.             }

  2738.             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){

  2739.                 file_index= -1;

  2740.                 break;

  2741.             }

  2742.         }

  2743.         /* if none, if is finished */

  2744.         if (file_index < 0) {

  2745.             if(no_packet_count){

  2746.                 no_packet_count=0;

  2747.                 memset(no_packet, 0, sizeof(no_packet));

  2748.                 usleep(10000);

  2749.                 continue;

  2750.             }

  2751.             break;

  2752.         }

  2753. 

  2754.         /* finish if limit size exhausted */

  2755.         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))

  2756.             break;

  2757. 

  2758.         /* read a frame from it and output it in the fifo */

  2759.         is = input_files[file_index].ctx;

  2760.         ret= av_read_frame(is, &pkt);

  2761.         if(ret == AVERROR(EAGAIN)){

  2762.             no_packet[file_index]=1;

  2763.             no_packet_count++;

  2764.             continue;

  2765.         }

  2766.         if (ret < 0) {

  2767.             input_files[file_index].eof_reached = 1;

  2768.             if (opt_shortest)

  2769.                 break;

  2770.             else

  2771.                 continue;

  2772.         }

  2773. 

  2774.         no_packet_count=0;

  2775.         memset(no_packet, 0, sizeof(no_packet));

  2776. 

  2777.         if (do_pkt_dump) {

  2778.             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,

  2779.                              is->streams[pkt.stream_index]);

  2780.         }

  2781.         /* the following test is needed in case new streams appear

  2782.            dynamically in stream : we ignore them */

  2783.         if (pkt.stream_index >= input_files[file_index].nb_streams)

  2784.             goto discard_packet;

  2785.         ist_index = input_files[file_index].ist_index + pkt.stream_index;

  2786.         ist = &input_streams[ist_index];

  2787.         if (ist->discard)

  2788.             goto discard_packet;

  2789. 

  2790.         if (pkt.dts != AV_NOPTS_VALUE)

  2791.             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);

  2792.         if (pkt.pts != AV_NOPTS_VALUE)

  2793.             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);

  2794. 

  2795.         if (ist->ts_scale) {

  2796.             if(pkt.pts != AV_NOPTS_VALUE)

  2797.                 pkt.pts *= ist->ts_scale;

  2798.             if(pkt.dts != AV_NOPTS_VALUE)

  2799.                 pkt.dts *= ist->ts_scale;

  2800.         }

  2801. 

  2802. //        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);

  2803.         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE

  2804.             && (is->iformat->flags & AVFMT_TS_DISCONT)) {

  2805.             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);

  2806.             int64_t delta= pkt_dts - ist->next_pts;

  2807.             if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||

  2808.                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&

  2809.                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||

  2810.                 pkt_dts+1<ist->pts)&& !copy_ts){

  2811.                 input_files[ist->file_index].ts_offset -= delta;

  2812.                 if (verbose > 2)

  2813.                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",

  2814.                             delta, input_files[ist->file_index].ts_offset);

  2815.                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);

  2816.                 if(pkt.pts != AV_NOPTS_VALUE)

  2817.                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);

  2818.             }

  2819.         }

  2820. 

  2821.         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);

  2822.         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {

  2823. 

  2824.             if (verbose >= 0)

  2825.                 fprintf(stderr, "Error while decoding stream #%d.%d\n",

  2826.                         ist->file_index, ist->st->index);

  2827.             if (exit_on_error)

  2828.                 ffmpeg_exit(1);

  2829.             av_free_packet(&pkt);

  2830.             goto redo;

  2831.         }

  2832. 

  2833.     discard_packet:

  2834.         av_free_packet(&pkt);

  2835. 

  2836.         /* dump report by using the output first video and audio streams */

  2837.         print_report(output_files, ost_table, nb_ostreams, 0);

  2838.     }

  2839. 

  2840.     /* at the end of stream, we must flush the decoder buffers */

  2841.     for (i = 0; i < nb_input_streams; i++) {

  2842.         ist = &input_streams[i];

  2843.         if (ist->decoding_needed) {

  2844.             output_packet(ist, i, ost_table, nb_ostreams, NULL);

  2845.         }

  2846.     }

  2847. 

  2848.     term_exit();

  2849. 

  2850.     /* write the trailer if needed and close file */

  2851.     for(i=0;i<nb_output_files;i++) {

  2852.         os = output_files[i];

  2853.         av_write_trailer(os);

  2854.     }

  2855. 

  2856.     /* dump report by using the first video and audio streams */

  2857.     print_report(output_files, ost_table, nb_ostreams, 1);

  2858. 

  2859.     /* close each encoder */

  2860.     for(i=0;i<nb_ostreams;i++) {

  2861.         ost = ost_table[i];

  2862.         if (ost->encoding_needed) {

  2863.             av_freep(&ost->st->codec->stats_in);

  2864.             avcodec_close(ost->st->codec);

  2865.         }

  2866. #if CONFIG_AVFILTER

  2867.         avfilter_graph_free(&ost->graph);

  2868. #endif

  2869.     }

  2870. 

  2871.     /* close each decoder */

  2872.     for (i = 0; i < nb_input_streams; i++) {

  2873.         ist = &input_streams[i];

  2874.         if (ist->decoding_needed) {

  2875.             avcodec_close(ist->st->codec);

  2876.         }

  2877.     }

  2878. 

  2879.     /* finished ! */

  2880.     ret = 0;

  2881. 

  2882.  fail:

  2883.     av_freep(&bit_buffer);

  2884. 

  2885.     if (ost_table) {

  2886.         for(i=0;i<nb_ostreams;i++) {

  2887.             ost = ost_table[i];

  2888.             if (ost) {

  2889.                 if (ost->st->stream_copy)

  2890.                     av_freep(&ost->st->codec->extradata);

  2891.                 if (ost->logfile) {

  2892.                     fclose(ost->logfile);

  2893.                     ost->logfile = NULL;

  2894.                 }

  2895.                 av_fifo_free(ost->fifo); /* works even if fifo is not

  2896.                                              initialized but set to zero */

  2897.                 av_freep(&ost->st->codec->subtitle_header);

  2898.                 av_free(ost->resample_frame.data[0]);

  2899.                 av_free(ost->forced_kf_pts);

  2900.                 if (ost->video_resample)

  2901.                     sws_freeContext(ost->img_resample_ctx);

  2902.                 if (ost->resample)

  2903.                     audio_resample_close(ost->resample);

  2904.                 if (ost->reformat_ctx)

  2905.                     av_audio_convert_free(ost->reformat_ctx);

  2906.                 av_dict_free(&ost->opts);

  2907.                 av_free(ost);

  2908.             }

  2909.         }

  2910.         av_free(ost_table);

  2911.     }

  2912.     return ret;

  2913. }

  2914. 

  2915. static int opt_format(const char *opt, const char *arg)

  2916. {

  2917.     last_asked_format = arg;

  2918.     return 0;

  2919. }

  2920. 

  2921. static int opt_video_rc_override_string(const char *opt, const char *arg)

  2922. {

  2923.     video_rc_override_string = arg;

  2924.     return 0;

  2925. }

  2926. 

  2927. static int opt_me_threshold(const char *opt, const char *arg)

  2928. {

  2929.     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);

  2930.     return 0;

  2931. }

  2932. 

  2933. static int opt_verbose(const char *opt, const char *arg)

  2934. {

  2935.     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);

  2936.     return 0;

  2937. }

  2938. 

  2939. static int opt_frame_rate(const char *opt, const char *arg)

  2940. {

  2941.     if (av_parse_video_rate(&frame_rate, arg) < 0) {

  2942.         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);

  2943.         ffmpeg_exit(1);

  2944.     }

  2945.     return 0;

  2946. }

  2947. 

  2948. static int opt_frame_crop(const char *opt, const char *arg)

  2949. {

  2950.     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);

  2951.     return AVERROR(EINVAL);

  2952. }

  2953. 

  2954. static int opt_frame_size(const char *opt, const char *arg)

  2955. {

  2956.     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {

  2957.         fprintf(stderr, "Incorrect frame size\n");

  2958.         return AVERROR(EINVAL);

  2959.     }

  2960.     return 0;

  2961. }

  2962. 

  2963. static int opt_pad(const char *opt, const char *arg) {

  2964.     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);

  2965.     return -1;

  2966. }

  2967. 

  2968. static int opt_frame_pix_fmt(const char *opt, const char *arg)

  2969. {

  2970.     if (strcmp(arg, "list")) {

  2971.         frame_pix_fmt = av_get_pix_fmt(arg);

  2972.         if (frame_pix_fmt == PIX_FMT_NONE) {

  2973.             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);

  2974.             return AVERROR(EINVAL);

  2975.         }

  2976.     } else {

  2977.         opt_pix_fmts(NULL, NULL);

  2978.         ffmpeg_exit(0);

  2979.     }

  2980.     return 0;

  2981. }

  2982. 

  2983. static int opt_frame_aspect_ratio(const char *opt, const char *arg)

  2984. {

  2985.     int x = 0, y = 0;

  2986.     double ar = 0;

  2987.     const char *p;

  2988.     char *end;

  2989. 

  2990.     p = strchr(arg, ':');

  2991.     if (p) {

  2992.         x = strtol(arg, &end, 10);

  2993.         if (end == p)

  2994.             y = strtol(end+1, &end, 10);

  2995.         if (x > 0 && y > 0)

  2996.             ar = (double)x / (double)y;

  2997.     } else

  2998.         ar = strtod(arg, NULL);

  2999. 

  3000.     if (!ar) {

  3001.         fprintf(stderr, "Incorrect aspect ratio specification.\n");

  3002.         return AVERROR(EINVAL);

  3003.     }

  3004.     frame_aspect_ratio = ar;

  3005.     return 0;

  3006. }

  3007. 

  3008. static int opt_metadata(const char *opt, const char *arg)

  3009. {

  3010.     char *mid= strchr(arg, '=');

  3011. 

  3012.     if(!mid){

  3013.         fprintf(stderr, "Missing =\n");

  3014.         ffmpeg_exit(1);

  3015.     }

  3016.     *mid++= 0;

  3017. 

  3018.     av_dict_set(&metadata, arg, mid, 0);

  3019. 

  3020.     return 0;

  3021. }

  3022. 

  3023. static int opt_qscale(const char *opt, const char *arg)

  3024. {

  3025.     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);

  3026.     if (video_qscale <= 0 || video_qscale > 255) {

  3027.         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");

  3028.         return AVERROR(EINVAL);

  3029.     }

  3030.     return 0;

  3031. }

  3032. 

  3033. static int opt_top_field_first(const char *opt, const char *arg)

  3034. {

  3035.     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);

  3036.     return opt_default(opt, arg);

  3037. }

  3038. 

  3039. static int opt_thread_count(const char *opt, const char *arg)

  3040. {

  3041.     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);

  3042. #if !HAVE_THREADS

  3043.     if (verbose >= 0)

  3044.         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");

  3045. #endif

  3046.     return 0;

  3047. }

  3048. 

  3049. static int opt_audio_sample_fmt(const char *opt, const char *arg)

  3050. {

  3051.     if (strcmp(arg, "list")) {

  3052.         audio_sample_fmt = av_get_sample_fmt(arg);

  3053.         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {

  3054.             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);

  3055.             return AVERROR(EINVAL);

  3056.         }

  3057.     } else {

  3058.         int i;

  3059.         char fmt_str[128];

  3060.         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)

  3061.             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));

  3062.         ffmpeg_exit(0);

  3063.     }

  3064.     return 0;

  3065. }

  3066. 

  3067. static int opt_audio_rate(const char *opt, const char *arg)

  3068. {

  3069.     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);

  3070.     return 0;

  3071. }

  3072. 

  3073. static int opt_audio_channels(const char *opt, const char *arg)

  3074. {

  3075.     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);

  3076.     return 0;

  3077. }

  3078. 

  3079. static int opt_video_channel(const char *opt, const char *arg)

  3080. {

  3081.     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");

  3082.     return opt_default("channel", arg);

  3083. }

  3084. 

  3085. static int opt_video_standard(const char *opt, const char *arg)

  3086. {

  3087.     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");

  3088.     return opt_default("standard", arg);

  3089. }

  3090. 

  3091. static int opt_codec(const char *opt, const char *arg)

  3092. {

  3093.     int *pstream_copy; char **pcodec_name; enum AVMediaType codec_type;

  3094. 

  3095.     if      (!strcmp(opt, "acodec")) { pstream_copy = &audio_stream_copy;    pcodec_name = &audio_codec_name;    codec_type = AVMEDIA_TYPE_AUDIO;    }

  3096.     else if (!strcmp(opt, "vcodec")) { pstream_copy = &video_stream_copy;    pcodec_name = &video_codec_name;    codec_type = AVMEDIA_TYPE_VIDEO;    }

  3097.     else if (!strcmp(opt, "scodec")) { pstream_copy = &subtitle_stream_copy; pcodec_name = &subtitle_codec_name; codec_type = AVMEDIA_TYPE_SUBTITLE; }

  3098.     else if (!strcmp(opt, "dcodec")) { pstream_copy = &data_stream_copy;     pcodec_name = &data_codec_name;     codec_type = AVMEDIA_TYPE_DATA;     }

  3099. 

  3100.     av_freep(pcodec_name);

  3101.     if (!strcmp(arg, "copy")) {

  3102.         *pstream_copy = 1;

  3103.     } else {

  3104.         *pcodec_name = av_strdup(arg);

  3105.     }

  3106.     return 0;

  3107. }

  3108. 

  3109. static int opt_codec_tag(const char *opt, const char *arg)

  3110. {

  3111.     char *tail;

  3112.     uint32_t *codec_tag;

  3113. 

  3114.     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :

  3115.                 !strcmp(opt, "vtag") ? &video_codec_tag :

  3116.                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;

  3117.     if (!codec_tag)

  3118.         return -1;

  3119. 

  3120.     *codec_tag = strtol(arg, &tail, 0);

  3121.     if (!tail || *tail)

  3122.         *codec_tag = AV_RL32(arg);

  3123. 

  3124.     return 0;

  3125. }

  3126. 

  3127. static int opt_map(const char *opt, const char *arg)

  3128. {

  3129.     StreamMap *m;

  3130.     char *p;

  3131. 

  3132.     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);

  3133.     m = &stream_maps[nb_stream_maps-1];

  3134. 

  3135.     m->file_index = strtol(arg, &p, 0);

  3136.     if (*p)

  3137.         p++;

  3138. 

  3139.     m->stream_index = strtol(p, &p, 0);

  3140.     if (*p) {

  3141.         p++;

  3142.         m->sync_file_index = strtol(p, &p, 0);

  3143.         if (*p)

  3144.             p++;

  3145.         m->sync_stream_index = strtol(p, &p, 0);

  3146.     } else {

  3147.         m->sync_file_index = m->file_index;

  3148.         m->sync_stream_index = m->stream_index;

  3149.     }

  3150.     return 0;

  3151. }

  3152. 

  3153. static void parse_meta_type(char *arg, char *type, int *index, char **endptr)

  3154. {

  3155.     *endptr = arg;

  3156.     if (*arg == ',') {

  3157.         *type = *(++arg);

  3158.         switch (*arg) {

  3159.         case 'g':

  3160.             break;

  3161.         case 's':

  3162.         case 'c':

  3163.         case 'p':

  3164.             *index = strtol(++arg, endptr, 0);

  3165.             break;

  3166.         default:

  3167.             fprintf(stderr, "Invalid metadata type %c.\n", *arg);

  3168.             ffmpeg_exit(1);

  3169.         }

  3170.     } else

  3171.         *type = 'g';

  3172. }

  3173. 

  3174. static int opt_map_metadata(const char *opt, const char *arg)

  3175. {

  3176.     MetadataMap *m, *m1;

  3177.     char *p;

  3178. 

  3179.     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),

  3180.                                 &nb_meta_data_maps, nb_meta_data_maps + 1);

  3181. 

  3182.     m = &meta_data_maps[nb_meta_data_maps - 1][0];

  3183.     m->file = strtol(arg, &p, 0);

  3184.     parse_meta_type(p, &m->type, &m->index, &p);

  3185.     if (*p)

  3186.         p++;

  3187. 

  3188.     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];

  3189.     m1->file = strtol(p, &p, 0);

  3190.     parse_meta_type(p, &m1->type, &m1->index, &p);

  3191. 

  3192.     if (m->type == 'g' || m1->type == 'g')

  3193.         metadata_global_autocopy = 0;

  3194.     if (m->type == 's' || m1->type == 's')

  3195.         metadata_streams_autocopy = 0;

  3196.     if (m->type == 'c' || m1->type == 'c')

  3197.         metadata_chapters_autocopy = 0;

  3198. 

  3199.     return 0;

  3200. }

  3201. 

  3202. static int opt_map_meta_data(const char *opt, const char *arg)

  3203. {

  3204.     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "

  3205.                     "Use -map_metadata instead.\n");

  3206.     return opt_map_metadata(opt, arg);

  3207. }

  3208. 

  3209. static int opt_map_chapters(const char *opt, const char *arg)

  3210. {

  3211.     ChapterMap *c;

  3212.     char *p;

  3213. 

  3214.     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,

  3215.                               nb_chapter_maps + 1);

  3216.     c = &chapter_maps[nb_chapter_maps - 1];

  3217.     c->out_file = strtol(arg, &p, 0);

  3218.     if (*p)

  3219.         p++;

  3220. 

  3221.     c->in_file = strtol(p, &p, 0);

  3222.     return 0;

  3223. }

  3224. 

  3225. static int opt_input_ts_scale(const char *opt, const char *arg)

  3226. {

  3227.     unsigned int stream;

  3228.     double scale;

  3229.     char *p;

  3230. 

  3231.     stream = strtol(arg, &p, 0);

  3232.     if (*p)

  3233.         p++;

  3234.     scale= strtod(p, &p);

  3235. 

  3236.     if(stream >= MAX_STREAMS)

  3237.         ffmpeg_exit(1);

  3238. 

  3239.     ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);

  3240.     ts_scale[stream] = scale;

  3241.     return 0;

  3242. }

  3243. 

  3244. static int opt_recording_time(const char *opt, const char *arg)

  3245. {

  3246.     recording_time = parse_time_or_die(opt, arg, 1);

  3247.     return 0;

  3248. }

  3249. 

  3250. static int opt_start_time(const char *opt, const char *arg)

  3251. {

  3252.     start_time = parse_time_or_die(opt, arg, 1);

  3253.     return 0;

  3254. }

  3255. 

  3256. static int opt_recording_timestamp(const char *opt, const char *arg)

  3257. {

  3258.     char buf[128];

  3259.     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;

  3260.     struct tm time = *gmtime((time_t*)&recording_timestamp);

  3261.     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);

  3262.     opt_metadata("metadata", buf);

  3263. 

  3264.     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "

  3265.                                  "tag instead.\n", opt);

  3266.     return 0;

  3267. }

  3268. 

  3269. static int opt_input_ts_offset(const char *opt, const char *arg)

  3270. {

  3271.     input_ts_offset = parse_time_or_die(opt, arg, 1);

  3272.     return 0;

  3273. }

  3274. 

  3275. static enum CodecID find_codec_or_die(const char *name, int type, int encoder)

  3276. {

  3277.     const char *codec_string = encoder ? "encoder" : "decoder";

  3278.     AVCodec *codec;

  3279. 

  3280.     if(!name)

  3281.         return CODEC_ID_NONE;

  3282.     codec = encoder ?

  3283.         avcodec_find_encoder_by_name(name) :

  3284.         avcodec_find_decoder_by_name(name);

  3285.     if(!codec) {

  3286.         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);

  3287.         ffmpeg_exit(1);

  3288.     }

  3289.     if(codec->type != type) {

  3290.         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);

  3291.         ffmpeg_exit(1);

  3292.     }

  3293.     return codec->id;

  3294. }

  3295. 

  3296. static int opt_input_file(const char *opt, const char *filename)

  3297. {

  3298.     AVFormatContext *ic;

  3299.     AVInputFormat *file_iformat = NULL;

  3300.     int err, i, ret, rfps, rfps_base;

  3301.     int64_t timestamp;

  3302.     uint8_t buf[128];

  3303.     AVDictionary **opts;

  3304.     int orig_nb_streams;                     // number of streams before avformat_find_stream_info

  3305. 

  3306.     if (last_asked_format) {

  3307.         if (!(file_iformat = av_find_input_format(last_asked_format))) {

  3308.             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);

  3309.             ffmpeg_exit(1);

  3310.         }

  3311.         last_asked_format = NULL;

  3312.     }

  3313. 

  3314.     if (!strcmp(filename, "-"))

  3315.         filename = "pipe:";

  3316. 

  3317.     using_stdin |= !strncmp(filename, "pipe:", 5) ||

  3318.                     !strcmp(filename, "/dev/stdin");

  3319. 

  3320.     /* get default parameters from command line */

  3321.     ic = avformat_alloc_context();

  3322.     if (!ic) {

  3323.         print_error(filename, AVERROR(ENOMEM));

  3324.         ffmpeg_exit(1);

  3325.     }

  3326.     if (audio_sample_rate) {

  3327.         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);

  3328.         av_dict_set(&format_opts, "sample_rate", buf, 0);

  3329.     }

  3330.     if (audio_channels) {

  3331.         snprintf(buf, sizeof(buf), "%d", audio_channels);

  3332.         av_dict_set(&format_opts, "channels", buf, 0);

  3333.     }

  3334.     if (frame_rate.num) {

  3335.         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);

  3336.         av_dict_set(&format_opts, "framerate", buf, 0);

  3337.     }

  3338.     if (frame_width && frame_height) {

  3339.         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);

  3340.         av_dict_set(&format_opts, "video_size", buf, 0);

  3341.     }

  3342.     if (frame_pix_fmt != PIX_FMT_NONE)

  3343.         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);

  3344. 

  3345.     ic->video_codec_id   =

  3346.         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);

  3347.     ic->audio_codec_id   =

  3348.         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);

  3349.     ic->subtitle_codec_id=

  3350.         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);

  3351.     ic->flags |= AVFMT_FLAG_NONBLOCK;

  3352. 

  3353.     if (loop_input) {

  3354.         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");

  3355.         ic->loop_input = loop_input;

  3356.     }

  3357. 

  3358.     /* open the input file with generic libav function */

  3359.     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);

  3360.     if (err < 0) {

  3361.         print_error(filename, err);

  3362.         ffmpeg_exit(1);

  3363.     }

  3364.     assert_avoptions(format_opts);

  3365. 

  3366.     if(opt_programid) {

  3367.         int i, j;

  3368.         int found=0;

  3369.         for(i=0; i<ic->nb_streams; i++){

  3370.             ic->streams[i]->discard= AVDISCARD_ALL;

  3371.         }

  3372.         for(i=0; i<ic->nb_programs; i++){

  3373.             AVProgram *p= ic->programs[i];

  3374.             if(p->id != opt_programid){

  3375.                 p->discard = AVDISCARD_ALL;

  3376.             }else{

  3377.                 found=1;

  3378.                 for(j=0; j<p->nb_stream_indexes; j++){

  3379.                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;

  3380.                 }

  3381.             }

  3382.         }

  3383.         if(!found){

  3384.             fprintf(stderr, "Specified program id not found\n");

  3385.             ffmpeg_exit(1);

  3386.         }

  3387.         opt_programid=0;

  3388.     }

  3389. 

  3390.     /* Set AVCodecContext options for avformat_find_stream_info */

  3391.     opts = setup_find_stream_info_opts(ic, codec_opts);

  3392.     orig_nb_streams = ic->nb_streams;

  3393. 

  3394.     /* If not enough info to get the stream parameters, we decode the

  3395.        first frames to get it. (used in mpeg case for example) */

  3396.     ret = avformat_find_stream_info(ic, opts);

  3397.     if (ret < 0 && verbose >= 0) {

  3398.         fprintf(stderr, "%s: could not find codec parameters\n", filename);

  3399.         av_close_input_file(ic);

  3400.         ffmpeg_exit(1);

  3401.     }

  3402. 

  3403.     timestamp = start_time;

  3404.     /* add the stream start time */

  3405.     if (ic->start_time != AV_NOPTS_VALUE)

  3406.         timestamp += ic->start_time;

  3407. 

  3408.     /* if seeking requested, we execute it */

  3409.     if (start_time != 0) {

  3410.         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);

  3411.         if (ret < 0) {

  3412.             fprintf(stderr, "%s: could not seek to position %0.3f\n",

  3413.                     filename, (double)timestamp / AV_TIME_BASE);

  3414.         }

  3415.         /* reset seek info */

  3416.         start_time = 0;

  3417.     }

  3418. 

  3419.     /* update the current parameters so that they match the one of the input stream */

  3420.     for(i=0;i<ic->nb_streams;i++) {

  3421.         AVStream *st = ic->streams[i];

  3422.         AVCodecContext *dec = st->codec;

  3423.         InputStream *ist;

  3424. 

  3425.         dec->thread_count = thread_count;

  3426. 

  3427.         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);

  3428.         ist = &input_streams[nb_input_streams - 1];

  3429.         ist->st = st;

  3430.         ist->file_index = nb_input_files;

  3431.         ist->discard = 1;

  3432.         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);

  3433. 

  3434.         if (i < nb_ts_scale)

  3435.             ist->ts_scale = ts_scale[i];

  3436. 

  3437.         switch (dec->codec_type) {

  3438.         case AVMEDIA_TYPE_AUDIO:

  3439.             ist->dec = avcodec_find_decoder_by_name(audio_codec_name);

  3440.             if(!ist->dec)

  3441.                 ist->dec = avcodec_find_decoder(dec->codec_id);

  3442.             if(audio_disable)

  3443.                 st->discard= AVDISCARD_ALL;

  3444.             break;

  3445.         case AVMEDIA_TYPE_VIDEO:

  3446.             ist->dec= avcodec_find_decoder_by_name(video_codec_name);

  3447.             if(!ist->dec)

  3448.                 ist->dec = avcodec_find_decoder(dec->codec_id);

  3449.             rfps      = ic->streams[i]->r_frame_rate.num;

  3450.             rfps_base = ic->streams[i]->r_frame_rate.den;

  3451.             if (dec->lowres) {

  3452.                 dec->flags |= CODEC_FLAG_EMU_EDGE;

  3453.             }

  3454.             if(me_threshold)

  3455.                 dec->debug |= FF_DEBUG_MV;

  3456. 

  3457.             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {

  3458. 

  3459.                 if (verbose >= 0)

  3460.                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",

  3461.                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,

  3462. 

  3463.                     (float)rfps / rfps_base, rfps, rfps_base);

  3464.             }

  3465. 

  3466.             if(video_disable)

  3467.                 st->discard= AVDISCARD_ALL;

  3468.             else if(video_discard)

  3469.                 st->discard= video_discard;

  3470.             break;

  3471.         case AVMEDIA_TYPE_DATA:

  3472.             break;

  3473.         case AVMEDIA_TYPE_SUBTITLE:

  3474.             ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);

  3475.             if(!ist->dec)

  3476.                 ist->dec = avcodec_find_decoder(dec->codec_id);

  3477.             if(subtitle_disable)

  3478.                 st->discard = AVDISCARD_ALL;

  3479.             break;

  3480.         case AVMEDIA_TYPE_ATTACHMENT:

  3481.         case AVMEDIA_TYPE_UNKNOWN:

  3482.             break;

  3483.         default:

  3484.             abort();

  3485.         }

  3486.     }

  3487. 

  3488.     /* dump the file content */

  3489.     if (verbose >= 0)

  3490.         av_dump_format(ic, nb_input_files, filename, 0);

  3491. 

  3492.     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);

  3493.     input_files[nb_input_files - 1].ctx        = ic;

  3494.     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;

  3495.     input_files[nb_input_files - 1].ts_offset  = input_ts_offset - (copy_ts ? 0 : timestamp);

  3496.     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;

  3497. 

  3498.     top_field_first = -1;

  3499.     frame_rate    = (AVRational){0, 0};

  3500.     frame_pix_fmt = PIX_FMT_NONE;

  3501.     frame_height = 0;

  3502.     frame_width  = 0;

  3503.     audio_sample_rate = 0;

  3504.     audio_channels    = 0;

  3505.     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;

  3506.     av_freep(&ts_scale);

  3507.     nb_ts_scale = 0;

  3508. 

  3509.     for (i = 0; i < orig_nb_streams; i++)

  3510.         av_dict_free(&opts[i]);

  3511.     av_freep(&opts);

  3512.     av_freep(&video_codec_name);

  3513.     av_freep(&audio_codec_name);

  3514.     av_freep(&subtitle_codec_name);

  3515.     uninit_opts();

  3516.     init_opts();

  3517.     return 0;

  3518. }

  3519. 

  3520. static void check_inputs(int *has_video_ptr,

  3521.                          int *has_audio_ptr,

  3522.                          int *has_subtitle_ptr,

  3523.                          int *has_data_ptr)

  3524. {

  3525.     int has_video, has_audio, has_subtitle, has_data, i, j;

  3526.     AVFormatContext *ic;

  3527. 

  3528.     has_video = 0;

  3529.     has_audio = 0;

  3530.     has_subtitle = 0;

  3531.     has_data = 0;

  3532. 

  3533.     for(j=0;j<nb_input_files;j++) {

  3534.         ic = input_files[j].ctx;

  3535.         for(i=0;i<ic->nb_streams;i++) {

  3536.             AVCodecContext *enc = ic->streams[i]->codec;

  3537.             switch(enc->codec_type) {

  3538.             case AVMEDIA_TYPE_AUDIO:

  3539.                 has_audio = 1;

  3540.                 break;

  3541.             case AVMEDIA_TYPE_VIDEO:

  3542.                 has_video = 1;

  3543.                 break;

  3544.             case AVMEDIA_TYPE_SUBTITLE:

  3545.                 has_subtitle = 1;

  3546.                 break;

  3547.             case AVMEDIA_TYPE_DATA:

  3548.             case AVMEDIA_TYPE_ATTACHMENT:

  3549.             case AVMEDIA_TYPE_UNKNOWN:

  3550.                 has_data = 1;

  3551.                 break;

  3552.             default:

  3553.                 abort();

  3554.             }

  3555.         }

  3556.     }

  3557.     *has_video_ptr = has_video;

  3558.     *has_audio_ptr = has_audio;

  3559.     *has_subtitle_ptr = has_subtitle;

  3560.     *has_data_ptr = has_data;

  3561. }

  3562. 

  3563. static void new_video_stream(AVFormatContext *oc, int file_idx)

  3564. {

  3565.     AVStream *st;

  3566.     OutputStream *ost;

  3567.     AVCodecContext *video_enc;

  3568.     enum CodecID codec_id = CODEC_ID_NONE;

  3569.     AVCodec *codec= NULL;

  3570. 

  3571.     if(!video_stream_copy){

  3572.         if (video_codec_name) {

  3573.             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);

  3574.             codec = avcodec_find_encoder_by_name(video_codec_name);

  3575.         } else {

  3576.             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);

  3577.             codec = avcodec_find_encoder(codec_id);

  3578.         }

  3579.     }

  3580. 

  3581.     ost = new_output_stream(oc, file_idx, codec);

  3582.     st  = ost->st;

  3583.     if (!video_stream_copy) {

  3584.         ost->frame_aspect_ratio = frame_aspect_ratio;

  3585.         frame_aspect_ratio = 0;

  3586. #if CONFIG_AVFILTER

  3587.         ost->avfilter = vfilters;

  3588.         vfilters = NULL;

  3589. #endif

  3590.     }

  3591. 

  3592.     ost->bitstream_filters = video_bitstream_filters;

  3593.     video_bitstream_filters= NULL;

  3594. 

  3595.     st->codec->thread_count= thread_count;

  3596. 

  3597.     video_enc = st->codec;

  3598. 

  3599.     if(video_codec_tag)

  3600.         video_enc->codec_tag= video_codec_tag;

  3601. 

  3602.     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {

  3603.         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;

  3604.     }

  3605. 

  3606.     video_enc->codec_type = AVMEDIA_TYPE_VIDEO;

  3607.     if (video_stream_copy) {

  3608.         st->stream_copy = 1;

  3609.         video_enc->sample_aspect_ratio =

  3610.         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);

  3611.     } else {

  3612.         const char *p;

  3613.         int i;

  3614. 

  3615.         if (frame_rate.num)

  3616.             ost->frame_rate = frame_rate;

  3617.         video_enc->codec_id = codec_id;

  3618. 

  3619.         video_enc->width = frame_width;

  3620.         video_enc->height = frame_height;

  3621.         video_enc->pix_fmt = frame_pix_fmt;

  3622.         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;

  3623.         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;

  3624. 

  3625.         if (intra_only)

  3626.             video_enc->gop_size = 0;

  3627.         if (video_qscale || same_quality) {

  3628.             video_enc->flags |= CODEC_FLAG_QSCALE;

  3629.             video_enc->global_quality = FF_QP2LAMBDA * video_qscale;

  3630.         }

  3631. 

  3632.         if(intra_matrix)

  3633.             video_enc->intra_matrix = intra_matrix;

  3634.         if(inter_matrix)

  3635.             video_enc->inter_matrix = inter_matrix;

  3636. 

  3637.         p= video_rc_override_string;

  3638.         for(i=0; p; i++){

  3639.             int start, end, q;

  3640.             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);

  3641.             if(e!=3){

  3642.                 fprintf(stderr, "error parsing rc_override\n");

  3643.                 ffmpeg_exit(1);

  3644.             }

  3645.             video_enc->rc_override=

  3646.                 av_realloc(video_enc->rc_override,

  3647.                            sizeof(RcOverride)*(i+1));

  3648.             video_enc->rc_override[i].start_frame= start;

  3649.             video_enc->rc_override[i].end_frame  = end;

  3650.             if(q>0){

  3651.                 video_enc->rc_override[i].qscale= q;

  3652.                 video_enc->rc_override[i].quality_factor= 1.0;

  3653.             }

  3654.             else{

  3655.                 video_enc->rc_override[i].qscale= 0;

  3656.                 video_enc->rc_override[i].quality_factor= -q/100.0;

  3657.             }

  3658.             p= strchr(p, '/');

  3659.             if(p) p++;

  3660.         }

  3661.         video_enc->rc_override_count=i;

  3662.         if (!video_enc->rc_initial_buffer_occupancy)

  3663.             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;

  3664.         video_enc->me_threshold= me_threshold;

  3665.         video_enc->intra_dc_precision= intra_dc_precision - 8;

  3666. 

  3667.         if (do_psnr)

  3668.             video_enc->flags|= CODEC_FLAG_PSNR;

  3669. 

  3670.         /* two pass mode */

  3671.         if (do_pass) {

  3672.             if (do_pass == 1) {

  3673.                 video_enc->flags |= CODEC_FLAG_PASS1;

  3674.             } else {

  3675.                 video_enc->flags |= CODEC_FLAG_PASS2;

  3676.             }

  3677.         }

  3678. 

  3679.         if (forced_key_frames)

  3680.             parse_forced_key_frames(forced_key_frames, ost, video_enc);

  3681.     }

  3682.     if (video_language) {

  3683.         av_dict_set(&st->metadata, "language", video_language, 0);

  3684.         av_freep(&video_language);

  3685.     }

  3686. 

  3687.     /* reset some key parameters */

  3688.     video_disable = 0;

  3689.     av_freep(&video_codec_name);

  3690.     av_freep(&forced_key_frames);

  3691.     video_stream_copy = 0;

  3692.     frame_pix_fmt = PIX_FMT_NONE;

  3693. }

  3694. 

  3695. static void new_audio_stream(AVFormatContext *oc, int file_idx)

  3696. {

  3697.     AVStream *st;

  3698.     OutputStream *ost;

  3699.     AVCodec *codec= NULL;

  3700.     AVCodecContext *audio_enc;

  3701.     enum CodecID codec_id = CODEC_ID_NONE;

  3702. 

  3703.     if(!audio_stream_copy){

  3704.         if (audio_codec_name) {

  3705.             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);

  3706.             codec = avcodec_find_encoder_by_name(audio_codec_name);

  3707.         } else {

  3708.             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);

  3709.             codec = avcodec_find_encoder(codec_id);

  3710.         }

  3711.     }

  3712.     ost = new_output_stream(oc, file_idx, codec);

  3713.     st  = ost->st;

  3714. 

  3715.     ost->bitstream_filters = audio_bitstream_filters;

  3716.     audio_bitstream_filters= NULL;

  3717. 

  3718.     st->codec->thread_count= thread_count;

  3719. 

  3720.     audio_enc = st->codec;

  3721.     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;

  3722. 

  3723.     if(audio_codec_tag)

  3724.         audio_enc->codec_tag= audio_codec_tag;

  3725. 

  3726.     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {

  3727.         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;

  3728.     }

  3729.     if (audio_stream_copy) {

  3730.         st->stream_copy = 1;

  3731.     } else {

  3732.         audio_enc->codec_id = codec_id;

  3733. 

  3734.         if (audio_qscale > QSCALE_NONE) {

  3735.             audio_enc->flags |= CODEC_FLAG_QSCALE;

  3736.             audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;

  3737.         }

  3738.         if (audio_channels)

  3739.             audio_enc->channels = audio_channels;

  3740.         if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)

  3741.             audio_enc->sample_fmt = audio_sample_fmt;

  3742.         if (audio_sample_rate)

  3743.             audio_enc->sample_rate = audio_sample_rate;

  3744.     }

  3745.     if (audio_language) {

  3746.         av_dict_set(&st->metadata, "language", audio_language, 0);

  3747.         av_freep(&audio_language);

  3748.     }

  3749. 

  3750.     /* reset some key parameters */

  3751.     audio_disable = 0;

  3752.     av_freep(&audio_codec_name);

  3753.     audio_stream_copy = 0;

  3754. }

  3755. 

  3756. static void new_data_stream(AVFormatContext *oc, int file_idx)

  3757. {

  3758.     AVStream *st;

  3759.     OutputStream *ost;

  3760.     AVCodecContext *data_enc;

  3761. 

  3762.     ost = new_output_stream(oc, file_idx, NULL);

  3763.     st  = ost->st;

  3764.     data_enc = st->codec;

  3765.     if (!data_stream_copy) {

  3766.         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");

  3767.         ffmpeg_exit(1);

  3768.     }

  3769. 

  3770.     data_enc->codec_type = AVMEDIA_TYPE_DATA;

  3771. 

  3772.     if (data_codec_tag)

  3773.         data_enc->codec_tag= data_codec_tag;

  3774. 

  3775.     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {

  3776.         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;

  3777.     }

  3778.     if (data_stream_copy) {

  3779.         st->stream_copy = 1;

  3780.     }

  3781. 

  3782.     data_disable = 0;

  3783.     av_freep(&data_codec_name);

  3784.     data_stream_copy = 0;

  3785. }

  3786. 

  3787. static void new_subtitle_stream(AVFormatContext *oc, int file_idx)

  3788. {

  3789.     AVStream *st;

  3790.     OutputStream *ost;

  3791.     AVCodec *codec=NULL;

  3792.     AVCodecContext *subtitle_enc;

  3793.     enum CodecID codec_id = CODEC_ID_NONE;

  3794. 

  3795.     if(!subtitle_stream_copy){

  3796.         if (subtitle_codec_name) {

  3797.             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);

  3798.             codec = avcodec_find_encoder_by_name(subtitle_codec_name);

  3799.         } else {

  3800.             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);

  3801.             codec = avcodec_find_encoder(codec_id);

  3802.         }

  3803.     }

  3804.     ost = new_output_stream(oc, file_idx, codec);

  3805.     st  = ost->st;

  3806.     subtitle_enc = st->codec;

  3807. 

  3808.     ost->bitstream_filters = subtitle_bitstream_filters;

  3809.     subtitle_bitstream_filters= NULL;

  3810. 

  3811.     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;

  3812. 

  3813.     if(subtitle_codec_tag)

  3814.         subtitle_enc->codec_tag= subtitle_codec_tag;

  3815. 

  3816.     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {

  3817.         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;

  3818.     }

  3819.     if (subtitle_stream_copy) {

  3820.         st->stream_copy = 1;

  3821.     } else {

  3822.         subtitle_enc->codec_id = codec_id;

  3823.     }

  3824. 

  3825.     if (subtitle_language) {

  3826.         av_dict_set(&st->metadata, "language", subtitle_language, 0);

  3827.         av_freep(&subtitle_language);

  3828.     }

  3829. 

  3830.     subtitle_disable = 0;

  3831.     av_freep(&subtitle_codec_name);

  3832.     subtitle_stream_copy = 0;

  3833. }

  3834. 

  3835. static int opt_new_stream(const char *opt, const char *arg)

  3836. {

  3837.     AVFormatContext *oc;

  3838.     int file_idx = nb_output_files - 1;

  3839.     if (nb_output_files <= 0) {

  3840.         fprintf(stderr, "At least one output file must be specified\n");

  3841.         ffmpeg_exit(1);

  3842.     }

  3843.     oc = output_files[file_idx];

  3844. 

  3845.     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);

  3846.     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);

  3847.     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);

  3848.     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);

  3849.     else av_assert0(0);

  3850.     return 0;

  3851. }

  3852. 

  3853. /* arg format is "output-stream-index:streamid-value". */

  3854. static int opt_streamid(const char *opt, const char *arg)

  3855. {

  3856.     int idx;

  3857.     char *p;

  3858.     char idx_str[16];

  3859. 

  3860.     av_strlcpy(idx_str, arg, sizeof(idx_str));

  3861.     p = strchr(idx_str, ':');

  3862.     if (!p) {

  3863.         fprintf(stderr,

  3864.                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",

  3865.                 arg, opt);

  3866.         ffmpeg_exit(1);

  3867.     }

  3868.     *p++ = '\0';

  3869.     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);

  3870.     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);

  3871.     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);

  3872.     return 0;

  3873. }

  3874. 

  3875. static int opt_output_file(const char *opt, const char *filename)

  3876. {

  3877.     AVFormatContext *oc;

  3878.     int err, use_video, use_audio, use_subtitle, use_data;

  3879.     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;

  3880.     AVOutputFormat *file_oformat;

  3881. 

  3882.     if(nb_output_files >= FF_ARRAY_ELEMS(output_files)){

  3883.         fprintf(stderr, "Too many output files\n");

  3884.         ffmpeg_exit(1);

  3885.     }

  3886. 

  3887.     if (!strcmp(filename, "-"))

  3888.         filename = "pipe:";

  3889. 

  3890.     err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);

  3891.     last_asked_format = NULL;

  3892.     if (!oc) {

  3893.         print_error(filename, err);

  3894.         ffmpeg_exit(1);

  3895.     }

  3896.     file_oformat= oc->oformat;

  3897. 

  3898.     if (!strcmp(file_oformat->name, "ffm") &&

  3899.         av_strstart(filename, "http:", NULL)) {

  3900.         /* special case for files sent to ffserver: we get the stream

  3901.            parameters from ffserver */

  3902.         int err = read_ffserver_streams(oc, filename);

  3903.         if (err < 0) {

  3904.             print_error(filename, err);

  3905.             ffmpeg_exit(1);

  3906.         }

  3907.     } else {

  3908.         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;

  3909.         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;

  3910.         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;

  3911.         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 */

  3912. 

  3913.         /* disable if no corresponding type found */

  3914.         check_inputs(&input_has_video,

  3915.                      &input_has_audio,

  3916.                      &input_has_subtitle,

  3917.                      &input_has_data);

  3918. 

  3919.         if (!input_has_video)

  3920.             use_video = 0;

  3921.         if (!input_has_audio)

  3922.             use_audio = 0;

  3923.         if (!input_has_subtitle)

  3924.             use_subtitle = 0;

  3925.         if (!input_has_data)

  3926.             use_data = 0;

  3927. 

  3928.         /* manual disable */

  3929.         if (audio_disable)    use_audio    = 0;

  3930.         if (video_disable)    use_video    = 0;

  3931.         if (subtitle_disable) use_subtitle = 0;

  3932.         if (data_disable)     use_data     = 0;

  3933. 

  3934.         if (use_video)    new_video_stream(oc, nb_output_files);

  3935.         if (use_audio)    new_audio_stream(oc, nb_output_files);

  3936.         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);

  3937.         if (use_data)     new_data_stream(oc, nb_output_files);

  3938. 

  3939.         av_dict_copy(&oc->metadata, metadata, 0);

  3940.         av_dict_free(&metadata);

  3941.     }

  3942. 

  3943.     av_dict_copy(&output_opts[nb_output_files], format_opts, 0);

  3944.     output_files[nb_output_files++] = oc;

  3945. 

  3946.     /* check filename in case of an image number is expected */

  3947.     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {

  3948.         if (!av_filename_number_test(oc->filename)) {

  3949.             print_error(oc->filename, AVERROR(EINVAL));

  3950.             ffmpeg_exit(1);

  3951.         }

  3952.     }

  3953. 

  3954.     if (!(oc->oformat->flags & AVFMT_NOFILE)) {

  3955.         /* test if it already exists to avoid loosing precious files */

  3956.         if (!file_overwrite &&

  3957.             (strchr(filename, ':') == NULL ||

  3958.              filename[1] == ':' ||

  3959.              av_strstart(filename, "file:", NULL))) {

  3960.             if (avio_check(filename, 0) == 0) {

  3961.                 if (!using_stdin) {

  3962.                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);

  3963.                     fflush(stderr);

  3964.                     if (!read_yesno()) {

  3965.                         fprintf(stderr, "Not overwriting - exiting\n");

  3966.                         ffmpeg_exit(1);

  3967.                     }

  3968.                 }

  3969.                 else {

  3970.                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);

  3971.                     ffmpeg_exit(1);

  3972.                 }

  3973.             }

  3974.         }

  3975. 

  3976.         /* open the file */

  3977.         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {

  3978.             print_error(filename, err);

  3979.             ffmpeg_exit(1);

  3980.         }

  3981.     }

  3982. 

  3983.     oc->preload= (int)(mux_preload*AV_TIME_BASE);

  3984.     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);

  3985. 

  3986.     if (loop_output >= 0) {

  3987.         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");

  3988.         oc->loop_output = loop_output;

  3989.     }

  3990. 

  3991.     frame_rate    = (AVRational){0, 0};

  3992.     frame_width   = 0;

  3993.     frame_height  = 0;

  3994.     audio_sample_rate = 0;

  3995.     audio_channels    = 0;

  3996.     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;

  3997. 

  3998.     av_freep(&forced_key_frames);

  3999.     uninit_opts();

  4000.     init_opts();

  4001.     return 0;

  4002. }

  4003. 

  4004. /* same option as mencoder */

  4005. static int opt_pass(const char *opt, const char *arg)

  4006. {

  4007.     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);

  4008.     return 0;

  4009. }

  4010. 

  4011. static int64_t getutime(void)

  4012. {

  4013. #if HAVE_GETRUSAGE

  4014.     struct rusage rusage;

  4015. 

  4016.     getrusage(RUSAGE_SELF, &rusage);

  4017.     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;

  4018. #elif HAVE_GETPROCESSTIMES

  4019.     HANDLE proc;

  4020.     FILETIME c, e, k, u;

  4021.     proc = GetCurrentProcess();

  4022.     GetProcessTimes(proc, &c, &e, &k, &u);

  4023.     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;

  4024. #else

  4025.     return av_gettime();

  4026. #endif

  4027. }

  4028. 

  4029. static int64_t getmaxrss(void)

  4030. {

  4031. #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS

  4032.     struct rusage rusage;

  4033.     getrusage(RUSAGE_SELF, &rusage);

  4034.     return (int64_t)rusage.ru_maxrss * 1024;

  4035. #elif HAVE_GETPROCESSMEMORYINFO

  4036.     HANDLE proc;

  4037.     PROCESS_MEMORY_COUNTERS memcounters;

  4038.     proc = GetCurrentProcess();

  4039.     memcounters.cb = sizeof(memcounters);

  4040.     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));

  4041.     return memcounters.PeakPagefileUsage;

  4042. #else

  4043.     return 0;

  4044. #endif

  4045. }

  4046. 

  4047. static void parse_matrix_coeffs(uint16_t *dest, const char *str)

  4048. {

  4049.     int i;

  4050.     const char *p = str;

  4051.     for(i = 0;; i++) {

  4052.         dest[i] = atoi(p);

  4053.         if(i == 63)

  4054.             break;

  4055.         p = strchr(p, ',');

  4056.         if(!p) {

  4057.             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);

  4058.             ffmpeg_exit(1);

  4059.         }

  4060.         p++;

  4061.     }

  4062. }

  4063. 

  4064. static int opt_inter_matrix(const char *opt, const char *arg)

  4065. {

  4066.     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);

  4067.     parse_matrix_coeffs(inter_matrix, arg);

  4068.     return 0;

  4069. }

  4070. 

  4071. static int opt_intra_matrix(const char *opt, const char *arg)

  4072. {

  4073.     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);

  4074.     parse_matrix_coeffs(intra_matrix, arg);

  4075.     return 0;

  4076. }

  4077. 

  4078. static void show_usage(void)

  4079. {

  4080.     printf("Hyper fast Audio and Video encoder\n");

  4081.     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");

  4082.     printf("\n");

  4083. }

  4084. 

  4085. static int opt_help(const char *opt, const char *arg)

  4086. {

  4087.     AVCodec *c;

  4088.     AVOutputFormat *oformat = NULL;

  4089.     AVInputFormat  *iformat = NULL;

  4090. 

  4091.     av_log_set_callback(log_callback_help);

  4092.     show_usage();

  4093.     show_help_options(options, "Main options:\n",

  4094.                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);

  4095.     show_help_options(options, "\nAdvanced options:\n",

  4096.                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,

  4097.                       OPT_EXPERT);

  4098.     show_help_options(options, "\nVideo options:\n",

  4099.                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,

  4100.                       OPT_VIDEO);

  4101.     show_help_options(options, "\nAdvanced Video options:\n",

  4102.                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,

  4103.                       OPT_VIDEO | OPT_EXPERT);

  4104.     show_help_options(options, "\nAudio options:\n",

  4105.                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,

  4106.                       OPT_AUDIO);

  4107.     show_help_options(options, "\nAdvanced Audio options:\n",

  4108.                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,

  4109.                       OPT_AUDIO | OPT_EXPERT);

  4110.     show_help_options(options, "\nSubtitle options:\n",

  4111.                       OPT_SUBTITLE | OPT_GRAB,

  4112.                       OPT_SUBTITLE);

  4113.     show_help_options(options, "\nAudio/Video grab options:\n",

  4114.                       OPT_GRAB,

  4115.                       OPT_GRAB);

  4116.     printf("\n");

  4117.     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

  4118.     printf("\n");

  4119. 

  4120.     /* individual codec options */

  4121.     c = NULL;

  4122.     while ((c = av_codec_next(c))) {

  4123.         if (c->priv_class) {

  4124.             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

  4125.             printf("\n");

  4126.         }

  4127.     }

  4128. 

  4129.     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

  4130.     printf("\n");

  4131. 

  4132.     /* individual muxer options */

  4133.     while ((oformat = av_oformat_next(oformat))) {

  4134.         if (oformat->priv_class) {

  4135.             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);

  4136.             printf("\n");

  4137.         }

  4138.     }

  4139. 

  4140.     /* individual demuxer options */

  4141.     while ((iformat = av_iformat_next(iformat))) {

  4142.         if (iformat->priv_class) {

  4143.             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);

  4144.             printf("\n");

  4145.         }

  4146.     }

  4147. 

  4148.     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);

  4149.     return 0;

  4150. }

  4151. 

  4152. static int opt_target(const char *opt, const char *arg)

  4153. {

  4154.     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;

  4155.     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};

  4156. 

  4157.     if(!strncmp(arg, "pal-", 4)) {

  4158.         norm = PAL;

  4159.         arg += 4;

  4160.     } else if(!strncmp(arg, "ntsc-", 5)) {

  4161.         norm = NTSC;

  4162.         arg += 5;

  4163.     } else if(!strncmp(arg, "film-", 5)) {

  4164.         norm = FILM;

  4165.         arg += 5;

  4166.     } else {

  4167.         int fr;

  4168.         /* Calculate FR via float to avoid int overflow */

  4169.         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);

  4170.         if(fr == 25000) {

  4171.             norm = PAL;

  4172.         } else if((fr == 29970) || (fr == 23976)) {

  4173.             norm = NTSC;

  4174.         } else {

  4175.             /* Try to determine PAL/NTSC by peeking in the input files */

  4176.             if(nb_input_files) {

  4177.                 int i, j;

  4178.                 for (j = 0; j < nb_input_files; j++) {

  4179.                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {

  4180.                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;

  4181.                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)

  4182.                             continue;

  4183.                         fr = c->time_base.den * 1000 / c->time_base.num;

  4184.                         if(fr == 25000) {

  4185.                             norm = PAL;

  4186.                             break;

  4187.                         } else if((fr == 29970) || (fr == 23976)) {

  4188.                             norm = NTSC;

  4189.                             break;

  4190.                         }

  4191.                     }

  4192.                     if(norm != UNKNOWN)

  4193.                         break;

  4194.                 }

  4195.             }

  4196.         }

  4197.         if(verbose > 0 && norm != UNKNOWN)

  4198.             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");

  4199.     }

  4200. 

  4201.     if(norm == UNKNOWN) {

  4202.         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");

  4203.         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");

  4204.         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");

  4205.         ffmpeg_exit(1);

  4206.     }

  4207. 

  4208.     if(!strcmp(arg, "vcd")) {

  4209.         opt_codec("vcodec", "mpeg1video");

  4210.         opt_codec("acodec", "mp2");

  4211.         opt_format("f", "vcd");

  4212. 

  4213.         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");

  4214.         opt_frame_rate("r", frame_rates[norm]);

  4215.         opt_default("g", norm == PAL ? "15" : "18");

  4216. 

  4217.         opt_default("b", "1150000");

  4218.         opt_default("maxrate", "1150000");

  4219.         opt_default("minrate", "1150000");

  4220.         opt_default("bufsize", "327680"); // 40*1024*8;

  4221. 

  4222.         opt_default("ab", "224000");

  4223.         audio_sample_rate = 44100;

  4224.         audio_channels = 2;

  4225. 

  4226.         opt_default("packetsize", "2324");

  4227.         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;

  4228. 

  4229.         /* We have to offset the PTS, so that it is consistent with the SCR.

  4230.            SCR starts at 36000, but the first two packs contain only padding

  4231.            and the first pack from the other stream, respectively, may also have

  4232.            been written before.

  4233.            So the real data starts at SCR 36000+3*1200. */

  4234.         mux_preload= (36000+3*1200) / 90000.0; //0.44

  4235.     } else if(!strcmp(arg, "svcd")) {

  4236. 

  4237.         opt_codec("vcodec", "mpeg2video");

  4238.         opt_codec("acodec", "mp2");

  4239.         opt_format("f", "svcd");

  4240. 

  4241.         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");

  4242.         opt_frame_rate("r", frame_rates[norm]);

  4243.         opt_frame_pix_fmt("pix_fmt", "yuv420p");

  4244.         opt_default("g", norm == PAL ? "15" : "18");

  4245. 

  4246.         opt_default("b", "2040000");

  4247.         opt_default("maxrate", "2516000");

  4248.         opt_default("minrate", "0"); //1145000;

  4249.         opt_default("bufsize", "1835008"); //224*1024*8;

  4250.         opt_default("flags", "+scan_offset");

  4251. 

  4252. 

  4253.         opt_default("ab", "224000");

  4254.         audio_sample_rate = 44100;

  4255. 

  4256.         opt_default("packetsize", "2324");

  4257. 

  4258.     } else if(!strcmp(arg, "dvd")) {

  4259. 

  4260.         opt_codec("vcodec", "mpeg2video");

  4261.         opt_codec("acodec", "ac3");

  4262.         opt_format("f", "dvd");

  4263. 

  4264.         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");

  4265.         opt_frame_rate("r", frame_rates[norm]);

  4266.         opt_frame_pix_fmt("pix_fmt", "yuv420p");

  4267.         opt_default("g", norm == PAL ? "15" : "18");

  4268. 

  4269.         opt_default("b", "6000000");

  4270.         opt_default("maxrate", "9000000");

  4271.         opt_default("minrate", "0"); //1500000;

  4272.         opt_default("bufsize", "1835008"); //224*1024*8;

  4273. 

  4274.         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.

  4275.         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8

  4276. 

  4277.         opt_default("ab", "448000");

  4278.         audio_sample_rate = 48000;

  4279. 

  4280.     } else if(!strncmp(arg, "dv", 2)) {

  4281. 

  4282.         opt_format("f", "dv");

  4283. 

  4284.         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");

  4285.         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :

  4286.                           norm == PAL ? "yuv420p" : "yuv411p");

  4287.         opt_frame_rate("r", frame_rates[norm]);

  4288. 

  4289.         audio_sample_rate = 48000;

  4290.         audio_channels = 2;

  4291. 

  4292.     } else {

  4293.         fprintf(stderr, "Unknown target: %s\n", arg);

  4294.         return AVERROR(EINVAL);

  4295.     }

  4296.     return 0;

  4297. }

  4298. 

  4299. static int opt_vstats_file(const char *opt, const char *arg)

  4300. {

  4301.     av_free (vstats_filename);

  4302.     vstats_filename=av_strdup (arg);

  4303.     return 0;

  4304. }

  4305. 

  4306. static int opt_vstats(const char *opt, const char *arg)

  4307. {

  4308.     char filename[40];

  4309.     time_t today2 = time(NULL);

  4310.     struct tm *today = localtime(&today2);

  4311. 

  4312.     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,

  4313.              today->tm_sec);

  4314.     return opt_vstats_file(opt, filename);

  4315. }

  4316. 

  4317. static int opt_bsf(const char *opt, const char *arg)

  4318. {

  4319.     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='

  4320.     AVBitStreamFilterContext **bsfp;

  4321. 

  4322.     if(!bsfc){

  4323.         fprintf(stderr, "Unknown bitstream filter %s\n", arg);

  4324.         ffmpeg_exit(1);

  4325.     }

  4326. 

  4327.     bsfp= *opt == 'v' ? &video_bitstream_filters :

  4328.           *opt == 'a' ? &audio_bitstream_filters :

  4329.                         &subtitle_bitstream_filters;

  4330.     while(*bsfp)

  4331.         bsfp= &(*bsfp)->next;

  4332. 

  4333.     *bsfp= bsfc;

  4334. 

  4335.     return 0;

  4336. }

  4337. 

  4338. static int opt_preset(const char *opt, const char *arg)

  4339. {

  4340.     FILE *f=NULL;

  4341.     char filename[1000], tmp[1000], tmp2[1000], line[1000];

  4342.     char *codec_name = *opt == 'v' ? video_codec_name :

  4343.                        *opt == 'a' ? audio_codec_name :

  4344.                                      subtitle_codec_name;

  4345. 

  4346.     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {

  4347.         fprintf(stderr, "File for preset '%s' not found\n", arg);

  4348.         ffmpeg_exit(1);

  4349.     }

  4350. 

  4351.     while(!feof(f)){

  4352.         int e= fscanf(f, "%999[^\n]\n", line) - 1;

  4353.         if(line[0] == '#' && !e)

  4354.             continue;

  4355.         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;

  4356.         if(e){

  4357.             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);

  4358.             ffmpeg_exit(1);

  4359.         }

  4360.         if (!strcmp(tmp, "acodec") ||

  4361.             !strcmp(tmp, "vcodec") ||

  4362.             !strcmp(tmp, "scodec") ||

  4363.             !strcmp(tmp, "dcodec")) {

  4364.             opt_codec(tmp, tmp2);

  4365.         }else if(opt_default(tmp, tmp2) < 0){

  4366.             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);

  4367.             ffmpeg_exit(1);

  4368.         }

  4369.     }

  4370. 

  4371.     fclose(f);

  4372. 

  4373.     return 0;

  4374. }

  4375. 

  4376. static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)

  4377. {

  4378. }

  4379. 

  4380. static int opt_passlogfile(const char *opt, const char *arg)

  4381. {

  4382.     pass_logfilename_prefix = arg;

  4383. #if CONFIG_LIBX264_ENCODER

  4384.     return opt_default("passlogfile", arg);

  4385. #else

  4386.     return 0;

  4387. #endif

  4388. }

  4389. 

  4390. static const OptionDef options[] = {

  4391.     /* main options */

  4392. #include "cmdutils_common_opts.h"

  4393.     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },

  4394.     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },

  4395.     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },

  4396.     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },

  4397.     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",

  4398.       "outfile[,metadata]:infile[,metadata]" },

  4399.     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",

  4400.       "outfile[,metadata]:infile[,metadata]" },

  4401.     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },

  4402.     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },

  4403.     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //

  4404.     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },

  4405.     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },

  4406.     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },

  4407.     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },

  4408.     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },

  4409.     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },

  4410.     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},

  4411.       "add timings for benchmarking" },

  4412.     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },

  4413.     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},

  4414.       "dump each input packet" },

  4415.     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},

  4416.       "when dumping packets, also dump the payload" },

  4417.     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },

  4418.     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },

  4419.     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },

  4420.     { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },

  4421.     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },

  4422.     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },

  4423.     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },

  4424.     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },

  4425.     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },

  4426.     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },

  4427.     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },

  4428.     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //

  4429.     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },

  4430.     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },

  4431.     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },

  4432.     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },

  4433. 

  4434.     /* video options */

  4435.     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },

  4436.     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },

  4437.     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },

  4438.     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },

  4439.     { "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" },

  4440.     { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },

  4441.     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

  4442.     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

  4443.     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

  4444.     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },

  4445.     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

  4446.     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

  4447.     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

  4448.     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },

  4449.     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },

  4450.     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},

  4451.     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },

  4452.     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },

  4453.     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },

  4454.     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },

  4455.     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_codec}, "force video codec ('copy' to copy stream)", "codec" },

  4456.     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },

  4457.     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, "use same quantizer as source (implies VBR)" },

  4458.     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, "use same quantizer as source (implies VBR)" },

  4459.     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },

  4460.     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },

  4461.     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},

  4462.       "deinterlace pictures" },

  4463.     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },

  4464.     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },

  4465.     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },

  4466. #if CONFIG_AVFILTER

  4467.     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },

  4468. #endif

  4469.     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },

  4470.     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },

  4471.     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },

  4472.     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },

  4473.     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },

  4474.     { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },

  4475.     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },

  4476.     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },

  4477.     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },

  4478.     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },

  4479.     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },

  4480. 

  4481.     /* audio options */

  4482.     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },

  4483.     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },

  4484.     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },

  4485.     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },

  4486.     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },

  4487.     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_codec}, "force audio codec ('copy' to copy stream)", "codec" },

  4488.     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },

  4489.     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //

  4490.     { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },

  4491.     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },

  4492.     { "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" },

  4493. 

  4494.     /* subtitle options */

  4495.     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },

  4496.     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },

  4497.     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },

  4498.     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },

  4499.     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },

  4500. 

  4501.     /* grab options */

  4502.     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },

  4503.     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },

  4504.     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },

  4505. 

  4506.     /* muxer options */

  4507.     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },

  4508.     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },

  4509. 

  4510.     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },

  4511.     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },

  4512.     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },

  4513. 

  4514.     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },

  4515.     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },

  4516.     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },

  4517.     { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },

  4518.     /* data codec support */

  4519.     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_codec}, "force data codec ('copy' to copy stream)", "codec" },

  4520. 

  4521.     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },

  4522.     { NULL, },

  4523. };

  4524. 

  4525. int main(int argc, char **argv)

  4526. {

  4527.     int64_t ti;

  4528. 

  4529.     av_log_set_flags(AV_LOG_SKIP_REPEATED);

  4530. 

  4531.     if(argc>1 && !strcmp(argv[1], "-d")){

  4532.         run_as_daemon=1;

  4533.         verbose=-1;

  4534.         av_log_set_callback(log_callback_null);

  4535.         argc--;

  4536.         argv++;

  4537.     }

  4538. 

  4539.     avcodec_register_all();

  4540. #if CONFIG_AVDEVICE

  4541.     avdevice_register_all();

  4542. #endif

  4543. #if CONFIG_AVFILTER

  4544.     avfilter_register_all();

  4545. #endif

  4546.     av_register_all();

  4547. 

  4548. #if HAVE_ISATTY

  4549.     if(isatty(STDIN_FILENO))

  4550.         avio_set_interrupt_cb(decode_interrupt_cb);

  4551. #endif

  4552. 

  4553.     init_opts();

  4554. 

  4555.     if(verbose>=0)

  4556.         show_banner();

  4557. 

  4558.     /* parse options */

  4559.     parse_options(argc, argv, options, opt_output_file);

  4560. 

  4561.     if(nb_output_files <= 0 && nb_input_files == 0) {

  4562.         show_usage();

  4563.         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");

  4564.         ffmpeg_exit(1);

  4565.     }

  4566. 

  4567.     /* file converter / grab */

  4568.     if (nb_output_files <= 0) {

  4569.         fprintf(stderr, "At least one output file must be specified\n");

  4570.         ffmpeg_exit(1);

  4571.     }

  4572. 

  4573.     if (nb_input_files == 0) {

  4574.         fprintf(stderr, "At least one input file must be specified\n");

  4575.         ffmpeg_exit(1);

  4576.     }

  4577. 

  4578.     ti = getutime();

  4579.     if (transcode(output_files, nb_output_files, input_files, nb_input_files,

  4580.                   stream_maps, nb_stream_maps) < 0)

  4581.         ffmpeg_exit(1);

  4582.     ti = getutime() - ti;

  4583.     if (do_benchmark) {

  4584.         int maxrss = getmaxrss() / 1024;

  4585.         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);

  4586.     }

  4587. 

  4588.     return ffmpeg_exit(0);

  4589. }