use strict_std_complience from avcodec_opts[AVMEDIA_TYPE_*]
[ffmpeg.git] / ffmpeg.c
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 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
24
25 #include "config.h"
26 #include <ctype.h>
27 #include <string.h>
28 #include <math.h>
29 #include <stdlib.h>
30 #include <errno.h>
31 #include <signal.h>
32 #include <limits.h>
33 #include <unistd.h>
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavcore/parseutils.h"
40 #include "libavutil/colorspace.h"
41 #include "libavutil/fifo.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/libm.h"
45 #include "libavformat/os_support.h"
46
47 #if CONFIG_AVFILTER
48 # include "libavfilter/avfilter.h"
49 # include "libavfilter/avfiltergraph.h"
50 # include "libavfilter/graphparser.h"
51 # include "libavfilter/vsrc_buffer.h"
52 #endif
53
54 #if HAVE_SYS_RESOURCE_H
55 #include <sys/types.h>
56 #include <sys/time.h>
57 #include <sys/resource.h>
58 #elif HAVE_GETPROCESSTIMES
59 #include <windows.h>
60 #endif
61 #if HAVE_GETPROCESSMEMORYINFO
62 #include <windows.h>
63 #include <psapi.h>
64 #endif
65
66 #if HAVE_SYS_SELECT_H
67 #include <sys/select.h>
68 #endif
69
70 #if HAVE_TERMIOS_H
71 #include <fcntl.h>
72 #include <sys/ioctl.h>
73 #include <sys/time.h>
74 #include <termios.h>
75 #elif HAVE_CONIO_H
76 #include <conio.h>
77 #endif
78 #include <time.h>
79
80 #include "cmdutils.h"
81
82 #undef NDEBUG
83 #include <assert.h>
84
85 const char program_name[] = "FFmpeg";
86 const int program_birth_year = 2000;
87
88 /* select an input stream for an output stream */
89 typedef struct AVStreamMap {
90     int file_index;
91     int stream_index;
92     int sync_file_index;
93     int sync_stream_index;
94 } AVStreamMap;
95
96 /**
97  * select an input file for an output file
98  */
99 typedef struct AVMetaDataMap {
100     int out_file;
101     int in_file;
102 } AVMetaDataMap;
103
104 static const OptionDef options[];
105
106 #define MAX_FILES 100
107
108 static const char *last_asked_format = NULL;
109 static AVFormatContext *input_files[MAX_FILES];
110 static int64_t input_files_ts_offset[MAX_FILES];
111 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
112 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
113 static int nb_input_files = 0;
114 static int nb_icodecs;
115
116 static AVFormatContext *output_files[MAX_FILES];
117 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
118 static int nb_output_files = 0;
119 static int nb_ocodecs;
120
121 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
122 static int nb_stream_maps;
123
124 static AVMetaDataMap meta_data_maps[MAX_FILES];
125 static int nb_meta_data_maps;
126
127 /* indexed by output file stream index */
128 static int streamid_map[MAX_STREAMS];
129
130 static int frame_width  = 0;
131 static int frame_height = 0;
132 static float frame_aspect_ratio = 0;
133 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
134 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
135 static int frame_topBand  = 0;
136 static int frame_bottomBand = 0;
137 static int frame_leftBand  = 0;
138 static int frame_rightBand = 0;
139 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
140 static AVRational frame_rate;
141 static float video_qscale = 0;
142 static uint16_t *intra_matrix = NULL;
143 static uint16_t *inter_matrix = NULL;
144 static const char *video_rc_override_string=NULL;
145 static int video_disable = 0;
146 static int video_discard = 0;
147 static char *video_codec_name = NULL;
148 static unsigned int video_codec_tag = 0;
149 static char *video_language = NULL;
150 static int same_quality = 0;
151 static int do_deinterlace = 0;
152 static int top_field_first = -1;
153 static int me_threshold = 0;
154 static int intra_dc_precision = 8;
155 static int loop_input = 0;
156 static int loop_output = AVFMT_NOOUTPUTLOOP;
157 static int qp_hist = 0;
158 #if CONFIG_AVFILTER
159 static char *vfilters = NULL;
160 AVFilterGraph *graph = NULL;
161 #endif
162
163 static int intra_only = 0;
164 static int audio_sample_rate = 44100;
165 static int64_t channel_layout = 0;
166 #define QSCALE_NONE -99999
167 static float audio_qscale = QSCALE_NONE;
168 static int audio_disable = 0;
169 static int audio_channels = 1;
170 static char  *audio_codec_name = NULL;
171 static unsigned int audio_codec_tag = 0;
172 static char *audio_language = NULL;
173
174 static int subtitle_disable = 0;
175 static char *subtitle_codec_name = NULL;
176 static char *subtitle_language = NULL;
177 static unsigned int subtitle_codec_tag = 0;
178
179 static float mux_preload= 0.5;
180 static float mux_max_delay= 0.7;
181
182 static int64_t recording_time = INT64_MAX;
183 static int64_t start_time = 0;
184 static int64_t recording_timestamp = 0;
185 static int64_t input_ts_offset = 0;
186 static int file_overwrite = 0;
187 static int metadata_count;
188 static AVMetadataTag *metadata;
189 static int do_benchmark = 0;
190 static int do_hex_dump = 0;
191 static int do_pkt_dump = 0;
192 static int do_psnr = 0;
193 static int do_pass = 0;
194 static char *pass_logfilename_prefix = NULL;
195 static int audio_stream_copy = 0;
196 static int video_stream_copy = 0;
197 static int subtitle_stream_copy = 0;
198 static int video_sync_method= -1;
199 static int audio_sync_method= 0;
200 static float audio_drift_threshold= 0.1;
201 static int copy_ts= 0;
202 static int opt_shortest = 0;
203 static int video_global_header = 0;
204 static char *vstats_filename;
205 static FILE *vstats_file;
206 static int opt_programid = 0;
207 static int copy_initial_nonkeyframes = 0;
208
209 static int rate_emu = 0;
210
211 static int  video_channel = 0;
212 static char *video_standard;
213
214 static int audio_volume = 256;
215
216 static int exit_on_error = 0;
217 static int using_stdin = 0;
218 static int verbose = 1;
219 static int thread_count= 1;
220 static int q_pressed = 0;
221 static int64_t video_size = 0;
222 static int64_t audio_size = 0;
223 static int64_t extra_size = 0;
224 static int nb_frames_dup = 0;
225 static int nb_frames_drop = 0;
226 static int input_sync;
227 static uint64_t limit_filesize = 0;
228 static int force_fps = 0;
229
230 static int pgmyuv_compatibility_hack=0;
231 static float dts_delta_threshold = 10;
232
233 static unsigned int sws_flags = SWS_BICUBIC;
234
235 static int64_t timer_start;
236
237 static uint8_t *audio_buf;
238 static uint8_t *audio_out;
239 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
240
241 static short *samples;
242
243 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
244 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
245 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
246 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
247
248 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
249
250 struct AVInputStream;
251
252 typedef struct AVOutputStream {
253     int file_index;          /* file index */
254     int index;               /* stream index in the output file */
255     int source_index;        /* AVInputStream index */
256     AVStream *st;            /* stream in the output file */
257     int encoding_needed;     /* true if encoding needed for this stream */
258     int frame_number;
259     /* input pts and corresponding output pts
260        for A/V sync */
261     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
262     struct AVInputStream *sync_ist; /* input stream to sync against */
263     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
264     /* video only */
265     int video_resample;
266     AVFrame pict_tmp;      /* temporary image for resampling */
267     struct SwsContext *img_resample_ctx; /* for image resampling */
268     int resample_height;
269     int resample_width;
270     int resample_pix_fmt;
271
272     /* full frame size of first frame */
273     int original_height;
274     int original_width;
275
276     /* cropping area sizes */
277     int video_crop;
278     int topBand;
279     int bottomBand;
280     int leftBand;
281     int rightBand;
282
283     /* cropping area of first frame */
284     int original_topBand;
285     int original_bottomBand;
286     int original_leftBand;
287     int original_rightBand;
288
289     /* audio only */
290     int audio_resample;
291     ReSampleContext *resample; /* for audio resampling */
292     int reformat_pair;
293     AVAudioConvert *reformat_ctx;
294     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
295     FILE *logfile;
296 } AVOutputStream;
297
298 typedef struct AVInputStream {
299     int file_index;
300     int index;
301     AVStream *st;
302     int discard;             /* true if stream data should be discarded */
303     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
304     int64_t sample_index;      /* current sample */
305
306     int64_t       start;     /* time when read started */
307     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
308                                 is not defined */
309     int64_t       pts;       /* current pts */
310     int is_start;            /* is 1 at the start and after a discontinuity */
311     int showed_multi_packet_warning;
312     int is_past_recording_time;
313 #if CONFIG_AVFILTER
314     AVFilterContext *output_video_filter;
315     AVFilterContext *input_video_filter;
316     AVFrame *filter_frame;
317     int has_filter_frame;
318     AVFilterBufferRef *picref;
319 #endif
320 } AVInputStream;
321
322 typedef struct AVInputFile {
323     int eof_reached;      /* true if eof reached */
324     int ist_index;        /* index of first stream in ist_table */
325     int buffer_size;      /* current total buffer size */
326     int nb_streams;       /* nb streams we are aware of */
327 } AVInputFile;
328
329 #if HAVE_TERMIOS_H
330
331 /* init terminal so that we can grab keys */
332 static struct termios oldtty;
333 #endif
334
335 #if CONFIG_AVFILTER
336 typedef struct {
337     int pix_fmt;
338 } FilterOutPriv;
339
340
341 static int output_init(AVFilterContext *ctx, const char *args, void *opaque)
342 {
343     FilterOutPriv *priv = ctx->priv;
344
345     if(!opaque) return -1;
346
347     priv->pix_fmt = *((int *)opaque);
348
349     return 0;
350 }
351
352 static void output_end_frame(AVFilterLink *link)
353 {
354 }
355
356 static int output_query_formats(AVFilterContext *ctx)
357 {
358     FilterOutPriv *priv = ctx->priv;
359     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
360
361     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
362     return 0;
363 }
364
365 static int get_filtered_video_pic(AVFilterContext *ctx,
366                                   AVFilterBufferRef **picref, AVFrame *pic2,
367                                   uint64_t *pts)
368 {
369     AVFilterBufferRef *pic;
370
371     if(avfilter_request_frame(ctx->inputs[0]))
372         return -1;
373     if(!(pic = ctx->inputs[0]->cur_buf))
374         return -1;
375     *picref = pic;
376     ctx->inputs[0]->cur_buf = NULL;
377
378     *pts          = pic->pts;
379
380     memcpy(pic2->data,     pic->data,     sizeof(pic->data));
381     memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
382     pic2->interlaced_frame = pic->video->interlaced;
383     pic2->top_field_first  = pic->video->top_field_first;
384
385     return 1;
386 }
387
388 static AVFilter output_filter =
389 {
390     .name      = "ffmpeg_output",
391
392     .priv_size = sizeof(FilterOutPriv),
393     .init      = output_init,
394
395     .query_formats = output_query_formats,
396
397     .inputs    = (AVFilterPad[]) {{ .name          = "default",
398                                     .type          = AVMEDIA_TYPE_VIDEO,
399                                     .end_frame     = output_end_frame,
400                                     .min_perms     = AV_PERM_READ, },
401                                   { .name = NULL }},
402     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
403 };
404
405 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
406 {
407     AVFilterContext *last_filter, *filter;
408     /** filter graph containing all filters including input & output */
409     AVCodecContext *codec = ost->st->codec;
410     AVCodecContext *icodec = ist->st->codec;
411     char args[255];
412     int ret;
413
414     graph = av_mallocz(sizeof(AVFilterGraph));
415
416     if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
417         return ret;
418     if ((ret = avfilter_open(&ist->output_video_filter, &output_filter, "out")) < 0)
419         return ret;
420
421     snprintf(args, 255, "%d:%d:%d", ist->st->codec->width,
422              ist->st->codec->height, ist->st->codec->pix_fmt);
423     if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
424         return ret;
425     if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &codec->pix_fmt)) < 0)
426         return ret;
427
428     /* add input and output filters to the overall graph */
429     avfilter_graph_add_filter(graph, ist->input_video_filter);
430     avfilter_graph_add_filter(graph, ist->output_video_filter);
431
432     last_filter = ist->input_video_filter;
433
434     if (ost->video_crop) {
435         snprintf(args, 255, "%d:%d:%d:%d",
436                  codec->width, codec->height,
437                  ost->leftBand, ost->topBand);
438         if ((ret = avfilter_open(&filter, avfilter_get_by_name("crop"), NULL)) < 0)
439             return ret;
440         if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
441             return ret;
442         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
443             return ret;
444         last_filter = filter;
445         avfilter_graph_add_filter(graph, last_filter);
446     }
447
448     if((codec->width !=
449         icodec->width - (frame_leftBand + frame_rightBand)) ||
450        (codec->height != icodec->height - (frame_topBand  + frame_bottomBand))) {
451         snprintf(args, 255, "%d:%d:flags=0x%X",
452                  codec->width,
453                  codec->height,
454                  (int)av_get_int(sws_opts, "sws_flags", NULL));
455         if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
456             return ret;
457         if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
458             return ret;
459         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
460             return ret;
461         last_filter = filter;
462         avfilter_graph_add_filter(graph, last_filter);
463     }
464
465     snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
466     graph->scale_sws_opts = av_strdup(args);
467
468     if (vfilters) {
469         AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
470         AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
471
472         outputs->name    = av_strdup("in");
473         outputs->filter  = last_filter;
474         outputs->pad_idx = 0;
475         outputs->next    = NULL;
476
477         inputs->name    = av_strdup("out");
478         inputs->filter  = ist->output_video_filter;
479         inputs->pad_idx = 0;
480         inputs->next    = NULL;
481
482         if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
483             return ret;
484         av_freep(&vfilters);
485     } else {
486         if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
487             return ret;
488     }
489
490     /* configure all the filter links */
491     if ((ret = avfilter_graph_check_validity(graph, NULL)) < 0)
492         return ret;
493     if ((ret = avfilter_graph_config_formats(graph, NULL)) < 0)
494         return ret;
495     if ((ret = avfilter_graph_config_links(graph, NULL)) < 0)
496         return ret;
497
498     codec->width  = ist->output_video_filter->inputs[0]->w;
499     codec->height = ist->output_video_filter->inputs[0]->h;
500
501     return 0;
502 }
503 #endif /* CONFIG_AVFILTER */
504
505 static void term_exit(void)
506 {
507     av_log(NULL, AV_LOG_QUIET, "");
508 #if HAVE_TERMIOS_H
509     tcsetattr (0, TCSANOW, &oldtty);
510 #endif
511 }
512
513 static volatile int received_sigterm = 0;
514
515 static void
516 sigterm_handler(int sig)
517 {
518     received_sigterm = sig;
519     term_exit();
520 }
521
522 static void term_init(void)
523 {
524 #if HAVE_TERMIOS_H
525     struct termios tty;
526
527     tcgetattr (0, &tty);
528     oldtty = tty;
529     atexit(term_exit);
530
531     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
532                           |INLCR|IGNCR|ICRNL|IXON);
533     tty.c_oflag |= OPOST;
534     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
535     tty.c_cflag &= ~(CSIZE|PARENB);
536     tty.c_cflag |= CS8;
537     tty.c_cc[VMIN] = 1;
538     tty.c_cc[VTIME] = 0;
539
540     tcsetattr (0, TCSANOW, &tty);
541     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
542 #endif
543
544     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
545     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
546 #ifdef SIGXCPU
547     signal(SIGXCPU, sigterm_handler);
548 #endif
549 }
550
551 /* read a key without blocking */
552 static int read_key(void)
553 {
554 #if HAVE_TERMIOS_H
555     int n = 1;
556     unsigned char ch;
557     struct timeval tv;
558     fd_set rfds;
559
560     FD_ZERO(&rfds);
561     FD_SET(0, &rfds);
562     tv.tv_sec = 0;
563     tv.tv_usec = 0;
564     n = select(1, &rfds, NULL, NULL, &tv);
565     if (n > 0) {
566         n = read(0, &ch, 1);
567         if (n == 1)
568             return ch;
569
570         return n;
571     }
572 #elif HAVE_CONIO_H
573     if(kbhit())
574         return(getch());
575 #endif
576     return -1;
577 }
578
579 static int decode_interrupt_cb(void)
580 {
581     return q_pressed || (q_pressed = read_key() == 'q');
582 }
583
584 static int ffmpeg_exit(int ret)
585 {
586     int i;
587
588     /* close files */
589     for(i=0;i<nb_output_files;i++) {
590         /* maybe av_close_output_file ??? */
591         AVFormatContext *s = output_files[i];
592         int j;
593         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
594             url_fclose(s->pb);
595         for(j=0;j<s->nb_streams;j++) {
596             av_metadata_free(&s->streams[j]->metadata);
597             av_free(s->streams[j]->codec);
598             av_free(s->streams[j]);
599         }
600         for(j=0;j<s->nb_programs;j++) {
601             av_metadata_free(&s->programs[j]->metadata);
602         }
603         for(j=0;j<s->nb_chapters;j++) {
604             av_metadata_free(&s->chapters[j]->metadata);
605         }
606         av_metadata_free(&s->metadata);
607         av_free(s);
608     }
609     for(i=0;i<nb_input_files;i++)
610         av_close_input_file(input_files[i]);
611
612     av_free(intra_matrix);
613     av_free(inter_matrix);
614
615     if (vstats_file)
616         fclose(vstats_file);
617     av_free(vstats_filename);
618
619     av_free(opt_names);
620
621     av_free(video_codec_name);
622     av_free(audio_codec_name);
623     av_free(subtitle_codec_name);
624
625     av_free(video_standard);
626
627     for (i=0;i<AVMEDIA_TYPE_NB;i++)
628         av_free(avcodec_opts[i]);
629     av_free(avformat_opts);
630     av_free(sws_opts);
631     av_free(audio_buf);
632     av_free(audio_out);
633     allocated_audio_buf_size= allocated_audio_out_size= 0;
634     av_free(samples);
635
636 #if CONFIG_AVFILTER
637     avfilter_uninit();
638 #endif
639
640     if (received_sigterm) {
641         fprintf(stderr,
642             "Received signal %d: terminating.\n",
643             (int) received_sigterm);
644         exit (255);
645     }
646
647     exit(ret); /* not all OS-es handle main() return value */
648     return ret;
649 }
650
651 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
652 {
653     if(codec && codec->sample_fmts){
654         const enum SampleFormat *p= codec->sample_fmts;
655         for(; *p!=-1; p++){
656             if(*p == st->codec->sample_fmt)
657                 break;
658         }
659         if(*p == -1)
660             st->codec->sample_fmt = codec->sample_fmts[0];
661     }
662 }
663
664 static void choose_sample_rate(AVStream *st, AVCodec *codec)
665 {
666     if(codec && codec->supported_samplerates){
667         const int *p= codec->supported_samplerates;
668         int best=0;
669         int best_dist=INT_MAX;
670         for(; *p; p++){
671             int dist= abs(st->codec->sample_rate - *p);
672             if(dist < best_dist){
673                 best_dist= dist;
674                 best= *p;
675             }
676         }
677         if(best_dist){
678             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
679         }
680         st->codec->sample_rate= best;
681     }
682 }
683
684 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
685 {
686     if(codec && codec->pix_fmts){
687         const enum PixelFormat *p= codec->pix_fmts;
688         for(; *p!=-1; p++){
689             if(*p == st->codec->pix_fmt)
690                 break;
691         }
692         if(*p == -1
693            && !(   st->codec->codec_id==CODEC_ID_MJPEG
694                 && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
695                 && (   st->codec->pix_fmt == PIX_FMT_YUV420P
696                     || st->codec->pix_fmt == PIX_FMT_YUV422P)))
697             st->codec->pix_fmt = codec->pix_fmts[0];
698     }
699 }
700
701 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
702 {
703     int i, err;
704     AVFormatContext *ic;
705     int nopts = 0;
706
707     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
708     if (err < 0)
709         return err;
710     /* copy stream format */
711     s->nb_streams = ic->nb_streams;
712     for(i=0;i<ic->nb_streams;i++) {
713         AVStream *st;
714         AVCodec *codec;
715
716         // FIXME: a more elegant solution is needed
717         st = av_mallocz(sizeof(AVStream));
718         memcpy(st, ic->streams[i], sizeof(AVStream));
719         st->codec = avcodec_alloc_context();
720         if (!st->codec) {
721             print_error(filename, AVERROR(ENOMEM));
722             ffmpeg_exit(1);
723         }
724         avcodec_copy_context(st->codec, ic->streams[i]->codec);
725         s->streams[i] = st;
726
727         codec = avcodec_find_encoder(st->codec->codec_id);
728         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
729             if (audio_stream_copy) {
730                 st->stream_copy = 1;
731             } else
732                 choose_sample_fmt(st, codec);
733         } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
734             if (video_stream_copy) {
735                 st->stream_copy = 1;
736             } else
737                 choose_pixel_fmt(st, codec);
738         }
739
740         if(!st->codec->thread_count)
741             st->codec->thread_count = 1;
742         if(st->codec->thread_count>1)
743             avcodec_thread_init(st->codec, st->codec->thread_count);
744
745         if(st->codec->flags & CODEC_FLAG_BITEXACT)
746             nopts = 1;
747     }
748
749     if (!nopts)
750         s->timestamp = av_gettime();
751
752     av_close_input_file(ic);
753     return 0;
754 }
755
756 static double
757 get_sync_ipts(const AVOutputStream *ost)
758 {
759     const AVInputStream *ist = ost->sync_ist;
760     return (double)(ist->pts - start_time)/AV_TIME_BASE;
761 }
762
763 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
764     int ret;
765
766     while(bsfc){
767         AVPacket new_pkt= *pkt;
768         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
769                                           &new_pkt.data, &new_pkt.size,
770                                           pkt->data, pkt->size,
771                                           pkt->flags & AV_PKT_FLAG_KEY);
772         if(a>0){
773             av_free_packet(pkt);
774             new_pkt.destruct= av_destruct_packet;
775         } else if(a<0){
776             fprintf(stderr, "%s failed for stream %d, codec %s",
777                     bsfc->filter->name, pkt->stream_index,
778                     avctx->codec ? avctx->codec->name : "copy");
779             print_error("", a);
780             if (exit_on_error)
781                 ffmpeg_exit(1);
782         }
783         *pkt= new_pkt;
784
785         bsfc= bsfc->next;
786     }
787
788     ret= av_interleaved_write_frame(s, pkt);
789     if(ret < 0){
790         print_error("av_interleaved_write_frame()", ret);
791         ffmpeg_exit(1);
792     }
793 }
794
795 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
796
797 static void do_audio_out(AVFormatContext *s,
798                          AVOutputStream *ost,
799                          AVInputStream *ist,
800                          unsigned char *buf, int size)
801 {
802     uint8_t *buftmp;
803     int64_t audio_out_size, audio_buf_size;
804     int64_t allocated_for_size= size;
805
806     int size_out, frame_bytes, ret;
807     AVCodecContext *enc= ost->st->codec;
808     AVCodecContext *dec= ist->st->codec;
809     int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
810     int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
811     const int coded_bps = av_get_bits_per_sample(enc->codec->id);
812
813 need_realloc:
814     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
815     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
816     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
817     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
818     audio_buf_size*= osize*enc->channels;
819
820     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
821     if(coded_bps > 8*osize)
822         audio_out_size= audio_out_size * coded_bps / (8*osize);
823     audio_out_size += FF_MIN_BUFFER_SIZE;
824
825     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
826         fprintf(stderr, "Buffer sizes too large\n");
827         ffmpeg_exit(1);
828     }
829
830     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
831     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
832     if (!audio_buf || !audio_out){
833         fprintf(stderr, "Out of memory in do_audio_out\n");
834         ffmpeg_exit(1);
835     }
836
837     if (enc->channels != dec->channels)
838         ost->audio_resample = 1;
839
840     if (ost->audio_resample && !ost->resample) {
841         if (dec->sample_fmt != SAMPLE_FMT_S16)
842             fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
843         ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
844                                                enc->sample_rate, dec->sample_rate,
845                                                enc->sample_fmt,  dec->sample_fmt,
846                                                16, 10, 0, 0.8);
847         if (!ost->resample) {
848             fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
849                     dec->channels, dec->sample_rate,
850                     enc->channels, enc->sample_rate);
851             ffmpeg_exit(1);
852         }
853     }
854
855 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
856     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
857         MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
858         if (ost->reformat_ctx)
859             av_audio_convert_free(ost->reformat_ctx);
860         ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
861                                                    dec->sample_fmt, 1, NULL, 0);
862         if (!ost->reformat_ctx) {
863             fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
864                 avcodec_get_sample_fmt_name(dec->sample_fmt),
865                 avcodec_get_sample_fmt_name(enc->sample_fmt));
866             ffmpeg_exit(1);
867         }
868         ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
869     }
870
871     if(audio_sync_method){
872         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
873                 - av_fifo_size(ost->fifo)/(enc->channels * 2);
874         double idelta= delta*dec->sample_rate / enc->sample_rate;
875         int byte_delta= ((int)idelta)*2*dec->channels;
876
877         //FIXME resample delay
878         if(fabs(delta) > 50){
879             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
880                 if(byte_delta < 0){
881                     byte_delta= FFMAX(byte_delta, -size);
882                     size += byte_delta;
883                     buf  -= byte_delta;
884                     if(verbose > 2)
885                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
886                     if(!size)
887                         return;
888                     ist->is_start=0;
889                 }else{
890                     static uint8_t *input_tmp= NULL;
891                     input_tmp= av_realloc(input_tmp, byte_delta + size);
892
893                     if(byte_delta > allocated_for_size - size){
894                         allocated_for_size= byte_delta + (int64_t)size;
895                         goto need_realloc;
896                     }
897                     ist->is_start=0;
898
899                     memset(input_tmp, 0, byte_delta);
900                     memcpy(input_tmp + byte_delta, buf, size);
901                     buf= input_tmp;
902                     size += byte_delta;
903                     if(verbose > 2)
904                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
905                 }
906             }else if(audio_sync_method>1){
907                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
908                 assert(ost->audio_resample);
909                 if(verbose > 2)
910                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
911 //                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));
912                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
913             }
914         }
915     }else
916         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
917                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
918
919     if (ost->audio_resample) {
920         buftmp = audio_buf;
921         size_out = audio_resample(ost->resample,
922                                   (short *)buftmp, (short *)buf,
923                                   size / (dec->channels * isize));
924         size_out = size_out * enc->channels * osize;
925     } else {
926         buftmp = buf;
927         size_out = size;
928     }
929
930     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
931         const void *ibuf[6]= {buftmp};
932         void *obuf[6]= {audio_buf};
933         int istride[6]= {isize};
934         int ostride[6]= {osize};
935         int len= size_out/istride[0];
936         if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
937             printf("av_audio_convert() failed\n");
938             if (exit_on_error)
939                 ffmpeg_exit(1);
940             return;
941         }
942         buftmp = audio_buf;
943         size_out = len*osize;
944     }
945
946     /* now encode as many frames as possible */
947     if (enc->frame_size > 1) {
948         /* output resampled raw samples */
949         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
950             fprintf(stderr, "av_fifo_realloc2() failed\n");
951             ffmpeg_exit(1);
952         }
953         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
954
955         frame_bytes = enc->frame_size * osize * enc->channels;
956
957         while (av_fifo_size(ost->fifo) >= frame_bytes) {
958             AVPacket pkt;
959             av_init_packet(&pkt);
960
961             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
962
963             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
964
965             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
966                                        (short *)audio_buf);
967             if (ret < 0) {
968                 fprintf(stderr, "Audio encoding failed\n");
969                 ffmpeg_exit(1);
970             }
971             audio_size += ret;
972             pkt.stream_index= ost->index;
973             pkt.data= audio_out;
974             pkt.size= ret;
975             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
976                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
977             pkt.flags |= AV_PKT_FLAG_KEY;
978             write_frame(s, &pkt, enc, bitstream_filters[ost->file_index][pkt.stream_index]);
979
980             ost->sync_opts += enc->frame_size;
981         }
982     } else {
983         AVPacket pkt;
984         av_init_packet(&pkt);
985
986         ost->sync_opts += size_out / (osize * enc->channels);
987
988         /* output a pcm frame */
989         /* determine the size of the coded buffer */
990         size_out /= osize;
991         if (coded_bps)
992             size_out = size_out*coded_bps/8;
993
994         if(size_out > audio_out_size){
995             fprintf(stderr, "Internal error, buffer size too small\n");
996             ffmpeg_exit(1);
997         }
998
999         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1000         ret = avcodec_encode_audio(enc, audio_out, size_out,
1001                                    (short *)buftmp);
1002         if (ret < 0) {
1003             fprintf(stderr, "Audio encoding failed\n");
1004             ffmpeg_exit(1);
1005         }
1006         audio_size += ret;
1007         pkt.stream_index= ost->index;
1008         pkt.data= audio_out;
1009         pkt.size= ret;
1010         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1011             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1012         pkt.flags |= AV_PKT_FLAG_KEY;
1013         write_frame(s, &pkt, enc, bitstream_filters[ost->file_index][pkt.stream_index]);
1014     }
1015 }
1016
1017 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1018 {
1019     AVCodecContext *dec;
1020     AVPicture *picture2;
1021     AVPicture picture_tmp;
1022     uint8_t *buf = 0;
1023
1024     dec = ist->st->codec;
1025
1026     /* deinterlace : must be done before any resize */
1027     if (do_deinterlace) {
1028         int size;
1029
1030         /* create temporary picture */
1031         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1032         buf = av_malloc(size);
1033         if (!buf)
1034             return;
1035
1036         picture2 = &picture_tmp;
1037         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1038
1039         if(avpicture_deinterlace(picture2, picture,
1040                                  dec->pix_fmt, dec->width, dec->height) < 0) {
1041             /* if error, do not deinterlace */
1042             fprintf(stderr, "Deinterlacing failed\n");
1043             av_free(buf);
1044             buf = NULL;
1045             picture2 = picture;
1046         }
1047     } else {
1048         picture2 = picture;
1049     }
1050
1051     if (picture != picture2)
1052         *picture = *picture2;
1053     *bufp = buf;
1054 }
1055
1056 /* we begin to correct av delay at this threshold */
1057 #define AV_DELAY_MAX 0.100
1058
1059 static void do_subtitle_out(AVFormatContext *s,
1060                             AVOutputStream *ost,
1061                             AVInputStream *ist,
1062                             AVSubtitle *sub,
1063                             int64_t pts)
1064 {
1065     static uint8_t *subtitle_out = NULL;
1066     int subtitle_out_max_size = 1024 * 1024;
1067     int subtitle_out_size, nb, i;
1068     AVCodecContext *enc;
1069     AVPacket pkt;
1070
1071     if (pts == AV_NOPTS_VALUE) {
1072         fprintf(stderr, "Subtitle packets must have a pts\n");
1073         if (exit_on_error)
1074             ffmpeg_exit(1);
1075         return;
1076     }
1077
1078     enc = ost->st->codec;
1079
1080     if (!subtitle_out) {
1081         subtitle_out = av_malloc(subtitle_out_max_size);
1082     }
1083
1084     /* Note: DVB subtitle need one packet to draw them and one other
1085        packet to clear them */
1086     /* XXX: signal it in the codec context ? */
1087     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1088         nb = 2;
1089     else
1090         nb = 1;
1091
1092     for(i = 0; i < nb; i++) {
1093         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1094         // start_display_time is required to be 0
1095         sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1096         sub->end_display_time -= sub->start_display_time;
1097         sub->start_display_time = 0;
1098         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1099                                                     subtitle_out_max_size, sub);
1100         if (subtitle_out_size < 0) {
1101             fprintf(stderr, "Subtitle encoding failed\n");
1102             ffmpeg_exit(1);
1103         }
1104
1105         av_init_packet(&pkt);
1106         pkt.stream_index = ost->index;
1107         pkt.data = subtitle_out;
1108         pkt.size = subtitle_out_size;
1109         pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1110         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1111             /* XXX: the pts correction is handled here. Maybe handling
1112                it in the codec would be better */
1113             if (i == 0)
1114                 pkt.pts += 90 * sub->start_display_time;
1115             else
1116                 pkt.pts += 90 * sub->end_display_time;
1117         }
1118         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1119     }
1120 }
1121
1122 static int bit_buffer_size= 1024*256;
1123 static uint8_t *bit_buffer= NULL;
1124
1125 static void do_video_out(AVFormatContext *s,
1126                          AVOutputStream *ost,
1127                          AVInputStream *ist,
1128                          AVFrame *in_picture,
1129                          int *frame_size)
1130 {
1131     int nb_frames, i, ret;
1132 #if !CONFIG_AVFILTER
1133     int64_t topBand, bottomBand, leftBand, rightBand;
1134 #endif
1135     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1136     AVFrame picture_crop_temp, picture_pad_temp;
1137     AVCodecContext *enc, *dec;
1138     double sync_ipts;
1139
1140     avcodec_get_frame_defaults(&picture_crop_temp);
1141     avcodec_get_frame_defaults(&picture_pad_temp);
1142
1143     enc = ost->st->codec;
1144     dec = ist->st->codec;
1145
1146     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1147
1148     /* by default, we output a single frame */
1149     nb_frames = 1;
1150
1151     *frame_size = 0;
1152
1153     if(video_sync_method){
1154         double vdelta = sync_ipts - ost->sync_opts;
1155         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1156         if (vdelta < -1.1)
1157             nb_frames = 0;
1158         else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1159             if(vdelta<=-0.6){
1160                 nb_frames=0;
1161             }else if(vdelta>0.6)
1162             ost->sync_opts= lrintf(sync_ipts);
1163         }else if (vdelta > 1.1)
1164             nb_frames = lrintf(vdelta);
1165 //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);
1166         if (nb_frames == 0){
1167             ++nb_frames_drop;
1168             if (verbose>2)
1169                 fprintf(stderr, "*** drop!\n");
1170         }else if (nb_frames > 1) {
1171             nb_frames_dup += nb_frames - 1;
1172             if (verbose>2)
1173                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1174         }
1175     }else
1176         ost->sync_opts= lrintf(sync_ipts);
1177
1178     nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1179     if (nb_frames <= 0)
1180         return;
1181
1182 #if CONFIG_AVFILTER
1183     formatted_picture = in_picture;
1184 #else
1185     if (ost->video_crop) {
1186         if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
1187             fprintf(stderr, "error cropping picture\n");
1188             if (exit_on_error)
1189                 ffmpeg_exit(1);
1190             return;
1191         }
1192         formatted_picture = &picture_crop_temp;
1193     } else {
1194         formatted_picture = in_picture;
1195     }
1196 #endif
1197
1198     final_picture = formatted_picture;
1199     padding_src = formatted_picture;
1200     resampling_dst = &ost->pict_tmp;
1201
1202     if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1203         || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1204         || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1205
1206         fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1207         if(!ost->video_resample)
1208             ffmpeg_exit(1);
1209     }
1210
1211 #if !CONFIG_AVFILTER
1212     if (ost->video_resample) {
1213         padding_src = NULL;
1214         final_picture = &ost->pict_tmp;
1215         if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1216           || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1217           || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1218
1219             /* keep bands proportional to the frame size */
1220             topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
1221             bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1222             leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
1223             rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
1224
1225             /* sanity check to ensure no bad band sizes sneak in */
1226             assert(topBand    <= INT_MAX && topBand    >= 0);
1227             assert(bottomBand <= INT_MAX && bottomBand >= 0);
1228             assert(leftBand   <= INT_MAX && leftBand   >= 0);
1229             assert(rightBand  <= INT_MAX && rightBand  >= 0);
1230
1231             ost->topBand    = topBand;
1232             ost->bottomBand = bottomBand;
1233             ost->leftBand   = leftBand;
1234             ost->rightBand  = rightBand;
1235
1236             ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1237             ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1238             ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1239
1240             /* initialize a new scaler context */
1241             sws_freeContext(ost->img_resample_ctx);
1242             sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1243             ost->img_resample_ctx = sws_getContext(
1244                 ist->st->codec->width  - (ost->leftBand + ost->rightBand),
1245                 ist->st->codec->height - (ost->topBand  + ost->bottomBand),
1246                 ist->st->codec->pix_fmt,
1247                 ost->st->codec->width,
1248                 ost->st->codec->height,
1249                 ost->st->codec->pix_fmt,
1250                 sws_flags, NULL, NULL, NULL);
1251             if (ost->img_resample_ctx == NULL) {
1252                 fprintf(stderr, "Cannot get resampling context\n");
1253                 ffmpeg_exit(1);
1254             }
1255         }
1256         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1257               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1258     }
1259 #endif
1260
1261     /* duplicates frame if needed */
1262     for(i=0;i<nb_frames;i++) {
1263         AVPacket pkt;
1264         av_init_packet(&pkt);
1265         pkt.stream_index= ost->index;
1266
1267         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1268             /* raw pictures are written as AVPicture structure to
1269                avoid any copies. We support temorarily the older
1270                method. */
1271             AVFrame* old_frame = enc->coded_frame;
1272             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1273             pkt.data= (uint8_t *)final_picture;
1274             pkt.size=  sizeof(AVPicture);
1275             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1276             pkt.flags |= AV_PKT_FLAG_KEY;
1277
1278             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1279             enc->coded_frame = old_frame;
1280         } else {
1281             AVFrame big_picture;
1282
1283             big_picture= *final_picture;
1284             /* better than nothing: use input picture interlaced
1285                settings */
1286             big_picture.interlaced_frame = in_picture->interlaced_frame;
1287             if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1288                 if(top_field_first == -1)
1289                     big_picture.top_field_first = in_picture->top_field_first;
1290                 else
1291                     big_picture.top_field_first = top_field_first;
1292             }
1293
1294             /* handles sameq here. This is not correct because it may
1295                not be a global option */
1296             big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1297             if(!me_threshold)
1298                 big_picture.pict_type = 0;
1299 //            big_picture.pts = AV_NOPTS_VALUE;
1300             big_picture.pts= ost->sync_opts;
1301 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1302 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1303             ret = avcodec_encode_video(enc,
1304                                        bit_buffer, bit_buffer_size,
1305                                        &big_picture);
1306             if (ret < 0) {
1307                 fprintf(stderr, "Video encoding failed\n");
1308                 ffmpeg_exit(1);
1309             }
1310
1311             if(ret>0){
1312                 pkt.data= bit_buffer;
1313                 pkt.size= ret;
1314                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1315                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1316 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1317    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1318    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1319
1320                 if(enc->coded_frame->key_frame)
1321                     pkt.flags |= AV_PKT_FLAG_KEY;
1322                 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1323                 *frame_size = ret;
1324                 video_size += ret;
1325                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1326                 //        enc->frame_number-1, ret, enc->pict_type);
1327                 /* if two pass, output log */
1328                 if (ost->logfile && enc->stats_out) {
1329                     fprintf(ost->logfile, "%s", enc->stats_out);
1330                 }
1331             }
1332         }
1333         ost->sync_opts++;
1334         ost->frame_number++;
1335     }
1336 }
1337
1338 static double psnr(double d){
1339     return -10.0*log(d)/log(10.0);
1340 }
1341
1342 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1343                            int frame_size)
1344 {
1345     AVCodecContext *enc;
1346     int frame_number;
1347     double ti1, bitrate, avg_bitrate;
1348
1349     /* this is executed just the first time do_video_stats is called */
1350     if (!vstats_file) {
1351         vstats_file = fopen(vstats_filename, "w");
1352         if (!vstats_file) {
1353             perror("fopen");
1354             ffmpeg_exit(1);
1355         }
1356     }
1357
1358     enc = ost->st->codec;
1359     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1360         frame_number = ost->frame_number;
1361         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1362         if (enc->flags&CODEC_FLAG_PSNR)
1363             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1364
1365         fprintf(vstats_file,"f_size= %6d ", frame_size);
1366         /* compute pts value */
1367         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1368         if (ti1 < 0.01)
1369             ti1 = 0.01;
1370
1371         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1372         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1373         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1374             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1375         fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1376     }
1377 }
1378
1379 static void print_report(AVFormatContext **output_files,
1380                          AVOutputStream **ost_table, int nb_ostreams,
1381                          int is_last_report)
1382 {
1383     char buf[1024];
1384     AVOutputStream *ost;
1385     AVFormatContext *oc;
1386     int64_t total_size;
1387     AVCodecContext *enc;
1388     int frame_number, vid, i;
1389     double bitrate, ti1, pts;
1390     static int64_t last_time = -1;
1391     static int qp_histogram[52];
1392
1393     if (!is_last_report) {
1394         int64_t cur_time;
1395         /* display the report every 0.5 seconds */
1396         cur_time = av_gettime();
1397         if (last_time == -1) {
1398             last_time = cur_time;
1399             return;
1400         }
1401         if ((cur_time - last_time) < 500000)
1402             return;
1403         last_time = cur_time;
1404     }
1405
1406
1407     oc = output_files[0];
1408
1409     total_size = url_fsize(oc->pb);
1410     if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1411         total_size= url_ftell(oc->pb);
1412
1413     buf[0] = '\0';
1414     ti1 = 1e10;
1415     vid = 0;
1416     for(i=0;i<nb_ostreams;i++) {
1417         ost = ost_table[i];
1418         enc = ost->st->codec;
1419         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1420             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1421                      !ost->st->stream_copy ?
1422                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1423         }
1424         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1425             float t = (av_gettime()-timer_start) / 1000000.0;
1426
1427             frame_number = ost->frame_number;
1428             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1429                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1430                      !ost->st->stream_copy ?
1431                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1432             if(is_last_report)
1433                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1434             if(qp_hist){
1435                 int j;
1436                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1437                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1438                     qp_histogram[qp]++;
1439                 for(j=0; j<32; j++)
1440                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1441             }
1442             if (enc->flags&CODEC_FLAG_PSNR){
1443                 int j;
1444                 double error, error_sum=0;
1445                 double scale, scale_sum=0;
1446                 char type[3]= {'Y','U','V'};
1447                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1448                 for(j=0; j<3; j++){
1449                     if(is_last_report){
1450                         error= enc->error[j];
1451                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1452                     }else{
1453                         error= enc->coded_frame->error[j];
1454                         scale= enc->width*enc->height*255.0*255.0;
1455                     }
1456                     if(j) scale/=4;
1457                     error_sum += error;
1458                     scale_sum += scale;
1459                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1460                 }
1461                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1462             }
1463             vid = 1;
1464         }
1465         /* compute min output value */
1466         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1467         if ((pts < ti1) && (pts > 0))
1468             ti1 = pts;
1469     }
1470     if (ti1 < 0.01)
1471         ti1 = 0.01;
1472
1473     if (verbose || is_last_report) {
1474         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1475
1476         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1477             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1478             (double)total_size / 1024, ti1, bitrate);
1479
1480         if (nb_frames_dup || nb_frames_drop)
1481           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1482                   nb_frames_dup, nb_frames_drop);
1483
1484         if (verbose >= 0)
1485             fprintf(stderr, "%s    \r", buf);
1486
1487         fflush(stderr);
1488     }
1489
1490     if (is_last_report && verbose >= 0){
1491         int64_t raw= audio_size + video_size + extra_size;
1492         fprintf(stderr, "\n");
1493         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1494                 video_size/1024.0,
1495                 audio_size/1024.0,
1496                 extra_size/1024.0,
1497                 100.0*(total_size - raw)/raw
1498         );
1499     }
1500 }
1501
1502 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1503 static int output_packet(AVInputStream *ist, int ist_index,
1504                          AVOutputStream **ost_table, int nb_ostreams,
1505                          const AVPacket *pkt)
1506 {
1507     AVFormatContext *os;
1508     AVOutputStream *ost;
1509     int ret, i;
1510     int got_picture;
1511     AVFrame picture;
1512     void *buffer_to_free;
1513     static unsigned int samples_size= 0;
1514     AVSubtitle subtitle, *subtitle_to_free;
1515 #if CONFIG_AVFILTER
1516     int frame_available;
1517 #endif
1518
1519     AVPacket avpkt;
1520     int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1521
1522     if(ist->next_pts == AV_NOPTS_VALUE)
1523         ist->next_pts= ist->pts;
1524
1525     if (pkt == NULL) {
1526         /* EOF handling */
1527         av_init_packet(&avpkt);
1528         avpkt.data = NULL;
1529         avpkt.size = 0;
1530         goto handle_eof;
1531     } else {
1532         avpkt = *pkt;
1533     }
1534
1535     if(pkt->dts != AV_NOPTS_VALUE)
1536         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1537
1538     //while we have more to decode or while the decoder did output something on EOF
1539     while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1540         uint8_t *data_buf, *decoded_data_buf;
1541         int data_size, decoded_data_size;
1542     handle_eof:
1543         ist->pts= ist->next_pts;
1544
1545         if(avpkt.size && avpkt.size != pkt->size &&
1546            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1547             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1548             ist->showed_multi_packet_warning=1;
1549         }
1550
1551         /* decode the packet if needed */
1552         decoded_data_buf = NULL; /* fail safe */
1553         decoded_data_size= 0;
1554         data_buf  = avpkt.data;
1555         data_size = avpkt.size;
1556         subtitle_to_free = NULL;
1557         if (ist->decoding_needed) {
1558             switch(ist->st->codec->codec_type) {
1559             case AVMEDIA_TYPE_AUDIO:{
1560                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1561                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1562                     av_free(samples);
1563                     samples= av_malloc(samples_size);
1564                 }
1565                 decoded_data_size= samples_size;
1566                     /* XXX: could avoid copy if PCM 16 bits with same
1567                        endianness as CPU */
1568                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1569                                             &avpkt);
1570                 if (ret < 0)
1571                     goto fail_decode;
1572                 avpkt.data += ret;
1573                 avpkt.size -= ret;
1574                 data_size   = ret;
1575                 /* Some bug in mpeg audio decoder gives */
1576                 /* decoded_data_size < 0, it seems they are overflows */
1577                 if (decoded_data_size <= 0) {
1578                     /* no audio frame */
1579                     continue;
1580                 }
1581                 decoded_data_buf = (uint8_t *)samples;
1582                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1583                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1584                 break;}
1585             case AVMEDIA_TYPE_VIDEO:
1586                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1587                     /* XXX: allocate picture correctly */
1588                     avcodec_get_frame_defaults(&picture);
1589
1590                     ret = avcodec_decode_video2(ist->st->codec,
1591                                                 &picture, &got_picture, &avpkt);
1592                     ist->st->quality= picture.quality;
1593                     if (ret < 0)
1594                         goto fail_decode;
1595                     if (!got_picture) {
1596                         /* no picture yet */
1597                         goto discard_packet;
1598                     }
1599                     if (ist->st->codec->time_base.num != 0) {
1600                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1601                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1602                                           ist->st->codec->time_base.num * ticks) /
1603                             ist->st->codec->time_base.den;
1604                     }
1605                     avpkt.size = 0;
1606                     break;
1607             case AVMEDIA_TYPE_SUBTITLE:
1608                 ret = avcodec_decode_subtitle2(ist->st->codec,
1609                                                &subtitle, &got_picture, &avpkt);
1610                 if (ret < 0)
1611                     goto fail_decode;
1612                 if (!got_picture) {
1613                     goto discard_packet;
1614                 }
1615                 subtitle_to_free = &subtitle;
1616                 avpkt.size = 0;
1617                 break;
1618             default:
1619                 goto fail_decode;
1620             }
1621         } else {
1622             switch(ist->st->codec->codec_type) {
1623             case AVMEDIA_TYPE_AUDIO:
1624                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1625                     ist->st->codec->sample_rate;
1626                 break;
1627             case AVMEDIA_TYPE_VIDEO:
1628                 if (ist->st->codec->time_base.num != 0) {
1629                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1630                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1631                                       ist->st->codec->time_base.num * ticks) /
1632                         ist->st->codec->time_base.den;
1633                 }
1634                 break;
1635             }
1636             ret = avpkt.size;
1637             avpkt.size = 0;
1638         }
1639
1640         buffer_to_free = NULL;
1641         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1642             pre_process_video_frame(ist, (AVPicture *)&picture,
1643                                     &buffer_to_free);
1644         }
1645
1646 #if CONFIG_AVFILTER
1647         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1648             // add it to be filtered
1649             av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1650                                      ist->pts,
1651                                      ist->st->codec->sample_aspect_ratio);
1652         }
1653 #endif
1654
1655         // preprocess audio (volume)
1656         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1657             if (audio_volume != 256) {
1658                 short *volp;
1659                 volp = samples;
1660                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1661                     int v = ((*volp) * audio_volume + 128) >> 8;
1662                     if (v < -32768) v = -32768;
1663                     if (v >  32767) v = 32767;
1664                     *volp++ = v;
1665                 }
1666             }
1667         }
1668
1669         /* frame rate emulation */
1670         if (rate_emu) {
1671             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1672             int64_t now = av_gettime() - ist->start;
1673             if (pts > now)
1674                 usleep(pts - now);
1675         }
1676 #if CONFIG_AVFILTER
1677         frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1678             !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1679 #endif
1680         /* if output time reached then transcode raw format,
1681            encode packets and output them */
1682         if (start_time == 0 || ist->pts >= start_time)
1683 #if CONFIG_AVFILTER
1684         while (frame_available) {
1685             if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1686                 get_filtered_video_pic(ist->output_video_filter, &ist->picref, &picture, &ist->pts);
1687 #endif
1688             for(i=0;i<nb_ostreams;i++) {
1689                 int frame_size;
1690
1691                 ost = ost_table[i];
1692                 if (ost->source_index == ist_index) {
1693                     os = output_files[ost->file_index];
1694
1695                     /* set the input output pts pairs */
1696                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1697
1698                     if (ost->encoding_needed) {
1699                         assert(ist->decoding_needed);
1700                         switch(ost->st->codec->codec_type) {
1701                         case AVMEDIA_TYPE_AUDIO:
1702                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1703                             break;
1704                         case AVMEDIA_TYPE_VIDEO:
1705 #if CONFIG_AVFILTER
1706                             if (ist->picref->video)
1707                                 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1708 #endif
1709                             do_video_out(os, ost, ist, &picture, &frame_size);
1710                             if (vstats_filename && frame_size)
1711                                 do_video_stats(os, ost, frame_size);
1712                             break;
1713                         case AVMEDIA_TYPE_SUBTITLE:
1714                             do_subtitle_out(os, ost, ist, &subtitle,
1715                                             pkt->pts);
1716                             break;
1717                         default:
1718                             abort();
1719                         }
1720                     } else {
1721                         AVFrame avframe; //FIXME/XXX remove this
1722                         AVPacket opkt;
1723                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1724
1725                         av_init_packet(&opkt);
1726
1727                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1728                             continue;
1729
1730                         /* no reencoding needed : output the packet directly */
1731                         /* force the input stream PTS */
1732
1733                         avcodec_get_frame_defaults(&avframe);
1734                         ost->st->codec->coded_frame= &avframe;
1735                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1736
1737                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1738                             audio_size += data_size;
1739                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1740                             video_size += data_size;
1741                             ost->sync_opts++;
1742                         }
1743
1744                         opkt.stream_index= ost->index;
1745                         if(pkt->pts != AV_NOPTS_VALUE)
1746                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1747                         else
1748                             opkt.pts= AV_NOPTS_VALUE;
1749
1750                         if (pkt->dts == AV_NOPTS_VALUE)
1751                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1752                         else
1753                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1754                         opkt.dts -= ost_tb_start_time;
1755
1756                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1757                         opkt.flags= pkt->flags;
1758
1759                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1760                         if(   ost->st->codec->codec_id != CODEC_ID_H264
1761                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1762                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1763                            ) {
1764                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1765                                 opkt.destruct= av_destruct_packet;
1766                         } else {
1767                             opkt.data = data_buf;
1768                             opkt.size = data_size;
1769                         }
1770
1771                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1772                         ost->st->codec->frame_number++;
1773                         ost->frame_number++;
1774                         av_free_packet(&opkt);
1775                     }
1776                 }
1777             }
1778
1779 #if CONFIG_AVFILTER
1780             frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1781                               ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1782             if(ist->picref)
1783                 avfilter_unref_buffer(ist->picref);
1784         }
1785 #endif
1786         av_free(buffer_to_free);
1787         /* XXX: allocate the subtitles in the codec ? */
1788         if (subtitle_to_free) {
1789             if (subtitle_to_free->rects != NULL) {
1790                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1791                     av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1792                     av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1793                     av_freep(&subtitle_to_free->rects[i]);
1794                 }
1795                 av_freep(&subtitle_to_free->rects);
1796             }
1797             subtitle_to_free->num_rects = 0;
1798             subtitle_to_free = NULL;
1799         }
1800     }
1801  discard_packet:
1802     if (pkt == NULL) {
1803         /* EOF handling */
1804
1805         for(i=0;i<nb_ostreams;i++) {
1806             ost = ost_table[i];
1807             if (ost->source_index == ist_index) {
1808                 AVCodecContext *enc= ost->st->codec;
1809                 os = output_files[ost->file_index];
1810
1811                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1812                     continue;
1813                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1814                     continue;
1815
1816                 if (ost->encoding_needed) {
1817                     for(;;) {
1818                         AVPacket pkt;
1819                         int fifo_bytes;
1820                         av_init_packet(&pkt);
1821                         pkt.stream_index= ost->index;
1822
1823                         switch(ost->st->codec->codec_type) {
1824                         case AVMEDIA_TYPE_AUDIO:
1825                             fifo_bytes = av_fifo_size(ost->fifo);
1826                             ret = 0;
1827                             /* encode any samples remaining in fifo */
1828                             if (fifo_bytes > 0) {
1829                                 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1830                                 int fs_tmp = enc->frame_size;
1831
1832                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1833                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1834                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1835                                 } else { /* pad */
1836                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1837                                     if (allocated_audio_buf_size < frame_bytes)
1838                                         ffmpeg_exit(1);
1839                                     memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1840                                 }
1841
1842                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1843                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1844                                                           ost->st->time_base.num, enc->sample_rate);
1845                                 enc->frame_size = fs_tmp;
1846                             }
1847                             if(ret <= 0) {
1848                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1849                             }
1850                             if (ret < 0) {
1851                                 fprintf(stderr, "Audio encoding failed\n");
1852                                 ffmpeg_exit(1);
1853                             }
1854                             audio_size += ret;
1855                             pkt.flags |= AV_PKT_FLAG_KEY;
1856                             break;
1857                         case AVMEDIA_TYPE_VIDEO:
1858                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1859                             if (ret < 0) {
1860                                 fprintf(stderr, "Video encoding failed\n");
1861                                 ffmpeg_exit(1);
1862                             }
1863                             video_size += ret;
1864                             if(enc->coded_frame && enc->coded_frame->key_frame)
1865                                 pkt.flags |= AV_PKT_FLAG_KEY;
1866                             if (ost->logfile && enc->stats_out) {
1867                                 fprintf(ost->logfile, "%s", enc->stats_out);
1868                             }
1869                             break;
1870                         default:
1871                             ret=-1;
1872                         }
1873
1874                         if(ret<=0)
1875                             break;
1876                         pkt.data= bit_buffer;
1877                         pkt.size= ret;
1878                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1879                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1880                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1881                     }
1882                 }
1883             }
1884         }
1885     }
1886
1887     return 0;
1888  fail_decode:
1889     return -1;
1890 }
1891
1892 static void print_sdp(AVFormatContext **avc, int n)
1893 {
1894     char sdp[2048];
1895
1896     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1897     printf("SDP:\n%s\n", sdp);
1898     fflush(stdout);
1899 }
1900
1901 static int copy_chapters(int infile, int outfile)
1902 {
1903     AVFormatContext *is = input_files[infile];
1904     AVFormatContext *os = output_files[outfile];
1905     int i;
1906
1907     for (i = 0; i < is->nb_chapters; i++) {
1908         AVChapter *in_ch = is->chapters[i], *out_ch;
1909         AVMetadataTag *t = NULL;
1910         int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1911                                       AV_TIME_BASE_Q, in_ch->time_base);
1912         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1913                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1914
1915
1916         if (in_ch->end < ts_off)
1917             continue;
1918         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1919             break;
1920
1921         out_ch = av_mallocz(sizeof(AVChapter));
1922         if (!out_ch)
1923             return AVERROR(ENOMEM);
1924
1925         out_ch->id        = in_ch->id;
1926         out_ch->time_base = in_ch->time_base;
1927         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1928         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1929
1930         while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1931             av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1932
1933         os->nb_chapters++;
1934         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1935         if (!os->chapters)
1936             return AVERROR(ENOMEM);
1937         os->chapters[os->nb_chapters - 1] = out_ch;
1938     }
1939     return 0;
1940 }
1941
1942 /*
1943  * The following code is the main loop of the file converter
1944  */
1945 static int transcode(AVFormatContext **output_files,
1946                      int nb_output_files,
1947                      AVFormatContext **input_files,
1948                      int nb_input_files,
1949                      AVStreamMap *stream_maps, int nb_stream_maps)
1950 {
1951     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1952     AVFormatContext *is, *os;
1953     AVCodecContext *codec, *icodec;
1954     AVOutputStream *ost, **ost_table = NULL;
1955     AVInputStream *ist, **ist_table = NULL;
1956     AVInputFile *file_table;
1957     char error[1024];
1958     int key;
1959     int want_sdp = 1;
1960     uint8_t no_packet[MAX_FILES]={0};
1961     int no_packet_count=0;
1962
1963     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1964     if (!file_table)
1965         goto fail;
1966
1967     /* input stream init */
1968     j = 0;
1969     for(i=0;i<nb_input_files;i++) {
1970         is = input_files[i];
1971         file_table[i].ist_index = j;
1972         file_table[i].nb_streams = is->nb_streams;
1973         j += is->nb_streams;
1974     }
1975     nb_istreams = j;
1976
1977     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1978     if (!ist_table)
1979         goto fail;
1980
1981     for(i=0;i<nb_istreams;i++) {
1982         ist = av_mallocz(sizeof(AVInputStream));
1983         if (!ist)
1984             goto fail;
1985         ist_table[i] = ist;
1986     }
1987     j = 0;
1988     for(i=0;i<nb_input_files;i++) {
1989         is = input_files[i];
1990         for(k=0;k<is->nb_streams;k++) {
1991             ist = ist_table[j++];
1992             ist->st = is->streams[k];
1993             ist->file_index = i;
1994             ist->index = k;
1995             ist->discard = 1; /* the stream is discarded by default
1996                                  (changed later) */
1997
1998             if (rate_emu) {
1999                 ist->start = av_gettime();
2000             }
2001         }
2002     }
2003
2004     /* output stream init */
2005     nb_ostreams = 0;
2006     for(i=0;i<nb_output_files;i++) {
2007         os = output_files[i];
2008         if (!os->nb_streams) {
2009             dump_format(output_files[i], i, output_files[i]->filename, 1);
2010             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2011             ret = AVERROR(EINVAL);
2012             goto fail;
2013         }
2014         nb_ostreams += os->nb_streams;
2015     }
2016     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2017         fprintf(stderr, "Number of stream maps must match number of output streams\n");
2018         ret = AVERROR(EINVAL);
2019         goto fail;
2020     }
2021
2022     /* Sanity check the mapping args -- do the input files & streams exist? */
2023     for(i=0;i<nb_stream_maps;i++) {
2024         int fi = stream_maps[i].file_index;
2025         int si = stream_maps[i].stream_index;
2026
2027         if (fi < 0 || fi > nb_input_files - 1 ||
2028             si < 0 || si > file_table[fi].nb_streams - 1) {
2029             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2030             ret = AVERROR(EINVAL);
2031             goto fail;
2032         }
2033         fi = stream_maps[i].sync_file_index;
2034         si = stream_maps[i].sync_stream_index;
2035         if (fi < 0 || fi > nb_input_files - 1 ||
2036             si < 0 || si > file_table[fi].nb_streams - 1) {
2037             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2038             ret = AVERROR(EINVAL);
2039             goto fail;
2040         }
2041     }
2042
2043     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2044     if (!ost_table)
2045         goto fail;
2046     for(i=0;i<nb_ostreams;i++) {
2047         ost = av_mallocz(sizeof(AVOutputStream));
2048         if (!ost)
2049             goto fail;
2050         ost_table[i] = ost;
2051     }
2052
2053     n = 0;
2054     for(k=0;k<nb_output_files;k++) {
2055         os = output_files[k];
2056         for(i=0;i<os->nb_streams;i++,n++) {
2057             int found;
2058             ost = ost_table[n];
2059             ost->file_index = k;
2060             ost->index = i;
2061             ost->st = os->streams[i];
2062             if (nb_stream_maps > 0) {
2063                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2064                     stream_maps[n].stream_index;
2065
2066                 /* Sanity check that the stream types match */
2067                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2068                     int i= ost->file_index;
2069                     dump_format(output_files[i], i, output_files[i]->filename, 1);
2070                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2071                         stream_maps[n].file_index, stream_maps[n].stream_index,
2072                         ost->file_index, ost->index);
2073                     ffmpeg_exit(1);
2074                 }
2075
2076             } else {
2077                 int best_nb_frames=-1;
2078                 /* get corresponding input stream index : we select the first one with the right type */
2079                 found = 0;
2080                 for(j=0;j<nb_istreams;j++) {
2081                     int skip=0;
2082                     ist = ist_table[j];
2083                     if(opt_programid){
2084                         int pi,si;
2085                         AVFormatContext *f= input_files[ ist->file_index ];
2086                         skip=1;
2087                         for(pi=0; pi<f->nb_programs; pi++){
2088                             AVProgram *p= f->programs[pi];
2089                             if(p->id == opt_programid)
2090                                 for(si=0; si<p->nb_stream_indexes; si++){
2091                                     if(f->streams[ p->stream_index[si] ] == ist->st)
2092                                         skip=0;
2093                                 }
2094                         }
2095                     }
2096                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2097                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
2098                         if(best_nb_frames < ist->st->codec_info_nb_frames){
2099                             best_nb_frames= ist->st->codec_info_nb_frames;
2100                             ost->source_index = j;
2101                             found = 1;
2102                         }
2103                     }
2104                 }
2105
2106                 if (!found) {
2107                     if(! opt_programid) {
2108                         /* try again and reuse existing stream */
2109                         for(j=0;j<nb_istreams;j++) {
2110                             ist = ist_table[j];
2111                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2112                                 && ist->st->discard != AVDISCARD_ALL) {
2113                                 ost->source_index = j;
2114                                 found = 1;
2115                             }
2116                         }
2117                     }
2118                     if (!found) {
2119                         int i= ost->file_index;
2120                         dump_format(output_files[i], i, output_files[i]->filename, 1);
2121                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2122                                 ost->file_index, ost->index);
2123                         ffmpeg_exit(1);
2124                     }
2125                 }
2126             }
2127             ist = ist_table[ost->source_index];
2128             ist->discard = 0;
2129             ost->sync_ist = (nb_stream_maps > 0) ?
2130                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2131                          stream_maps[n].sync_stream_index] : ist;
2132         }
2133     }
2134
2135     /* for each output stream, we compute the right encoding parameters */
2136     for(i=0;i<nb_ostreams;i++) {
2137         AVMetadataTag *t = NULL;
2138         ost = ost_table[i];
2139         os = output_files[ost->file_index];
2140         ist = ist_table[ost->source_index];
2141
2142         codec = ost->st->codec;
2143         icodec = ist->st->codec;
2144
2145         while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2146             av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2147         }
2148
2149         ost->st->disposition = ist->st->disposition;
2150         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2151         codec->chroma_sample_location = icodec->chroma_sample_location;
2152
2153         if (ost->st->stream_copy) {
2154             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2155
2156             if (extra_size > INT_MAX)
2157                 goto fail;
2158
2159             /* if stream_copy is selected, no need to decode or encode */
2160             codec->codec_id = icodec->codec_id;
2161             codec->codec_type = icodec->codec_type;
2162
2163             if(!codec->codec_tag){
2164                 if(   !os->oformat->codec_tag
2165                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2166                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2167                     codec->codec_tag = icodec->codec_tag;
2168             }
2169
2170             codec->bit_rate = icodec->bit_rate;
2171             codec->extradata= av_mallocz(extra_size);
2172             if (!codec->extradata)
2173                 goto fail;
2174             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2175             codec->extradata_size= icodec->extradata_size;
2176             if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
2177                 codec->time_base = icodec->time_base;
2178                 codec->time_base.num *= icodec->ticks_per_frame;
2179                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2180                           codec->time_base.num, codec->time_base.den, INT_MAX);
2181             }else
2182                 codec->time_base = ist->st->time_base;
2183             switch(codec->codec_type) {
2184             case AVMEDIA_TYPE_AUDIO:
2185                 if(audio_volume != 256) {
2186                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2187                     ffmpeg_exit(1);
2188                 }
2189                 codec->channel_layout = icodec->channel_layout;
2190                 codec->sample_rate = icodec->sample_rate;
2191                 codec->channels = icodec->channels;
2192                 codec->frame_size = icodec->frame_size;
2193                 codec->block_align= icodec->block_align;
2194                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2195                     codec->block_align= 0;
2196                 if(codec->codec_id == CODEC_ID_AC3)
2197                     codec->block_align= 0;
2198                 break;
2199             case AVMEDIA_TYPE_VIDEO:
2200                 codec->pix_fmt = icodec->pix_fmt;
2201                 codec->width = icodec->width;
2202                 codec->height = icodec->height;
2203                 codec->has_b_frames = icodec->has_b_frames;
2204                 break;
2205             case AVMEDIA_TYPE_SUBTITLE:
2206                 codec->width = icodec->width;
2207                 codec->height = icodec->height;
2208                 break;
2209             default:
2210                 abort();
2211             }
2212         } else {
2213             switch(codec->codec_type) {
2214             case AVMEDIA_TYPE_AUDIO:
2215                 ost->fifo= av_fifo_alloc(1024);
2216                 if(!ost->fifo)
2217                     goto fail;
2218                 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2219                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2220                 icodec->request_channels = codec->channels;
2221                 ist->decoding_needed = 1;
2222                 ost->encoding_needed = 1;
2223                 break;
2224             case AVMEDIA_TYPE_VIDEO:
2225                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2226                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2227                     ffmpeg_exit(1);
2228                 }
2229                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2230                 ost->video_resample = ((codec->width != icodec->width -
2231                                 (frame_leftBand + frame_rightBand)) ||
2232                         (codec->height != icodec->height -
2233                                 (frame_topBand  + frame_bottomBand)) ||
2234                         (codec->pix_fmt != icodec->pix_fmt));
2235                 if (ost->video_crop) {
2236                     ost->topBand    = ost->original_topBand    = frame_topBand;
2237                     ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2238                     ost->leftBand   = ost->original_leftBand   = frame_leftBand;
2239                     ost->rightBand  = ost->original_rightBand  = frame_rightBand;
2240                 }
2241                 if (ost->video_resample) {
2242                     avcodec_get_frame_defaults(&ost->pict_tmp);
2243                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2244                                          codec->width, codec->height)) {
2245                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2246                         ffmpeg_exit(1);
2247                     }
2248                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2249                     ost->img_resample_ctx = sws_getContext(
2250                             icodec->width - (frame_leftBand + frame_rightBand),
2251                             icodec->height - (frame_topBand + frame_bottomBand),
2252                             icodec->pix_fmt,
2253                             codec->width,
2254                             codec->height,
2255                             codec->pix_fmt,
2256                             sws_flags, NULL, NULL, NULL);
2257                     if (ost->img_resample_ctx == NULL) {
2258                         fprintf(stderr, "Cannot get resampling context\n");
2259                         ffmpeg_exit(1);
2260                     }
2261
2262 #if !CONFIG_AVFILTER
2263                     ost->original_height = icodec->height;
2264                     ost->original_width  = icodec->width;
2265 #endif
2266                     codec->bits_per_raw_sample= 0;
2267                 }
2268                 ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
2269                 ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
2270                 ost->resample_pix_fmt= icodec->pix_fmt;
2271                 ost->encoding_needed = 1;
2272                 ist->decoding_needed = 1;
2273
2274 #if CONFIG_AVFILTER
2275                 if (configure_filters(ist, ost)) {
2276                     fprintf(stderr, "Error opening filters!\n");
2277                     exit(1);
2278                 }
2279 #endif
2280                 break;
2281             case AVMEDIA_TYPE_SUBTITLE:
2282                 ost->encoding_needed = 1;
2283                 ist->decoding_needed = 1;
2284                 break;
2285             default:
2286                 abort();
2287                 break;
2288             }
2289             /* two pass mode */
2290             if (ost->encoding_needed &&
2291                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2292                 char logfilename[1024];
2293                 FILE *f;
2294
2295                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2296                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2297                          i);
2298                 if (codec->flags & CODEC_FLAG_PASS1) {
2299                     f = fopen(logfilename, "wb");
2300                     if (!f) {
2301                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2302                         ffmpeg_exit(1);
2303                     }
2304                     ost->logfile = f;
2305                 } else {
2306                     char  *logbuffer;
2307                     size_t logbuffer_size;
2308                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2309                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2310                         ffmpeg_exit(1);
2311                     }
2312                     codec->stats_in = logbuffer;
2313                 }
2314             }
2315         }
2316         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2317             int size= codec->width * codec->height;
2318             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2319         }
2320     }
2321
2322     if (!bit_buffer)
2323         bit_buffer = av_malloc(bit_buffer_size);
2324     if (!bit_buffer) {
2325         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2326                 bit_buffer_size);
2327         ret = AVERROR(ENOMEM);
2328         goto fail;
2329     }
2330
2331     /* open each encoder */
2332     for(i=0;i<nb_ostreams;i++) {
2333         ost = ost_table[i];
2334         if (ost->encoding_needed) {
2335             AVCodec *codec = output_codecs[i];
2336             if (!codec)
2337                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2338             if (!codec) {
2339                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2340                          ost->st->codec->codec_id, ost->file_index, ost->index);
2341                 ret = AVERROR(EINVAL);
2342                 goto dump_format;
2343             }
2344             if (avcodec_open(ost->st->codec, codec) < 0) {
2345                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2346                         ost->file_index, ost->index);
2347                 ret = AVERROR(EINVAL);
2348                 goto dump_format;
2349             }
2350             extra_size += ost->st->codec->extradata_size;
2351         }
2352     }
2353
2354     /* open each decoder */
2355     for(i=0;i<nb_istreams;i++) {
2356         ist = ist_table[i];
2357         if (ist->decoding_needed) {
2358             AVCodec *codec = input_codecs[i];
2359             if (!codec)
2360                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2361             if (!codec) {
2362                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2363                         ist->st->codec->codec_id, ist->file_index, ist->index);
2364                 ret = AVERROR(EINVAL);
2365                 goto dump_format;
2366             }
2367             if (avcodec_open(ist->st->codec, codec) < 0) {
2368                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2369                         ist->file_index, ist->index);
2370                 ret = AVERROR(EINVAL);
2371                 goto dump_format;
2372             }
2373             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2374             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2375         }
2376     }
2377
2378     /* init pts */
2379     for(i=0;i<nb_istreams;i++) {
2380         AVStream *st;
2381         ist = ist_table[i];
2382         st= ist->st;
2383         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2384         ist->next_pts = AV_NOPTS_VALUE;
2385         ist->is_start = 1;
2386     }
2387
2388     /* set meta data information from input file if required */
2389     for (i=0;i<nb_meta_data_maps;i++) {
2390         AVFormatContext *out_file;
2391         AVFormatContext *in_file;
2392         AVMetadataTag *mtag;
2393
2394         int out_file_index = meta_data_maps[i].out_file;
2395         int in_file_index = meta_data_maps[i].in_file;
2396         if (out_file_index < 0 || out_file_index >= nb_output_files) {
2397             snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2398                      out_file_index, out_file_index, in_file_index);
2399             ret = AVERROR(EINVAL);
2400             goto dump_format;
2401         }
2402         if (in_file_index < 0 || in_file_index >= nb_input_files) {
2403             snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2404                      in_file_index, out_file_index, in_file_index);
2405             ret = AVERROR(EINVAL);
2406             goto dump_format;
2407         }
2408
2409         out_file = output_files[out_file_index];
2410         in_file = input_files[in_file_index];
2411
2412
2413         mtag=NULL;
2414         while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2415             av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2416         av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2417                                     in_file->iformat->metadata_conv);
2418     }
2419
2420     /* copy chapters from the first input file that has them*/
2421     for (i = 0; i < nb_input_files; i++) {
2422         if (!input_files[i]->nb_chapters)
2423             continue;
2424
2425         for (j = 0; j < nb_output_files; j++)
2426             if ((ret = copy_chapters(i, j)) < 0)
2427                 goto dump_format;
2428     }
2429
2430     /* open files and write file headers */
2431     for(i=0;i<nb_output_files;i++) {
2432         os = output_files[i];
2433         if (av_write_header(os) < 0) {
2434             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2435             ret = AVERROR(EINVAL);
2436             goto dump_format;
2437         }
2438         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2439             want_sdp = 0;
2440         }
2441     }
2442
2443  dump_format:
2444     /* dump the file output parameters - cannot be done before in case
2445        of stream copy */
2446     for(i=0;i<nb_output_files;i++) {
2447         dump_format(output_files[i], i, output_files[i]->filename, 1);
2448     }
2449
2450     /* dump the stream mapping */
2451     if (verbose >= 0) {
2452         fprintf(stderr, "Stream mapping:\n");
2453         for(i=0;i<nb_ostreams;i++) {
2454             ost = ost_table[i];
2455             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2456                     ist_table[ost->source_index]->file_index,
2457                     ist_table[ost->source_index]->index,
2458                     ost->file_index,
2459                     ost->index);
2460             if (ost->sync_ist != ist_table[ost->source_index])
2461                 fprintf(stderr, " [sync #%d.%d]",
2462                         ost->sync_ist->file_index,
2463                         ost->sync_ist->index);
2464             fprintf(stderr, "\n");
2465         }
2466     }
2467
2468     if (ret) {
2469         fprintf(stderr, "%s\n", error);
2470         goto fail;
2471     }
2472
2473     if (want_sdp) {
2474         print_sdp(output_files, nb_output_files);
2475     }
2476
2477     if (!using_stdin && verbose >= 0) {
2478         fprintf(stderr, "Press [q] to stop encoding\n");
2479         url_set_interrupt_cb(decode_interrupt_cb);
2480     }
2481     term_init();
2482
2483     timer_start = av_gettime();
2484
2485     for(; received_sigterm == 0;) {
2486         int file_index, ist_index;
2487         AVPacket pkt;
2488         double ipts_min;
2489         double opts_min;
2490
2491     redo:
2492         ipts_min= 1e100;
2493         opts_min= 1e100;
2494         /* if 'q' pressed, exits */
2495         if (!using_stdin) {
2496             if (q_pressed)
2497                 break;
2498             /* read_key() returns 0 on EOF */
2499             key = read_key();
2500             if (key == 'q')
2501                 break;
2502         }
2503
2504         /* select the stream that we must read now by looking at the
2505            smallest output pts */
2506         file_index = -1;
2507         for(i=0;i<nb_ostreams;i++) {
2508             double ipts, opts;
2509             ost = ost_table[i];
2510             os = output_files[ost->file_index];
2511             ist = ist_table[ost->source_index];
2512             if(ist->is_past_recording_time || no_packet[ist->file_index])
2513                 continue;
2514                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2515             ipts = (double)ist->pts;
2516             if (!file_table[ist->file_index].eof_reached){
2517                 if(ipts < ipts_min) {
2518                     ipts_min = ipts;
2519                     if(input_sync ) file_index = ist->file_index;
2520                 }
2521                 if(opts < opts_min) {
2522                     opts_min = opts;
2523                     if(!input_sync) file_index = ist->file_index;
2524                 }
2525             }
2526             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2527                 file_index= -1;
2528                 break;
2529             }
2530         }
2531         /* if none, if is finished */
2532         if (file_index < 0) {
2533             if(no_packet_count){
2534                 no_packet_count=0;
2535                 memset(no_packet, 0, sizeof(no_packet));
2536                 usleep(10000);
2537                 continue;
2538             }
2539             break;
2540         }
2541
2542         /* finish if limit size exhausted */
2543         if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2544             break;
2545
2546         /* read a frame from it and output it in the fifo */
2547         is = input_files[file_index];
2548         ret= av_read_frame(is, &pkt);
2549         if(ret == AVERROR(EAGAIN)){
2550             no_packet[file_index]=1;
2551             no_packet_count++;
2552             continue;
2553         }
2554         if (ret < 0) {
2555             file_table[file_index].eof_reached = 1;
2556             if (opt_shortest)
2557                 break;
2558             else
2559                 continue;
2560         }
2561
2562         no_packet_count=0;
2563         memset(no_packet, 0, sizeof(no_packet));
2564
2565         if (do_pkt_dump) {
2566             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2567         }
2568         /* the following test is needed in case new streams appear
2569            dynamically in stream : we ignore them */
2570         if (pkt.stream_index >= file_table[file_index].nb_streams)
2571             goto discard_packet;
2572         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2573         ist = ist_table[ist_index];
2574         if (ist->discard)
2575             goto discard_packet;
2576
2577         if (pkt.dts != AV_NOPTS_VALUE)
2578             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2579         if (pkt.pts != AV_NOPTS_VALUE)
2580             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2581
2582         if(input_files_ts_scale[file_index][pkt.stream_index]){
2583             if(pkt.pts != AV_NOPTS_VALUE)
2584                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2585             if(pkt.dts != AV_NOPTS_VALUE)
2586                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2587         }
2588
2589 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2590         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2591             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2592             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2593             int64_t delta= pkt_dts - ist->next_pts;
2594             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2595                 input_files_ts_offset[ist->file_index]-= delta;
2596                 if (verbose > 2)
2597                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2598                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2599                 if(pkt.pts != AV_NOPTS_VALUE)
2600                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2601             }
2602         }
2603
2604         /* finish if recording time exhausted */
2605         if (recording_time != INT64_MAX &&
2606             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2607             ist->is_past_recording_time = 1;
2608             goto discard_packet;
2609         }
2610
2611         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2612         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2613
2614             if (verbose >= 0)
2615                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2616                         ist->file_index, ist->index);
2617             if (exit_on_error)
2618                 ffmpeg_exit(1);
2619             av_free_packet(&pkt);
2620             goto redo;
2621         }
2622
2623     discard_packet:
2624         av_free_packet(&pkt);
2625
2626         /* dump report by using the output first video and audio streams */
2627         print_report(output_files, ost_table, nb_ostreams, 0);
2628     }
2629
2630     /* at the end of stream, we must flush the decoder buffers */
2631     for(i=0;i<nb_istreams;i++) {
2632         ist = ist_table[i];
2633         if (ist->decoding_needed) {
2634             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2635         }
2636     }
2637
2638     term_exit();
2639
2640     /* write the trailer if needed and close file */
2641     for(i=0;i<nb_output_files;i++) {
2642         os = output_files[i];
2643         av_write_trailer(os);
2644     }
2645
2646     /* dump report by using the first video and audio streams */
2647     print_report(output_files, ost_table, nb_ostreams, 1);
2648
2649     /* close each encoder */
2650     for(i=0;i<nb_ostreams;i++) {
2651         ost = ost_table[i];
2652         if (ost->encoding_needed) {
2653             av_freep(&ost->st->codec->stats_in);
2654             avcodec_close(ost->st->codec);
2655         }
2656     }
2657
2658     /* close each decoder */
2659     for(i=0;i<nb_istreams;i++) {
2660         ist = ist_table[i];
2661         if (ist->decoding_needed) {
2662             avcodec_close(ist->st->codec);
2663         }
2664     }
2665 #if CONFIG_AVFILTER
2666     if (graph) {
2667         avfilter_graph_destroy(graph);
2668         av_freep(&graph);
2669     }
2670 #endif
2671
2672     /* finished ! */
2673     ret = 0;
2674
2675  fail:
2676     av_freep(&bit_buffer);
2677     av_free(file_table);
2678
2679     if (ist_table) {
2680         for(i=0;i<nb_istreams;i++) {
2681             ist = ist_table[i];
2682             av_free(ist);
2683         }
2684         av_free(ist_table);
2685     }
2686     if (ost_table) {
2687         for(i=0;i<nb_ostreams;i++) {
2688             ost = ost_table[i];
2689             if (ost) {
2690                 if (ost->st->stream_copy)
2691                     av_freep(&ost->st->codec->extradata);
2692                 if (ost->logfile) {
2693                     fclose(ost->logfile);
2694                     ost->logfile = NULL;
2695                 }
2696                 av_fifo_free(ost->fifo); /* works even if fifo is not
2697                                              initialized but set to zero */
2698                 av_free(ost->pict_tmp.data[0]);
2699                 if (ost->video_resample)
2700                     sws_freeContext(ost->img_resample_ctx);
2701                 if (ost->resample)
2702                     audio_resample_close(ost->resample);
2703                 if (ost->reformat_ctx)
2704                     av_audio_convert_free(ost->reformat_ctx);
2705                 av_free(ost);
2706             }
2707         }
2708         av_free(ost_table);
2709     }
2710     return ret;
2711 }
2712
2713 static void opt_format(const char *arg)
2714 {
2715     /* compatibility stuff for pgmyuv */
2716     if (!strcmp(arg, "pgmyuv")) {
2717         pgmyuv_compatibility_hack=1;
2718 //        opt_image_format(arg);
2719         arg = "image2";
2720         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2721     }
2722
2723     last_asked_format = arg;
2724 }
2725
2726 static void opt_video_rc_override_string(const char *arg)
2727 {
2728     video_rc_override_string = arg;
2729 }
2730
2731 static int opt_me_threshold(const char *opt, const char *arg)
2732 {
2733     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2734     return 0;
2735 }
2736
2737 static int opt_verbose(const char *opt, const char *arg)
2738 {
2739     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2740     return 0;
2741 }
2742
2743 static int opt_frame_rate(const char *opt, const char *arg)
2744 {
2745     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2746         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2747         ffmpeg_exit(1);
2748     }
2749     return 0;
2750 }
2751
2752 static int opt_bitrate(const char *opt, const char *arg)
2753 {
2754     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2755
2756     opt_default(opt, arg);
2757
2758     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2759         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2760
2761     return 0;
2762 }
2763
2764 static void opt_frame_crop_top(const char *arg)
2765 {
2766     frame_topBand = atoi(arg);
2767     if (frame_topBand < 0) {
2768         fprintf(stderr, "Incorrect top crop size\n");
2769         ffmpeg_exit(1);
2770     }
2771     if ((frame_topBand) >= frame_height){
2772         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2773         ffmpeg_exit(1);
2774     }
2775     fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2776     frame_height -= frame_topBand;
2777 }
2778
2779 static void opt_frame_crop_bottom(const char *arg)
2780 {
2781     frame_bottomBand = atoi(arg);
2782     if (frame_bottomBand < 0) {
2783         fprintf(stderr, "Incorrect bottom crop size\n");
2784         ffmpeg_exit(1);
2785     }
2786     if ((frame_bottomBand) >= frame_height){
2787         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2788         ffmpeg_exit(1);
2789     }
2790     fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2791     frame_height -= frame_bottomBand;
2792 }
2793
2794 static void opt_frame_crop_left(const char *arg)
2795 {
2796     frame_leftBand = atoi(arg);
2797     if (frame_leftBand < 0) {
2798         fprintf(stderr, "Incorrect left crop size\n");
2799         ffmpeg_exit(1);
2800     }
2801     if ((frame_leftBand) >= frame_width){
2802         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2803         ffmpeg_exit(1);
2804     }
2805     fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2806     frame_width -= frame_leftBand;
2807 }
2808
2809 static void opt_frame_crop_right(const char *arg)
2810 {
2811     frame_rightBand = atoi(arg);
2812     if (frame_rightBand < 0) {
2813         fprintf(stderr, "Incorrect right crop size\n");
2814         ffmpeg_exit(1);
2815     }
2816     if ((frame_rightBand) >= frame_width){
2817         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2818         ffmpeg_exit(1);
2819     }
2820     fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
2821     frame_width -= frame_rightBand;
2822 }
2823
2824 static void opt_frame_size(const char *arg)
2825 {
2826     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2827         fprintf(stderr, "Incorrect frame size\n");
2828         ffmpeg_exit(1);
2829     }
2830 }
2831
2832 static int opt_pad(const char *opt, const char *arg) {
2833     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2834     return -1;
2835 }
2836
2837 static void opt_frame_pix_fmt(const char *arg)
2838 {
2839     if (strcmp(arg, "list")) {
2840         frame_pix_fmt = av_get_pix_fmt(arg);
2841         if (frame_pix_fmt == PIX_FMT_NONE) {
2842             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2843             ffmpeg_exit(1);
2844         }
2845     } else {
2846         show_pix_fmts();
2847         ffmpeg_exit(0);
2848     }
2849 }
2850
2851 static void opt_frame_aspect_ratio(const char *arg)
2852 {
2853     int x = 0, y = 0;
2854     double ar = 0;
2855     const char *p;
2856     char *end;
2857
2858     p = strchr(arg, ':');
2859     if (p) {
2860         x = strtol(arg, &end, 10);
2861         if (end == p)
2862             y = strtol(end+1, &end, 10);
2863         if (x > 0 && y > 0)
2864             ar = (double)x / (double)y;
2865     } else
2866         ar = strtod(arg, NULL);
2867
2868     if (!ar) {
2869         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2870         ffmpeg_exit(1);
2871     }
2872     frame_aspect_ratio = ar;
2873 }
2874
2875 static int opt_metadata(const char *opt, const char *arg)
2876 {
2877     char *mid= strchr(arg, '=');
2878
2879     if(!mid){
2880         fprintf(stderr, "Missing =\n");
2881         ffmpeg_exit(1);
2882     }
2883     *mid++= 0;
2884
2885     metadata_count++;
2886     metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2887     metadata[metadata_count-1].key  = av_strdup(arg);
2888     metadata[metadata_count-1].value= av_strdup(mid);
2889
2890     return 0;
2891 }
2892
2893 static void opt_qscale(const char *arg)
2894 {
2895     video_qscale = atof(arg);
2896     if (video_qscale <= 0 ||
2897         video_qscale > 255) {
2898         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2899         ffmpeg_exit(1);
2900     }
2901 }
2902
2903 static void opt_top_field_first(const char *arg)
2904 {
2905     top_field_first= atoi(arg);
2906 }
2907
2908 static int opt_thread_count(const char *opt, const char *arg)
2909 {
2910     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2911 #if !HAVE_THREADS
2912     if (verbose >= 0)
2913         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2914 #endif
2915     return 0;
2916 }
2917
2918 static void opt_audio_sample_fmt(const char *arg)
2919 {
2920     if (strcmp(arg, "list"))
2921         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2922     else {
2923         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2924         ffmpeg_exit(0);
2925     }
2926 }
2927
2928 static int opt_audio_rate(const char *opt, const char *arg)
2929 {
2930     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2931     return 0;
2932 }
2933
2934 static int opt_audio_channels(const char *opt, const char *arg)
2935 {
2936     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2937     return 0;
2938 }
2939
2940 static void opt_video_channel(const char *arg)
2941 {
2942     video_channel = strtol(arg, NULL, 0);
2943 }
2944
2945 static void opt_video_standard(const char *arg)
2946 {
2947     video_standard = av_strdup(arg);
2948 }
2949
2950 static void opt_codec(int *pstream_copy, char **pcodec_name,
2951                       int codec_type, const char *arg)
2952 {
2953     av_freep(pcodec_name);
2954     if (!strcmp(arg, "copy")) {
2955         *pstream_copy = 1;
2956     } else {
2957         *pcodec_name = av_strdup(arg);
2958     }
2959 }
2960
2961 static void opt_audio_codec(const char *arg)
2962 {
2963     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2964 }
2965
2966 static void opt_audio_tag(const char *arg)
2967 {
2968     char *tail;
2969     audio_codec_tag= strtol(arg, &tail, 0);
2970
2971     if(!tail || *tail)
2972         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2973 }
2974
2975 static void opt_video_tag(const char *arg)
2976 {
2977     char *tail;
2978     video_codec_tag= strtol(arg, &tail, 0);
2979
2980     if(!tail || *tail)
2981         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2982 }
2983
2984 static void opt_video_codec(const char *arg)
2985 {
2986     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2987 }
2988
2989 static void opt_subtitle_codec(const char *arg)
2990 {
2991     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2992 }
2993
2994 static void opt_subtitle_tag(const char *arg)
2995 {
2996     char *tail;
2997     subtitle_codec_tag= strtol(arg, &tail, 0);
2998
2999     if(!tail || *tail)
3000         subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
3001 }
3002
3003 static void opt_map(const char *arg)
3004 {
3005     AVStreamMap *m;
3006     char *p;
3007
3008     m = &stream_maps[nb_stream_maps++];
3009
3010     m->file_index = strtol(arg, &p, 0);
3011     if (*p)
3012         p++;
3013
3014     m->stream_index = strtol(p, &p, 0);
3015     if (*p) {
3016         p++;
3017         m->sync_file_index = strtol(p, &p, 0);
3018         if (*p)
3019             p++;
3020         m->sync_stream_index = strtol(p, &p, 0);
3021     } else {
3022         m->sync_file_index = m->file_index;
3023         m->sync_stream_index = m->stream_index;
3024     }
3025 }
3026
3027 static void opt_map_meta_data(const char *arg)
3028 {
3029     AVMetaDataMap *m;
3030     char *p;
3031
3032     m = &meta_data_maps[nb_meta_data_maps++];
3033
3034     m->out_file = strtol(arg, &p, 0);
3035     if (*p)
3036         p++;
3037
3038     m->in_file = strtol(p, &p, 0);
3039 }
3040
3041 static void opt_input_ts_scale(const char *arg)
3042 {
3043     unsigned int stream;
3044     double scale;
3045     char *p;
3046
3047     stream = strtol(arg, &p, 0);
3048     if (*p)
3049         p++;
3050     scale= strtod(p, &p);
3051
3052     if(stream >= MAX_STREAMS)
3053         ffmpeg_exit(1);
3054
3055     input_files_ts_scale[nb_input_files][stream]= scale;
3056 }
3057
3058 static int opt_recording_time(const char *opt, const char *arg)
3059 {
3060     recording_time = parse_time_or_die(opt, arg, 1);
3061     return 0;
3062 }
3063
3064 static int opt_start_time(const char *opt, const char *arg)
3065 {
3066     start_time = parse_time_or_die(opt, arg, 1);
3067     return 0;
3068 }
3069
3070 static int opt_recording_timestamp(const char *opt, const char *arg)
3071 {
3072     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3073     return 0;
3074 }
3075
3076 static int opt_input_ts_offset(const char *opt, const char *arg)
3077 {
3078     input_ts_offset = parse_time_or_die(opt, arg, 1);
3079     return 0;
3080 }
3081
3082 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3083 {
3084     const char *codec_string = encoder ? "encoder" : "decoder";
3085     AVCodec *codec;
3086
3087     if(!name)
3088         return CODEC_ID_NONE;
3089     codec = encoder ?
3090         avcodec_find_encoder_by_name(name) :
3091         avcodec_find_decoder_by_name(name);
3092     if(!codec) {
3093         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3094         ffmpeg_exit(1);
3095     }
3096     if(codec->type != type) {
3097         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3098         ffmpeg_exit(1);
3099     }
3100     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3101        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3102         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3103                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3104                 codec_string, codec->name);
3105         codec = encoder ?
3106             avcodec_find_encoder(codec->id) :
3107             avcodec_find_decoder(codec->id);
3108         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3109             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3110                     codec_string, codec->name);
3111         ffmpeg_exit(1);
3112     }
3113     return codec->id;
3114 }
3115
3116 static void opt_input_file(const char *filename)
3117 {
3118     AVFormatContext *ic;
3119     AVFormatParameters params, *ap = &params;
3120     AVInputFormat *file_iformat = NULL;
3121     int err, i, ret, rfps, rfps_base;
3122     int64_t timestamp;
3123
3124     if (last_asked_format) {
3125         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3126             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3127             ffmpeg_exit(1);
3128         }
3129         last_asked_format = NULL;
3130     }
3131
3132     if (!strcmp(filename, "-"))
3133         filename = "pipe:";
3134
3135     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3136                     !strcmp(filename, "/dev/stdin");
3137
3138     /* get default parameters from command line */
3139     ic = avformat_alloc_context();
3140     if (!ic) {
3141         print_error(filename, AVERROR(ENOMEM));
3142         ffmpeg_exit(1);
3143     }
3144
3145     memset(ap, 0, sizeof(*ap));
3146     ap->prealloced_context = 1;
3147     ap->sample_rate = audio_sample_rate;
3148     ap->channels = audio_channels;
3149     ap->time_base.den = frame_rate.num;
3150     ap->time_base.num = frame_rate.den;
3151     ap->width = frame_width;
3152     ap->height = frame_height;
3153     ap->pix_fmt = frame_pix_fmt;
3154    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3155     ap->channel = video_channel;
3156     ap->standard = video_standard;
3157
3158     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
3159
3160     ic->video_codec_id   =
3161         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3162                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3163     ic->audio_codec_id   =
3164         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3165                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3166     ic->subtitle_codec_id=
3167         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3168                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3169     ic->flags |= AVFMT_FLAG_NONBLOCK;
3170
3171     if(pgmyuv_compatibility_hack)
3172         ic->video_codec_id= CODEC_ID_PGMYUV;
3173
3174     /* open the input file with generic libav function */
3175     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3176     if (err < 0) {
3177         print_error(filename, err);
3178         ffmpeg_exit(1);
3179     }
3180     if(opt_programid) {
3181         int i, j;
3182         int found=0;
3183         for(i=0; i<ic->nb_streams; i++){
3184             ic->streams[i]->discard= AVDISCARD_ALL;
3185         }
3186         for(i=0; i<ic->nb_programs; i++){
3187             AVProgram *p= ic->programs[i];
3188             if(p->id != opt_programid){
3189                 p->discard = AVDISCARD_ALL;
3190             }else{
3191                 found=1;
3192                 for(j=0; j<p->nb_stream_indexes; j++){
3193                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3194                 }
3195             }
3196         }
3197         if(!found){
3198             fprintf(stderr, "Specified program id not found\n");
3199             ffmpeg_exit(1);
3200         }
3201         opt_programid=0;
3202     }
3203
3204     ic->loop_input = loop_input;
3205
3206     /* If not enough info to get the stream parameters, we decode the
3207        first frames to get it. (used in mpeg case for example) */
3208     ret = av_find_stream_info(ic);
3209     if (ret < 0 && verbose >= 0) {
3210         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3211         av_close_input_file(ic);
3212         ffmpeg_exit(1);
3213     }
3214
3215     timestamp = start_time;
3216     /* add the stream start time */
3217     if (ic->start_time != AV_NOPTS_VALUE)
3218         timestamp += ic->start_time;
3219
3220     /* if seeking requested, we execute it */
3221     if (start_time != 0) {
3222         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3223         if (ret < 0) {
3224             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3225                     filename, (double)timestamp / AV_TIME_BASE);
3226         }
3227         /* reset seek info */
3228         start_time = 0;
3229     }
3230
3231     /* update the current parameters so that they match the one of the input stream */
3232     for(i=0;i<ic->nb_streams;i++) {
3233         AVStream *st = ic->streams[i];
3234         AVCodecContext *dec = st->codec;
3235         avcodec_thread_init(dec, thread_count);
3236         switch (dec->codec_type) {
3237         case AVMEDIA_TYPE_AUDIO:
3238             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3239             //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3240             channel_layout    = dec->channel_layout;
3241             audio_channels    = dec->channels;
3242             audio_sample_rate = dec->sample_rate;
3243             audio_sample_fmt  = dec->sample_fmt;
3244             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3245             if(audio_disable)
3246                 st->discard= AVDISCARD_ALL;
3247             /* Note that av_find_stream_info can add more streams, and we
3248              * currently have no chance of setting up lowres decoding
3249              * early enough for them. */
3250             if (dec->lowres)
3251                 audio_sample_rate >>= dec->lowres;
3252             break;
3253         case AVMEDIA_TYPE_VIDEO:
3254             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3255             frame_height = dec->height;
3256             frame_width  = dec->width;
3257             if(ic->streams[i]->sample_aspect_ratio.num)
3258                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3259             else
3260                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3261             frame_aspect_ratio *= (float) dec->width / dec->height;
3262             frame_pix_fmt = dec->pix_fmt;
3263             rfps      = ic->streams[i]->r_frame_rate.num;
3264             rfps_base = ic->streams[i]->r_frame_rate.den;
3265             if (dec->lowres) {
3266                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3267                 frame_height >>= dec->lowres;
3268                 frame_width  >>= dec->lowres;
3269             }
3270             if(me_threshold)
3271                 dec->debug |= FF_DEBUG_MV;
3272
3273             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3274
3275                 if (verbose >= 0)
3276                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3277                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3278
3279                     (float)rfps / rfps_base, rfps, rfps_base);
3280             }
3281             /* update the current frame rate to match the stream frame rate */
3282             frame_rate.num = rfps;
3283             frame_rate.den = rfps_base;
3284
3285             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3286             if(video_disable)
3287                 st->discard= AVDISCARD_ALL;
3288             else if(video_discard)
3289                 st->discard= video_discard;
3290             break;
3291         case AVMEDIA_TYPE_DATA:
3292             break;
3293         case AVMEDIA_TYPE_SUBTITLE:
3294             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3295             if(subtitle_disable)
3296                 st->discard = AVDISCARD_ALL;
3297             break;
3298         case AVMEDIA_TYPE_ATTACHMENT:
3299         case AVMEDIA_TYPE_UNKNOWN:
3300             nb_icodecs++;
3301             break;
3302         default:
3303             abort();
3304         }
3305     }
3306
3307     input_files[nb_input_files] = ic;
3308     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3309     /* dump the file content */
3310     if (verbose >= 0)
3311         dump_format(ic, nb_input_files, filename, 0);
3312
3313     nb_input_files++;
3314
3315     video_channel = 0;
3316
3317     av_freep(&video_codec_name);
3318     av_freep(&audio_codec_name);
3319     av_freep(&subtitle_codec_name);
3320 }
3321
3322 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3323                                          int *has_subtitle_ptr)
3324 {
3325     int has_video, has_audio, has_subtitle, i, j;
3326     AVFormatContext *ic;
3327
3328     has_video = 0;
3329     has_audio = 0;
3330     has_subtitle = 0;
3331     for(j=0;j<nb_input_files;j++) {
3332         ic = input_files[j];
3333         for(i=0;i<ic->nb_streams;i++) {
3334             AVCodecContext *enc = ic->streams[i]->codec;
3335             switch(enc->codec_type) {
3336             case AVMEDIA_TYPE_AUDIO:
3337                 has_audio = 1;
3338                 break;
3339             case AVMEDIA_TYPE_VIDEO:
3340                 has_video = 1;
3341                 break;
3342             case AVMEDIA_TYPE_SUBTITLE:
3343                 has_subtitle = 1;
3344                 break;
3345             case AVMEDIA_TYPE_DATA:
3346             case AVMEDIA_TYPE_ATTACHMENT:
3347             case AVMEDIA_TYPE_UNKNOWN:
3348                 break;
3349             default:
3350                 abort();
3351             }
3352         }
3353     }
3354     *has_video_ptr = has_video;
3355     *has_audio_ptr = has_audio;
3356     *has_subtitle_ptr = has_subtitle;
3357 }
3358
3359 static void new_video_stream(AVFormatContext *oc)
3360 {
3361     AVStream *st;
3362     AVCodecContext *video_enc;
3363     enum CodecID codec_id;
3364
3365     st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3366     if (!st) {
3367         fprintf(stderr, "Could not alloc stream\n");
3368         ffmpeg_exit(1);
3369     }
3370     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3371     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3372     video_bitstream_filters= NULL;
3373
3374     avcodec_thread_init(st->codec, thread_count);
3375
3376     video_enc = st->codec;
3377
3378     if(video_codec_tag)
3379         video_enc->codec_tag= video_codec_tag;
3380
3381     if(   (video_global_header&1)
3382        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3383         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3384         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3385     }
3386     if(video_global_header&2){
3387         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3388         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3389     }
3390
3391     if (video_stream_copy) {
3392         st->stream_copy = 1;
3393         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3394         video_enc->sample_aspect_ratio =
3395         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3396     } else {
3397         const char *p;
3398         int i;
3399         AVCodec *codec;
3400         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3401
3402         if (video_codec_name) {
3403             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3404                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3405             codec = avcodec_find_encoder_by_name(video_codec_name);
3406             output_codecs[nb_ocodecs] = codec;
3407         } else {
3408             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3409             codec = avcodec_find_encoder(codec_id);
3410         }
3411
3412         video_enc->codec_id = codec_id;
3413
3414         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3415
3416         if (codec && codec->supported_framerates && !force_fps)
3417             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3418         video_enc->time_base.den = fps.num;
3419         video_enc->time_base.num = fps.den;
3420
3421         video_enc->width = frame_width;
3422         video_enc->height = frame_height;
3423         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3424         video_enc->pix_fmt = frame_pix_fmt;
3425         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3426
3427         choose_pixel_fmt(st, codec);
3428
3429         if (intra_only)
3430             video_enc->gop_size = 0;
3431         if (video_qscale || same_quality) {
3432             video_enc->flags |= CODEC_FLAG_QSCALE;
3433             video_enc->global_quality=
3434                 st->quality = FF_QP2LAMBDA * video_qscale;
3435         }
3436
3437         if(intra_matrix)
3438             video_enc->intra_matrix = intra_matrix;
3439         if(inter_matrix)
3440             video_enc->inter_matrix = inter_matrix;
3441
3442         p= video_rc_override_string;
3443         for(i=0; p; i++){
3444             int start, end, q;
3445             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3446             if(e!=3){
3447                 fprintf(stderr, "error parsing rc_override\n");
3448                 ffmpeg_exit(1);
3449             }
3450             video_enc->rc_override=
3451                 av_realloc(video_enc->rc_override,
3452                            sizeof(RcOverride)*(i+1));
3453             video_enc->rc_override[i].start_frame= start;
3454             video_enc->rc_override[i].end_frame  = end;
3455             if(q>0){
3456                 video_enc->rc_override[i].qscale= q;
3457                 video_enc->rc_override[i].quality_factor= 1.0;
3458             }
3459             else{
3460                 video_enc->rc_override[i].qscale= 0;
3461                 video_enc->rc_override[i].quality_factor= -q/100.0;
3462             }
3463             p= strchr(p, '/');
3464             if(p) p++;
3465         }
3466         video_enc->rc_override_count=i;
3467         if (!video_enc->rc_initial_buffer_occupancy)
3468             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3469         video_enc->me_threshold= me_threshold;
3470         video_enc->intra_dc_precision= intra_dc_precision - 8;
3471
3472         if (do_psnr)
3473             video_enc->flags|= CODEC_FLAG_PSNR;
3474
3475         /* two pass mode */
3476         if (do_pass) {
3477             if (do_pass == 1) {
3478                 video_enc->flags |= CODEC_FLAG_PASS1;
3479             } else {
3480                 video_enc->flags |= CODEC_FLAG_PASS2;
3481             }
3482         }
3483     }
3484     nb_ocodecs++;
3485     if (video_language) {
3486         av_metadata_set2(&st->metadata, "language", video_language, 0);
3487         av_freep(&video_language);
3488     }
3489
3490     /* reset some key parameters */
3491     video_disable = 0;
3492     av_freep(&video_codec_name);
3493     video_stream_copy = 0;
3494     frame_pix_fmt = PIX_FMT_NONE;
3495 }
3496
3497 static void new_audio_stream(AVFormatContext *oc)
3498 {
3499     AVStream *st;
3500     AVCodecContext *audio_enc;
3501     enum CodecID codec_id;
3502
3503     st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3504     if (!st) {
3505         fprintf(stderr, "Could not alloc stream\n");
3506         ffmpeg_exit(1);
3507     }
3508     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3509
3510     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3511     audio_bitstream_filters= NULL;
3512
3513     avcodec_thread_init(st->codec, thread_count);
3514
3515     audio_enc = st->codec;
3516     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3517
3518     if(audio_codec_tag)
3519         audio_enc->codec_tag= audio_codec_tag;
3520
3521     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3522         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3523         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3524     }
3525     if (audio_stream_copy) {
3526         st->stream_copy = 1;
3527         audio_enc->channels = audio_channels;
3528         audio_enc->sample_rate = audio_sample_rate;
3529     } else {
3530         AVCodec *codec;
3531
3532         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3533
3534         if (audio_codec_name) {
3535             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3536                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3537             codec = avcodec_find_encoder_by_name(audio_codec_name);
3538             output_codecs[nb_ocodecs] = codec;
3539         } else {
3540             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3541             codec = avcodec_find_encoder(codec_id);
3542         }
3543         audio_enc->codec_id = codec_id;
3544
3545         if (audio_qscale > QSCALE_NONE) {
3546             audio_enc->flags |= CODEC_FLAG_QSCALE;
3547             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3548         }
3549         audio_enc->channels = audio_channels;
3550         audio_enc->sample_fmt = audio_sample_fmt;
3551         audio_enc->sample_rate = audio_sample_rate;
3552         audio_enc->channel_layout = channel_layout;
3553         if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3554             audio_enc->channel_layout = 0;
3555         choose_sample_fmt(st, codec);
3556         choose_sample_rate(st, codec);
3557     }
3558     nb_ocodecs++;
3559     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3560     if (audio_language) {
3561         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3562         av_freep(&audio_language);
3563     }
3564
3565     /* reset some key parameters */
3566     audio_disable = 0;
3567     av_freep(&audio_codec_name);
3568     audio_stream_copy = 0;
3569 }
3570
3571 static void new_subtitle_stream(AVFormatContext *oc)
3572 {
3573     AVStream *st;
3574     AVCodecContext *subtitle_enc;
3575
3576     st = av_new_stream(oc, streamid_map[oc->nb_streams]);
3577     if (!st) {
3578         fprintf(stderr, "Could not alloc stream\n");
3579         ffmpeg_exit(1);
3580     }
3581     avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3582
3583     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3584     subtitle_bitstream_filters= NULL;
3585
3586     subtitle_enc = st->codec;
3587     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3588
3589     if(subtitle_codec_tag)
3590         subtitle_enc->codec_tag= subtitle_codec_tag;
3591
3592     if (subtitle_stream_copy) {
3593         st->stream_copy = 1;
3594     } else {
3595         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3596         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3597                                                    avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3598         output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3599     }
3600     nb_ocodecs++;
3601
3602     if (subtitle_language) {
3603         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3604         av_freep(&subtitle_language);
3605     }
3606
3607     subtitle_disable = 0;
3608     av_freep(&subtitle_codec_name);
3609     subtitle_stream_copy = 0;
3610 }
3611
3612 static void opt_new_stream(const char *opt, const char *arg)
3613 {
3614     AVFormatContext *oc;
3615     if (nb_output_files <= 0) {
3616         fprintf(stderr, "At least one output file must be specified\n");
3617         ffmpeg_exit(1);
3618     }
3619     oc = output_files[nb_output_files - 1];
3620
3621     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc);
3622     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc);
3623     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc);
3624     else assert(0);
3625 }
3626
3627 /* arg format is "output-stream-index:streamid-value". */
3628 static void opt_streamid(const char *opt, const char *arg)
3629 {
3630     int idx;
3631     char *p;
3632     char idx_str[16];
3633
3634     strncpy(idx_str, arg, sizeof(idx_str));
3635     idx_str[sizeof(idx_str)-1] = '\0';
3636     p = strchr(idx_str, ':');
3637     if (!p) {
3638         fprintf(stderr,
3639                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3640                 arg, opt);
3641         ffmpeg_exit(1);
3642     }
3643     *p++ = '\0';
3644     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3645     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3646 }
3647
3648 static void opt_output_file(const char *filename)
3649 {
3650     AVFormatContext *oc;
3651     int err, use_video, use_audio, use_subtitle;
3652     int input_has_video, input_has_audio, input_has_subtitle;
3653     AVFormatParameters params, *ap = &params;
3654     AVOutputFormat *file_oformat;
3655
3656     if (!strcmp(filename, "-"))
3657         filename = "pipe:";
3658
3659     oc = avformat_alloc_context();
3660     if (!oc) {
3661         print_error(filename, AVERROR(ENOMEM));
3662         ffmpeg_exit(1);
3663     }
3664
3665     if (last_asked_format) {
3666         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3667         if (!file_oformat) {
3668             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3669             ffmpeg_exit(1);
3670         }
3671         last_asked_format = NULL;
3672     } else {
3673         file_oformat = av_guess_format(NULL, filename, NULL);
3674         if (!file_oformat) {
3675             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3676                     filename);
3677             ffmpeg_exit(1);
3678         }
3679     }
3680
3681     oc->oformat = file_oformat;
3682     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3683
3684     if (!strcmp(file_oformat->name, "ffm") &&
3685         av_strstart(filename, "http:", NULL)) {
3686         /* special case for files sent to ffserver: we get the stream
3687            parameters from ffserver */