fic: Support rendering cursors
[ffmpeg.git] / avconv.c
1 /*
2  * avconv main
3  * Copyright (c) 2000-2011 The libav developers.
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "config.h"
23 #include <ctype.h>
24 #include <string.h>
25 #include <math.h>
26 #include <stdlib.h>
27 #include <errno.h>
28 #include <signal.h>
29 #include <limits.h>
30 #include <stdint.h>
31
32 #include "libavformat/avformat.h"
33 #include "libavdevice/avdevice.h"
34 #include "libswscale/swscale.h"
35 #include "libavresample/avresample.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/channel_layout.h"
38 #include "libavutil/parseutils.h"
39 #include "libavutil/samplefmt.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavutil/imgutils.h"
48 #include "libavutil/time.h"
49 #include "libavformat/os_support.h"
50
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/buffersrc.h"
53 # include "libavfilter/buffersink.h"
54
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/time.h>
57 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
60 #include <windows.h>
61 #endif
62 #if HAVE_GETPROCESSMEMORYINFO
63 #include <windows.h>
64 #include <psapi.h>
65 #endif
66
67 #if HAVE_SYS_SELECT_H
68 #include <sys/select.h>
69 #endif
70
71 #if HAVE_PTHREADS
72 #include <pthread.h>
73 #endif
74
75 #include <time.h>
76
77 #include "avconv.h"
78 #include "cmdutils.h"
79
80 #include "libavutil/avassert.h"
81
82 const char program_name[] = "avconv";
83 const int program_birth_year = 2000;
84
85 static FILE *vstats_file;
86
87 static int nb_frames_drop = 0;
88
89
90
91 #if HAVE_PTHREADS
92 /* signal to input threads that they should exit; set by the main thread */
93 static int transcoding_finished;
94 #endif
95
96 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
97
98 InputStream **input_streams = NULL;
99 int        nb_input_streams = 0;
100 InputFile   **input_files   = NULL;
101 int        nb_input_files   = 0;
102
103 OutputStream **output_streams = NULL;
104 int         nb_output_streams = 0;
105 OutputFile   **output_files   = NULL;
106 int         nb_output_files   = 0;
107
108 FilterGraph **filtergraphs;
109 int        nb_filtergraphs;
110
111 static void term_exit(void)
112 {
113     av_log(NULL, AV_LOG_QUIET, "");
114 }
115
116 static volatile int received_sigterm = 0;
117 static volatile int received_nb_signals = 0;
118
119 static void
120 sigterm_handler(int sig)
121 {
122     received_sigterm = sig;
123     received_nb_signals++;
124     term_exit();
125 }
126
127 static void term_init(void)
128 {
129     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
130     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
131 #ifdef SIGXCPU
132     signal(SIGXCPU, sigterm_handler);
133 #endif
134 }
135
136 static int decode_interrupt_cb(void *ctx)
137 {
138     return received_nb_signals > 1;
139 }
140
141 const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
142
143 static void avconv_cleanup(int ret)
144 {
145     int i, j;
146
147     for (i = 0; i < nb_filtergraphs; i++) {
148         avfilter_graph_free(&filtergraphs[i]->graph);
149         for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
150             av_freep(&filtergraphs[i]->inputs[j]->name);
151             av_freep(&filtergraphs[i]->inputs[j]);
152         }
153         av_freep(&filtergraphs[i]->inputs);
154         for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
155             av_freep(&filtergraphs[i]->outputs[j]->name);
156             av_freep(&filtergraphs[i]->outputs[j]);
157         }
158         av_freep(&filtergraphs[i]->outputs);
159         av_freep(&filtergraphs[i]->graph_desc);
160         av_freep(&filtergraphs[i]);
161     }
162     av_freep(&filtergraphs);
163
164     /* close files */
165     for (i = 0; i < nb_output_files; i++) {
166         AVFormatContext *s = output_files[i]->ctx;
167         if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE) && s->pb)
168             avio_close(s->pb);
169         avformat_free_context(s);
170         av_dict_free(&output_files[i]->opts);
171         av_freep(&output_files[i]);
172     }
173     for (i = 0; i < nb_output_streams; i++) {
174         AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
175         while (bsfc) {
176             AVBitStreamFilterContext *next = bsfc->next;
177             av_bitstream_filter_close(bsfc);
178             bsfc = next;
179         }
180         output_streams[i]->bitstream_filters = NULL;
181         av_frame_free(&output_streams[i]->filtered_frame);
182
183         av_parser_close(output_streams[i]->parser);
184
185         av_freep(&output_streams[i]->forced_keyframes);
186         av_freep(&output_streams[i]->avfilter);
187         av_freep(&output_streams[i]->logfile_prefix);
188         av_freep(&output_streams[i]);
189     }
190     for (i = 0; i < nb_input_files; i++) {
191         avformat_close_input(&input_files[i]->ctx);
192         av_freep(&input_files[i]);
193     }
194     for (i = 0; i < nb_input_streams; i++) {
195         av_frame_free(&input_streams[i]->decoded_frame);
196         av_frame_free(&input_streams[i]->filter_frame);
197         av_dict_free(&input_streams[i]->opts);
198         av_freep(&input_streams[i]->filters);
199         av_freep(&input_streams[i]->hwaccel_device);
200         av_freep(&input_streams[i]);
201     }
202
203     if (vstats_file)
204         fclose(vstats_file);
205     av_free(vstats_filename);
206
207     av_freep(&input_streams);
208     av_freep(&input_files);
209     av_freep(&output_streams);
210     av_freep(&output_files);
211
212     uninit_opts();
213
214     avformat_network_deinit();
215
216     if (received_sigterm) {
217         av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
218                (int) received_sigterm);
219         exit (255);
220     }
221 }
222
223 void assert_avoptions(AVDictionary *m)
224 {
225     AVDictionaryEntry *t;
226     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
227         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
228         exit_program(1);
229     }
230 }
231
232 static void abort_codec_experimental(AVCodec *c, int encoder)
233 {
234     const char *codec_string = encoder ? "encoder" : "decoder";
235     AVCodec *codec;
236     av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
237             "results.\nAdd '-strict experimental' if you want to use it.\n",
238             codec_string, c->name);
239     codec = encoder ? avcodec_find_encoder(c->id) : avcodec_find_decoder(c->id);
240     if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
241         av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
242                codec_string, codec->name);
243     exit_program(1);
244 }
245
246 /*
247  * Update the requested input sample format based on the output sample format.
248  * This is currently only used to request float output from decoders which
249  * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
250  * Ideally this will be removed in the future when decoders do not do format
251  * conversion and only output in their native format.
252  */
253 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
254                               AVCodecContext *enc)
255 {
256     /* if sample formats match or a decoder sample format has already been
257        requested, just return */
258     if (enc->sample_fmt == dec->sample_fmt ||
259         dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
260         return;
261
262     /* if decoder supports more than one output format */
263     if (dec_codec && dec_codec->sample_fmts &&
264         dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
265         dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
266         const enum AVSampleFormat *p;
267         int min_dec = INT_MAX, min_inc = INT_MAX;
268         enum AVSampleFormat dec_fmt = AV_SAMPLE_FMT_NONE;
269         enum AVSampleFormat inc_fmt = AV_SAMPLE_FMT_NONE;
270
271         /* find a matching sample format in the encoder */
272         for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
273             if (*p == enc->sample_fmt) {
274                 dec->request_sample_fmt = *p;
275                 return;
276             } else {
277                 enum AVSampleFormat dfmt = av_get_packed_sample_fmt(*p);
278                 enum AVSampleFormat efmt = av_get_packed_sample_fmt(enc->sample_fmt);
279                 int fmt_diff = 32 * abs(dfmt - efmt);
280                 if (av_sample_fmt_is_planar(*p) !=
281                     av_sample_fmt_is_planar(enc->sample_fmt))
282                     fmt_diff++;
283                 if (dfmt == efmt) {
284                     min_inc = fmt_diff;
285                     inc_fmt = *p;
286                 } else if (dfmt > efmt) {
287                     if (fmt_diff < min_inc) {
288                         min_inc = fmt_diff;
289                         inc_fmt = *p;
290                     }
291                 } else {
292                     if (fmt_diff < min_dec) {
293                         min_dec = fmt_diff;
294                         dec_fmt = *p;
295                     }
296                 }
297             }
298         }
299
300         /* if none match, provide the one that matches quality closest */
301         dec->request_sample_fmt = min_inc != INT_MAX ? inc_fmt : dec_fmt;
302     }
303 }
304
305 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
306 {
307     AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
308     AVCodecContext          *avctx = ost->st->codec;
309     int ret;
310
311     /*
312      * Audio encoders may split the packets --  #frames in != #packets out.
313      * But there is no reordering, so we can limit the number of output packets
314      * by simply dropping them here.
315      * Counting encoded video frames needs to be done separately because of
316      * reordering, see do_video_out()
317      */
318     if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
319         if (ost->frame_number >= ost->max_frames) {
320             av_free_packet(pkt);
321             return;
322         }
323         ost->frame_number++;
324     }
325
326     while (bsfc) {
327         AVPacket new_pkt = *pkt;
328         int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
329                                            &new_pkt.data, &new_pkt.size,
330                                            pkt->data, pkt->size,
331                                            pkt->flags & AV_PKT_FLAG_KEY);
332         if (a > 0) {
333             av_free_packet(pkt);
334             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
335                                            av_buffer_default_free, NULL, 0);
336             if (!new_pkt.buf)
337                 exit_program(1);
338         } else if (a < 0) {
339             av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
340                    bsfc->filter->name, pkt->stream_index,
341                    avctx->codec ? avctx->codec->name : "copy");
342             print_error("", a);
343             if (exit_on_error)
344                 exit_program(1);
345         }
346         *pkt = new_pkt;
347
348         bsfc = bsfc->next;
349     }
350
351     if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
352         ost->last_mux_dts != AV_NOPTS_VALUE &&
353         pkt->dts < ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT)) {
354         av_log(NULL, AV_LOG_WARNING, "Non-monotonous DTS in output stream "
355                "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
356                ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
357         if (exit_on_error) {
358             av_log(NULL, AV_LOG_FATAL, "aborting.\n");
359             exit_program(1);
360         }
361         av_log(NULL, AV_LOG_WARNING, "changing to %"PRId64". This may result "
362                "in incorrect timestamps in the output file.\n",
363                ost->last_mux_dts + 1);
364         pkt->dts = ost->last_mux_dts + 1;
365         if (pkt->pts != AV_NOPTS_VALUE)
366             pkt->pts = FFMAX(pkt->pts, pkt->dts);
367     }
368     ost->last_mux_dts = pkt->dts;
369
370     ost->data_size += pkt->size;
371     ost->packets_written++;
372
373     pkt->stream_index = ost->index;
374     ret = av_interleaved_write_frame(s, pkt);
375     if (ret < 0) {
376         print_error("av_interleaved_write_frame()", ret);
377         exit_program(1);
378     }
379 }
380
381 static int check_recording_time(OutputStream *ost)
382 {
383     OutputFile *of = output_files[ost->file_index];
384
385     if (of->recording_time != INT64_MAX &&
386         av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
387                       AV_TIME_BASE_Q) >= 0) {
388         ost->finished = 1;
389         return 0;
390     }
391     return 1;
392 }
393
394 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
395                          AVFrame *frame)
396 {
397     AVCodecContext *enc = ost->st->codec;
398     AVPacket pkt;
399     int got_packet = 0;
400
401     av_init_packet(&pkt);
402     pkt.data = NULL;
403     pkt.size = 0;
404
405     if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
406         frame->pts = ost->sync_opts;
407     ost->sync_opts = frame->pts + frame->nb_samples;
408
409     ost->samples_encoded += frame->nb_samples;
410     ost->frames_encoded++;
411
412     if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
413         av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
414         exit_program(1);
415     }
416
417     if (got_packet) {
418         if (pkt.pts != AV_NOPTS_VALUE)
419             pkt.pts      = av_rescale_q(pkt.pts,      enc->time_base, ost->st->time_base);
420         if (pkt.dts != AV_NOPTS_VALUE)
421             pkt.dts      = av_rescale_q(pkt.dts,      enc->time_base, ost->st->time_base);
422         if (pkt.duration > 0)
423             pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
424
425         write_frame(s, &pkt, ost);
426     }
427 }
428
429 static void do_subtitle_out(AVFormatContext *s,
430                             OutputStream *ost,
431                             InputStream *ist,
432                             AVSubtitle *sub,
433                             int64_t pts)
434 {
435     static uint8_t *subtitle_out = NULL;
436     int subtitle_out_max_size = 1024 * 1024;
437     int subtitle_out_size, nb, i;
438     AVCodecContext *enc;
439     AVPacket pkt;
440
441     if (pts == AV_NOPTS_VALUE) {
442         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
443         if (exit_on_error)
444             exit_program(1);
445         return;
446     }
447
448     enc = ost->st->codec;
449
450     if (!subtitle_out) {
451         subtitle_out = av_malloc(subtitle_out_max_size);
452     }
453
454     /* Note: DVB subtitle need one packet to draw them and one other
455        packet to clear them */
456     /* XXX: signal it in the codec context ? */
457     if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
458         nb = 2;
459     else
460         nb = 1;
461
462     for (i = 0; i < nb; i++) {
463         ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
464         if (!check_recording_time(ost))
465             return;
466
467         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
468         // start_display_time is required to be 0
469         sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
470         sub->end_display_time  -= sub->start_display_time;
471         sub->start_display_time = 0;
472
473         ost->frames_encoded++;
474
475         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
476                                                     subtitle_out_max_size, sub);
477         if (subtitle_out_size < 0) {
478             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
479             exit_program(1);
480         }
481
482         av_init_packet(&pkt);
483         pkt.data = subtitle_out;
484         pkt.size = subtitle_out_size;
485         pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
486         if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
487             /* XXX: the pts correction is handled here. Maybe handling
488                it in the codec would be better */
489             if (i == 0)
490                 pkt.pts += 90 * sub->start_display_time;
491             else
492                 pkt.pts += 90 * sub->end_display_time;
493         }
494         write_frame(s, &pkt, ost);
495     }
496 }
497
498 static void do_video_out(AVFormatContext *s,
499                          OutputStream *ost,
500                          AVFrame *in_picture,
501                          int *frame_size)
502 {
503     int ret, format_video_sync;
504     AVPacket pkt;
505     AVCodecContext *enc = ost->st->codec;
506
507     *frame_size = 0;
508
509     format_video_sync = video_sync_method;
510     if (format_video_sync == VSYNC_AUTO)
511         format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
512                             (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
513     if (format_video_sync != VSYNC_PASSTHROUGH &&
514         ost->frame_number &&
515         in_picture->pts != AV_NOPTS_VALUE &&
516         in_picture->pts < ost->sync_opts) {
517         nb_frames_drop++;
518         av_log(NULL, AV_LOG_WARNING,
519                "*** dropping frame %d from stream %d at ts %"PRId64"\n",
520                ost->frame_number, ost->st->index, in_picture->pts);
521         return;
522     }
523
524     if (in_picture->pts == AV_NOPTS_VALUE)
525         in_picture->pts = ost->sync_opts;
526     ost->sync_opts = in_picture->pts;
527
528
529     if (!ost->frame_number)
530         ost->first_pts = in_picture->pts;
531
532     av_init_packet(&pkt);
533     pkt.data = NULL;
534     pkt.size = 0;
535
536     if (ost->frame_number >= ost->max_frames)
537         return;
538
539     if (s->oformat->flags & AVFMT_RAWPICTURE &&
540         enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
541         /* raw pictures are written as AVPicture structure to
542            avoid any copies. We support temporarily the older
543            method. */
544         enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
545         enc->coded_frame->top_field_first  = in_picture->top_field_first;
546         pkt.data   = (uint8_t *)in_picture;
547         pkt.size   =  sizeof(AVPicture);
548         pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
549         pkt.flags |= AV_PKT_FLAG_KEY;
550
551         write_frame(s, &pkt, ost);
552     } else {
553         int got_packet;
554
555         if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME) &&
556             ost->top_field_first >= 0)
557             in_picture->top_field_first = !!ost->top_field_first;
558
559         in_picture->quality = ost->st->codec->global_quality;
560         if (!enc->me_threshold)
561             in_picture->pict_type = 0;
562         if (ost->forced_kf_index < ost->forced_kf_count &&
563             in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
564             in_picture->pict_type = AV_PICTURE_TYPE_I;
565             ost->forced_kf_index++;
566         }
567
568         ost->frames_encoded++;
569
570         ret = avcodec_encode_video2(enc, &pkt, in_picture, &got_packet);
571         if (ret < 0) {
572             av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
573             exit_program(1);
574         }
575
576         if (got_packet) {
577             if (pkt.pts != AV_NOPTS_VALUE)
578                 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
579             if (pkt.dts != AV_NOPTS_VALUE)
580                 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
581
582             write_frame(s, &pkt, ost);
583             *frame_size = pkt.size;
584
585             /* if two pass, output log */
586             if (ost->logfile && enc->stats_out) {
587                 fprintf(ost->logfile, "%s", enc->stats_out);
588             }
589         }
590     }
591     ost->sync_opts++;
592     /*
593      * For video, number of frames in == number of packets out.
594      * But there may be reordering, so we can't throw away frames on encoder
595      * flush, we need to limit them here, before they go into encoder.
596      */
597     ost->frame_number++;
598 }
599
600 static double psnr(double d)
601 {
602     return -10.0 * log(d) / log(10.0);
603 }
604
605 static void do_video_stats(OutputStream *ost, int frame_size)
606 {
607     AVCodecContext *enc;
608     int frame_number;
609     double ti1, bitrate, avg_bitrate;
610
611     /* this is executed just the first time do_video_stats is called */
612     if (!vstats_file) {
613         vstats_file = fopen(vstats_filename, "w");
614         if (!vstats_file) {
615             perror("fopen");
616             exit_program(1);
617         }
618     }
619
620     enc = ost->st->codec;
621     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
622         frame_number = ost->frame_number;
623         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
624         if (enc->flags&CODEC_FLAG_PSNR)
625             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
626
627         fprintf(vstats_file,"f_size= %6d ", frame_size);
628         /* compute pts value */
629         ti1 = ost->sync_opts * av_q2d(enc->time_base);
630         if (ti1 < 0.01)
631             ti1 = 0.01;
632
633         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
634         avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
635         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
636                (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
637         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
638     }
639 }
640
641 /*
642  * Read one frame for lavfi output for ost and encode it.
643  */
644 static int poll_filter(OutputStream *ost)
645 {
646     OutputFile    *of = output_files[ost->file_index];
647     AVFrame *filtered_frame = NULL;
648     int frame_size, ret;
649
650     if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
651         return AVERROR(ENOMEM);
652     }
653     filtered_frame = ost->filtered_frame;
654
655     if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
656         !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
657         ret = av_buffersink_get_samples(ost->filter->filter, filtered_frame,
658                                          ost->st->codec->frame_size);
659     else
660         ret = av_buffersink_get_frame(ost->filter->filter, filtered_frame);
661
662     if (ret < 0)
663         return ret;
664
665     if (filtered_frame->pts != AV_NOPTS_VALUE) {
666         int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
667         filtered_frame->pts = av_rescale_q(filtered_frame->pts,
668                                            ost->filter->filter->inputs[0]->time_base,
669                                            ost->st->codec->time_base) -
670                               av_rescale_q(start_time,
671                                            AV_TIME_BASE_Q,
672                                            ost->st->codec->time_base);
673     }
674
675     switch (ost->filter->filter->inputs[0]->type) {
676     case AVMEDIA_TYPE_VIDEO:
677         if (!ost->frame_aspect_ratio)
678             ost->st->codec->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
679
680         do_video_out(of->ctx, ost, filtered_frame, &frame_size);
681         if (vstats_filename && frame_size)
682             do_video_stats(ost, frame_size);
683         break;
684     case AVMEDIA_TYPE_AUDIO:
685         do_audio_out(of->ctx, ost, filtered_frame);
686         break;
687     default:
688         // TODO support subtitle filters
689         av_assert0(0);
690     }
691
692     av_frame_unref(filtered_frame);
693
694     return 0;
695 }
696
697 /*
698  * Read as many frames from possible from lavfi and encode them.
699  *
700  * Always read from the active stream with the lowest timestamp. If no frames
701  * are available for it then return EAGAIN and wait for more input. This way we
702  * can use lavfi sources that generate unlimited amount of frames without memory
703  * usage exploding.
704  */
705 static int poll_filters(void)
706 {
707     int i, j, ret = 0;
708
709     while (ret >= 0 && !received_sigterm) {
710         OutputStream *ost = NULL;
711         int64_t min_pts = INT64_MAX;
712
713         /* choose output stream with the lowest timestamp */
714         for (i = 0; i < nb_output_streams; i++) {
715             int64_t pts = output_streams[i]->sync_opts;
716
717             if (!output_streams[i]->filter || output_streams[i]->finished)
718                 continue;
719
720             pts = av_rescale_q(pts, output_streams[i]->st->codec->time_base,
721                                AV_TIME_BASE_Q);
722             if (pts < min_pts) {
723                 min_pts = pts;
724                 ost = output_streams[i];
725             }
726         }
727
728         if (!ost)
729             break;
730
731         ret = poll_filter(ost);
732
733         if (ret == AVERROR_EOF) {
734             OutputFile *of = output_files[ost->file_index];
735
736             ost->finished = 1;
737
738             if (of->shortest) {
739                 for (j = 0; j < of->ctx->nb_streams; j++)
740                     output_streams[of->ost_index + j]->finished = 1;
741             }
742
743             ret = 0;
744         } else if (ret == AVERROR(EAGAIN))
745             return 0;
746     }
747
748     return ret;
749 }
750
751 static void print_final_stats(int64_t total_size)
752 {
753     uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
754     uint64_t data_size = 0;
755     float percent = -1.0;
756     int i, j;
757
758     for (i = 0; i < nb_output_streams; i++) {
759         OutputStream *ost = output_streams[i];
760         switch (ost->st->codec->codec_type) {
761             case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
762             case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
763             default:                 other_size += ost->data_size; break;
764         }
765         extra_size += ost->st->codec->extradata_size;
766         data_size  += ost->data_size;
767     }
768
769     if (data_size && total_size >= data_size)
770         percent = 100.0 * (total_size - data_size) / data_size;
771
772     av_log(NULL, AV_LOG_INFO, "\n");
773     av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB other streams:%1.0fkB global headers:%1.0fkB muxing overhead: ",
774            video_size / 1024.0,
775            audio_size / 1024.0,
776            other_size / 1024.0,
777            extra_size / 1024.0);
778     if (percent >= 0.0)
779         av_log(NULL, AV_LOG_INFO, "%f%%", percent);
780     else
781         av_log(NULL, AV_LOG_INFO, "unknown");
782     av_log(NULL, AV_LOG_INFO, "\n");
783
784     /* print verbose per-stream stats */
785     for (i = 0; i < nb_input_files; i++) {
786         InputFile *f = input_files[i];
787         uint64_t total_packets = 0, total_size = 0;
788
789         av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
790                i, f->ctx->filename);
791
792         for (j = 0; j < f->nb_streams; j++) {
793             InputStream *ist = input_streams[f->ist_index + j];
794             enum AVMediaType type = ist->st->codec->codec_type;
795
796             total_size    += ist->data_size;
797             total_packets += ist->nb_packets;
798
799             av_log(NULL, AV_LOG_VERBOSE, "  Input stream #%d:%d (%s): ",
800                    i, j, media_type_string(type));
801             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
802                    ist->nb_packets, ist->data_size);
803
804             if (ist->decoding_needed) {
805                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
806                        ist->frames_decoded);
807                 if (type == AVMEDIA_TYPE_AUDIO)
808                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
809                 av_log(NULL, AV_LOG_VERBOSE, "; ");
810             }
811
812             av_log(NULL, AV_LOG_VERBOSE, "\n");
813         }
814
815         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
816                total_packets, total_size);
817     }
818
819     for (i = 0; i < nb_output_files; i++) {
820         OutputFile *of = output_files[i];
821         uint64_t total_packets = 0, total_size = 0;
822
823         av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
824                i, of->ctx->filename);
825
826         for (j = 0; j < of->ctx->nb_streams; j++) {
827             OutputStream *ost = output_streams[of->ost_index + j];
828             enum AVMediaType type = ost->st->codec->codec_type;
829
830             total_size    += ost->data_size;
831             total_packets += ost->packets_written;
832
833             av_log(NULL, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
834                    i, j, media_type_string(type));
835             if (ost->encoding_needed) {
836                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
837                        ost->frames_encoded);
838                 if (type == AVMEDIA_TYPE_AUDIO)
839                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
840                 av_log(NULL, AV_LOG_VERBOSE, "; ");
841             }
842
843             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
844                    ost->packets_written, ost->data_size);
845
846             av_log(NULL, AV_LOG_VERBOSE, "\n");
847         }
848
849         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
850                total_packets, total_size);
851     }
852 }
853
854 static void print_report(int is_last_report, int64_t timer_start)
855 {
856     char buf[1024];
857     OutputStream *ost;
858     AVFormatContext *oc;
859     int64_t total_size;
860     AVCodecContext *enc;
861     int frame_number, vid, i;
862     double bitrate, ti1, pts;
863     static int64_t last_time = -1;
864     static int qp_histogram[52];
865
866     if (!print_stats && !is_last_report)
867         return;
868
869     if (!is_last_report) {
870         int64_t cur_time;
871         /* display the report every 0.5 seconds */
872         cur_time = av_gettime();
873         if (last_time == -1) {
874             last_time = cur_time;
875             return;
876         }
877         if ((cur_time - last_time) < 500000)
878             return;
879         last_time = cur_time;
880     }
881
882
883     oc = output_files[0]->ctx;
884
885     total_size = avio_size(oc->pb);
886     if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
887         total_size = avio_tell(oc->pb);
888     if (total_size < 0) {
889         char errbuf[128];
890         av_strerror(total_size, errbuf, sizeof(errbuf));
891         av_log(NULL, AV_LOG_VERBOSE, "Bitrate not available, "
892                "avio_tell() failed: %s\n", errbuf);
893         total_size = 0;
894     }
895
896     buf[0] = '\0';
897     ti1 = 1e10;
898     vid = 0;
899     for (i = 0; i < nb_output_streams; i++) {
900         float q = -1;
901         ost = output_streams[i];
902         enc = ost->st->codec;
903         if (!ost->stream_copy && enc->coded_frame)
904             q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
905         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
906             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
907         }
908         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
909             float t = (av_gettime() - timer_start) / 1000000.0;
910
911             frame_number = ost->frame_number;
912             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
913                      frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
914             if (is_last_report)
915                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
916             if (qp_hist) {
917                 int j;
918                 int qp = lrintf(q);
919                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
920                     qp_histogram[qp]++;
921                 for (j = 0; j < 32; j++)
922                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log2(qp_histogram[j] + 1)));
923             }
924             if (enc->flags&CODEC_FLAG_PSNR) {
925                 int j;
926                 double error, error_sum = 0;
927                 double scale, scale_sum = 0;
928                 char type[3] = { 'Y','U','V' };
929                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
930                 for (j = 0; j < 3; j++) {
931                     if (is_last_report) {
932                         error = enc->error[j];
933                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
934                     } else {
935                         error = enc->coded_frame->error[j];
936                         scale = enc->width * enc->height * 255.0 * 255.0;
937                     }
938                     if (j)
939                         scale /= 4;
940                     error_sum += error;
941                     scale_sum += scale;
942                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
943                 }
944                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
945             }
946             vid = 1;
947         }
948         /* compute min output value */
949         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
950         if ((pts < ti1) && (pts > 0))
951             ti1 = pts;
952     }
953     if (ti1 < 0.01)
954         ti1 = 0.01;
955
956     bitrate = (double)(total_size * 8) / ti1 / 1000.0;
957
958     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
959             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
960             (double)total_size / 1024, ti1, bitrate);
961
962     if (nb_frames_drop)
963         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " drop=%d",
964                  nb_frames_drop);
965
966     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
967
968     fflush(stderr);
969
970     if (is_last_report)
971         print_final_stats(total_size);
972
973 }
974
975 static void flush_encoders(void)
976 {
977     int i, ret;
978
979     for (i = 0; i < nb_output_streams; i++) {
980         OutputStream   *ost = output_streams[i];
981         AVCodecContext *enc = ost->st->codec;
982         AVFormatContext *os = output_files[ost->file_index]->ctx;
983         int stop_encoding = 0;
984
985         if (!ost->encoding_needed)
986             continue;
987
988         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
989             continue;
990         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
991             continue;
992
993         for (;;) {
994             int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
995             const char *desc;
996
997             switch (ost->st->codec->codec_type) {
998             case AVMEDIA_TYPE_AUDIO:
999                 encode = avcodec_encode_audio2;
1000                 desc   = "Audio";
1001                 break;
1002             case AVMEDIA_TYPE_VIDEO:
1003                 encode = avcodec_encode_video2;
1004                 desc   = "Video";
1005                 break;
1006             default:
1007                 stop_encoding = 1;
1008             }
1009
1010             if (encode) {
1011                 AVPacket pkt;
1012                 int got_packet;
1013                 av_init_packet(&pkt);
1014                 pkt.data = NULL;
1015                 pkt.size = 0;
1016
1017                 ret = encode(enc, &pkt, NULL, &got_packet);
1018                 if (ret < 0) {
1019                     av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
1020                     exit_program(1);
1021                 }
1022                 if (ost->logfile && enc->stats_out) {
1023                     fprintf(ost->logfile, "%s", enc->stats_out);
1024                 }
1025                 if (!got_packet) {
1026                     stop_encoding = 1;
1027                     break;
1028                 }
1029                 if (pkt.pts != AV_NOPTS_VALUE)
1030                     pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1031                 if (pkt.dts != AV_NOPTS_VALUE)
1032                     pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1033                 if (pkt.duration > 0)
1034                     pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1035                 write_frame(os, &pkt, ost);
1036             }
1037
1038             if (stop_encoding)
1039                 break;
1040         }
1041     }
1042 }
1043
1044 /*
1045  * Check whether a packet from ist should be written into ost at this time
1046  */
1047 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1048 {
1049     OutputFile *of = output_files[ost->file_index];
1050     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
1051
1052     if (ost->source_index != ist_index)
1053         return 0;
1054
1055     if (of->start_time != AV_NOPTS_VALUE && ist->last_dts < of->start_time)
1056         return 0;
1057
1058     return 1;
1059 }
1060
1061 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1062 {
1063     OutputFile *of = output_files[ost->file_index];
1064     InputFile   *f = input_files [ist->file_index];
1065     int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1066     int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1067     AVPacket opkt;
1068
1069     av_init_packet(&opkt);
1070
1071     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1072         !ost->copy_initial_nonkeyframes)
1073         return;
1074
1075     if (of->recording_time != INT64_MAX &&
1076         ist->last_dts >= of->recording_time + start_time) {
1077         ost->finished = 1;
1078         return;
1079     }
1080
1081     if (f->recording_time != INT64_MAX) {
1082         start_time = f->ctx->start_time;
1083         if (f->start_time != AV_NOPTS_VALUE)
1084             start_time += f->start_time;
1085         if (ist->last_dts >= f->recording_time + start_time) {
1086             ost->finished = 1;
1087             return;
1088         }
1089     }
1090
1091     /* force the input stream PTS */
1092     if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1093         ost->sync_opts++;
1094
1095     if (pkt->pts != AV_NOPTS_VALUE)
1096         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1097     else
1098         opkt.pts = AV_NOPTS_VALUE;
1099
1100     if (pkt->dts == AV_NOPTS_VALUE)
1101         opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->st->time_base);
1102     else
1103         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1104     opkt.dts -= ost_tb_start_time;
1105
1106     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1107     opkt.flags    = pkt->flags;
1108
1109     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1110     if (  ost->st->codec->codec_id != AV_CODEC_ID_H264
1111        && ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
1112        && ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
1113        && ost->st->codec->codec_id != AV_CODEC_ID_VC1
1114        ) {
1115         if (av_parser_change(ost->parser, ost->st->codec,
1116                              &opkt.data, &opkt.size,
1117                              pkt->data, pkt->size,
1118                              pkt->flags & AV_PKT_FLAG_KEY)) {
1119             opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
1120             if (!opkt.buf)
1121                 exit_program(1);
1122         }
1123     } else {
1124         opkt.data = pkt->data;
1125         opkt.size = pkt->size;
1126     }
1127
1128     write_frame(of->ctx, &opkt, ost);
1129     ost->st->codec->frame_number++;
1130 }
1131
1132 int guess_input_channel_layout(InputStream *ist)
1133 {
1134     AVCodecContext *dec = ist->st->codec;
1135
1136     if (!dec->channel_layout) {
1137         char layout_name[256];
1138
1139         dec->channel_layout = av_get_default_channel_layout(dec->channels);
1140         if (!dec->channel_layout)
1141             return 0;
1142         av_get_channel_layout_string(layout_name, sizeof(layout_name),
1143                                      dec->channels, dec->channel_layout);
1144         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for  Input Stream "
1145                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1146     }
1147     return 1;
1148 }
1149
1150 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1151 {
1152     AVFrame *decoded_frame, *f;
1153     AVCodecContext *avctx = ist->st->codec;
1154     int i, ret, err = 0, resample_changed;
1155
1156     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1157         return AVERROR(ENOMEM);
1158     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1159         return AVERROR(ENOMEM);
1160     decoded_frame = ist->decoded_frame;
1161
1162     ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1163     if (!*got_output || ret < 0) {
1164         if (!pkt->size) {
1165             for (i = 0; i < ist->nb_filters; i++)
1166                 av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
1167         }
1168         return ret;
1169     }
1170
1171     ist->samples_decoded += decoded_frame->nb_samples;
1172     ist->frames_decoded++;
1173
1174     /* if the decoder provides a pts, use it instead of the last packet pts.
1175        the decoder could be delaying output by a packet or more. */
1176     if (decoded_frame->pts != AV_NOPTS_VALUE)
1177         ist->next_dts = decoded_frame->pts;
1178     else if (pkt->pts != AV_NOPTS_VALUE)
1179         decoded_frame->pts = pkt->pts;
1180     pkt->pts           = AV_NOPTS_VALUE;
1181
1182     resample_changed = ist->resample_sample_fmt     != decoded_frame->format         ||
1183                        ist->resample_channels       != avctx->channels               ||
1184                        ist->resample_channel_layout != decoded_frame->channel_layout ||
1185                        ist->resample_sample_rate    != decoded_frame->sample_rate;
1186     if (resample_changed) {
1187         char layout1[64], layout2[64];
1188
1189         if (!guess_input_channel_layout(ist)) {
1190             av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1191                    "layout for Input Stream #%d.%d\n", ist->file_index,
1192                    ist->st->index);
1193             exit_program(1);
1194         }
1195         decoded_frame->channel_layout = avctx->channel_layout;
1196
1197         av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1198                                      ist->resample_channel_layout);
1199         av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
1200                                      decoded_frame->channel_layout);
1201
1202         av_log(NULL, AV_LOG_INFO,
1203                "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n",
1204                ist->file_index, ist->st->index,
1205                ist->resample_sample_rate,  av_get_sample_fmt_name(ist->resample_sample_fmt),
1206                ist->resample_channels, layout1,
1207                decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
1208                avctx->channels, layout2);
1209
1210         ist->resample_sample_fmt     = decoded_frame->format;
1211         ist->resample_sample_rate    = decoded_frame->sample_rate;
1212         ist->resample_channel_layout = decoded_frame->channel_layout;
1213         ist->resample_channels       = avctx->channels;
1214
1215         for (i = 0; i < nb_filtergraphs; i++)
1216             if (ist_in_filtergraph(filtergraphs[i], ist) &&
1217                 configure_filtergraph(filtergraphs[i]) < 0) {
1218                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1219                 exit_program(1);
1220             }
1221     }
1222
1223     if (decoded_frame->pts != AV_NOPTS_VALUE)
1224         decoded_frame->pts = av_rescale_q(decoded_frame->pts,
1225                                           ist->st->time_base,
1226                                           (AVRational){1, ist->st->codec->sample_rate});
1227     for (i = 0; i < ist->nb_filters; i++) {
1228         if (i < ist->nb_filters - 1) {
1229             f = ist->filter_frame;
1230             err = av_frame_ref(f, decoded_frame);
1231             if (err < 0)
1232                 break;
1233         } else
1234             f = decoded_frame;
1235
1236         err = av_buffersrc_add_frame(ist->filters[i]->filter, f);
1237         if (err < 0)
1238             break;
1239     }
1240
1241     av_frame_unref(ist->filter_frame);
1242     av_frame_unref(decoded_frame);
1243     return err < 0 ? err : ret;
1244 }
1245
1246 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
1247 {
1248     AVFrame *decoded_frame, *f;
1249     int i, ret = 0, err = 0, resample_changed;
1250
1251     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1252         return AVERROR(ENOMEM);
1253     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1254         return AVERROR(ENOMEM);
1255     decoded_frame = ist->decoded_frame;
1256
1257     ret = avcodec_decode_video2(ist->st->codec,
1258                                 decoded_frame, got_output, pkt);
1259     if (!*got_output || ret < 0) {
1260         if (!pkt->size) {
1261             for (i = 0; i < ist->nb_filters; i++)
1262                 av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
1263         }
1264         return ret;
1265     }
1266
1267     ist->frames_decoded++;
1268
1269     if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
1270         err = ist->hwaccel_retrieve_data(ist->st->codec, decoded_frame);
1271         if (err < 0)
1272             goto fail;
1273     }
1274     ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
1275
1276     decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1277                                            decoded_frame->pkt_dts);
1278     pkt->size = 0;
1279
1280     if (ist->st->sample_aspect_ratio.num)
1281         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1282
1283     resample_changed = ist->resample_width   != decoded_frame->width  ||
1284                        ist->resample_height  != decoded_frame->height ||
1285                        ist->resample_pix_fmt != decoded_frame->format;
1286     if (resample_changed) {
1287         av_log(NULL, AV_LOG_INFO,
1288                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1289                ist->file_index, ist->st->index,
1290                ist->resample_width,  ist->resample_height,  av_get_pix_fmt_name(ist->resample_pix_fmt),
1291                decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1292
1293         ret = poll_filters();
1294         if (ret < 0 && (ret != AVERROR_EOF && ret != AVERROR(EAGAIN)))
1295             av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n");
1296
1297         ist->resample_width   = decoded_frame->width;
1298         ist->resample_height  = decoded_frame->height;
1299         ist->resample_pix_fmt = decoded_frame->format;
1300
1301         for (i = 0; i < nb_filtergraphs; i++)
1302             if (ist_in_filtergraph(filtergraphs[i], ist) &&
1303                 configure_filtergraph(filtergraphs[i]) < 0) {
1304                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1305                 exit_program(1);
1306             }
1307     }
1308
1309     for (i = 0; i < ist->nb_filters; i++) {
1310         if (i < ist->nb_filters - 1) {
1311             f = ist->filter_frame;
1312             err = av_frame_ref(f, decoded_frame);
1313             if (err < 0)
1314                 break;
1315         } else
1316             f = decoded_frame;
1317
1318         err = av_buffersrc_add_frame(ist->filters[i]->filter, f);
1319         if (err < 0)
1320             break;
1321     }
1322
1323 fail:
1324     av_frame_unref(ist->filter_frame);
1325     av_frame_unref(decoded_frame);
1326     return err < 0 ? err : ret;
1327 }
1328
1329 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1330 {
1331     AVSubtitle subtitle;
1332     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1333                                           &subtitle, got_output, pkt);
1334     if (ret < 0)
1335         return ret;
1336     if (!*got_output)
1337         return ret;
1338
1339     ist->frames_decoded++;
1340
1341     for (i = 0; i < nb_output_streams; i++) {
1342         OutputStream *ost = output_streams[i];
1343
1344         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1345             continue;
1346
1347         do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
1348     }
1349
1350     avsubtitle_free(&subtitle);
1351     return ret;
1352 }
1353
1354 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1355 static int output_packet(InputStream *ist, const AVPacket *pkt)
1356 {
1357     int i;
1358     int got_output;
1359     AVPacket avpkt;
1360
1361     if (ist->next_dts == AV_NOPTS_VALUE)
1362         ist->next_dts = ist->last_dts;
1363
1364     if (pkt == NULL) {
1365         /* EOF handling */
1366         av_init_packet(&avpkt);
1367         avpkt.data = NULL;
1368         avpkt.size = 0;
1369         goto handle_eof;
1370     } else {
1371         avpkt = *pkt;
1372     }
1373
1374     if (pkt->dts != AV_NOPTS_VALUE)
1375         ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1376
1377     // while we have more to decode or while the decoder did output something on EOF
1378     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1379         int ret = 0;
1380     handle_eof:
1381
1382         ist->last_dts = ist->next_dts;
1383
1384         if (avpkt.size && avpkt.size != pkt->size &&
1385             !(ist->dec->capabilities & CODEC_CAP_SUBFRAMES)) {
1386             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1387                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1388             ist->showed_multi_packet_warning = 1;
1389         }
1390
1391         switch (ist->st->codec->codec_type) {
1392         case AVMEDIA_TYPE_AUDIO:
1393             ret = decode_audio    (ist, &avpkt, &got_output);
1394             break;
1395         case AVMEDIA_TYPE_VIDEO:
1396             ret = decode_video    (ist, &avpkt, &got_output);
1397             if (avpkt.duration)
1398                 ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
1399             else if (ist->st->avg_frame_rate.num)
1400                 ist->next_dts += av_rescale_q(1, av_inv_q(ist->st->avg_frame_rate),
1401                                               AV_TIME_BASE_Q);
1402             else if (ist->st->codec->time_base.num != 0) {
1403                 int ticks      = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1404                                                    ist->st->codec->ticks_per_frame;
1405                 ist->next_dts += av_rescale_q(ticks, ist->st->codec->time_base, AV_TIME_BASE_Q);
1406             }
1407             break;
1408         case AVMEDIA_TYPE_SUBTITLE:
1409             ret = transcode_subtitles(ist, &avpkt, &got_output);
1410             break;
1411         default:
1412             return -1;
1413         }
1414
1415         if (ret < 0)
1416             return ret;
1417         // touch data and size only if not EOF
1418         if (pkt) {
1419             avpkt.data += ret;
1420             avpkt.size -= ret;
1421         }
1422         if (!got_output) {
1423             continue;
1424         }
1425     }
1426
1427     /* handle stream copy */
1428     if (!ist->decoding_needed) {
1429         ist->last_dts = ist->next_dts;
1430         switch (ist->st->codec->codec_type) {
1431         case AVMEDIA_TYPE_AUDIO:
1432             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1433                              ist->st->codec->sample_rate;
1434             break;
1435         case AVMEDIA_TYPE_VIDEO:
1436             if (ist->st->codec->time_base.num != 0) {
1437                 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
1438                 ist->next_dts += ((int64_t)AV_TIME_BASE *
1439                                   ist->st->codec->time_base.num * ticks) /
1440                                   ist->st->codec->time_base.den;
1441             }
1442             break;
1443         }
1444     }
1445     for (i = 0; pkt && i < nb_output_streams; i++) {
1446         OutputStream *ost = output_streams[i];
1447
1448         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
1449             continue;
1450
1451         do_streamcopy(ist, ost, pkt);
1452     }
1453
1454     return 0;
1455 }
1456
1457 static void print_sdp(void)
1458 {
1459     char sdp[16384];
1460     int i;
1461     AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
1462
1463     if (!avc)
1464         exit_program(1);
1465     for (i = 0; i < nb_output_files; i++)
1466         avc[i] = output_files[i]->ctx;
1467
1468     av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
1469     printf("SDP:\n%s\n", sdp);
1470     fflush(stdout);
1471     av_freep(&avc);
1472 }
1473
1474 static const HWAccel *get_hwaccel(enum AVPixelFormat pix_fmt)
1475 {
1476     int i;
1477     for (i = 0; hwaccels[i].name; i++)
1478         if (hwaccels[i].pix_fmt == pix_fmt)
1479             return &hwaccels[i];
1480     return NULL;
1481 }
1482
1483 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
1484 {
1485     InputStream *ist = s->opaque;
1486     const enum AVPixelFormat *p;
1487     int ret;
1488
1489     for (p = pix_fmts; *p != -1; p++) {
1490         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
1491         const HWAccel *hwaccel;
1492
1493         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1494             break;
1495
1496         hwaccel = get_hwaccel(*p);
1497         if (!hwaccel ||
1498             (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
1499             (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
1500             continue;
1501
1502         ret = hwaccel->init(s);
1503         if (ret < 0) {
1504             if (ist->hwaccel_id == hwaccel->id) {
1505                 av_log(NULL, AV_LOG_FATAL,
1506                        "%s hwaccel requested for input stream #%d:%d, "
1507                        "but cannot be initialized.\n", hwaccel->name,
1508                        ist->file_index, ist->st->index);
1509                 exit_program(1);
1510             }
1511             continue;
1512         }
1513         ist->active_hwaccel_id = hwaccel->id;
1514         ist->hwaccel_pix_fmt   = *p;
1515         break;
1516     }
1517
1518     return *p;
1519 }
1520
1521 static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
1522 {
1523     InputStream *ist = s->opaque;
1524
1525     if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
1526         return ist->hwaccel_get_buffer(s, frame, flags);
1527
1528     return avcodec_default_get_buffer2(s, frame, flags);
1529 }
1530
1531 static int init_input_stream(int ist_index, char *error, int error_len)
1532 {
1533     int i, ret;
1534     InputStream *ist = input_streams[ist_index];
1535     if (ist->decoding_needed) {
1536         AVCodec *codec = ist->dec;
1537         if (!codec) {
1538             snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
1539                     ist->st->codec->codec_id, ist->file_index, ist->st->index);
1540             return AVERROR(EINVAL);
1541         }
1542
1543         /* update requested sample format for the decoder based on the
1544            corresponding encoder sample format */
1545         for (i = 0; i < nb_output_streams; i++) {
1546             OutputStream *ost = output_streams[i];
1547             if (ost->source_index == ist_index) {
1548                 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1549                 break;
1550             }
1551         }
1552
1553         ist->st->codec->opaque      = ist;
1554         ist->st->codec->get_format  = get_format;
1555         ist->st->codec->get_buffer2 = get_buffer;
1556         ist->st->codec->thread_safe_callbacks = 1;
1557
1558         av_opt_set_int(ist->st->codec, "refcounted_frames", 1, 0);
1559
1560         if (!av_dict_get(ist->opts, "threads", NULL, 0))
1561             av_dict_set(&ist->opts, "threads", "auto", 0);
1562         if ((ret = avcodec_open2(ist->st->codec, codec, &ist->opts)) < 0) {
1563             char errbuf[128];
1564             if (ret == AVERROR_EXPERIMENTAL)
1565                 abort_codec_experimental(codec, 0);
1566
1567             av_strerror(ret, errbuf, sizeof(errbuf));
1568
1569             snprintf(error, error_len,
1570                      "Error while opening decoder for input stream "
1571                      "#%d:%d : %s",
1572                      ist->file_index, ist->st->index, errbuf);
1573             return ret;
1574         }
1575         assert_avoptions(ist->opts);
1576     }
1577
1578     ist->last_dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1579     ist->next_dts = AV_NOPTS_VALUE;
1580     init_pts_correction(&ist->pts_ctx);
1581
1582     return 0;
1583 }
1584
1585 static InputStream *get_input_stream(OutputStream *ost)
1586 {
1587     if (ost->source_index >= 0)
1588         return input_streams[ost->source_index];
1589
1590     if (ost->filter) {
1591         FilterGraph *fg = ost->filter->graph;
1592         int i;
1593
1594         for (i = 0; i < fg->nb_inputs; i++)
1595             if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
1596                 return fg->inputs[i]->ist;
1597     }
1598
1599     return NULL;
1600 }
1601
1602 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1603                                     AVCodecContext *avctx)
1604 {
1605     char *p;
1606     int n = 1, i;
1607     int64_t t;
1608
1609     for (p = kf; *p; p++)
1610         if (*p == ',')
1611             n++;
1612     ost->forced_kf_count = n;
1613     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1614     if (!ost->forced_kf_pts) {
1615         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1616         exit_program(1);
1617     }
1618
1619     p = kf;
1620     for (i = 0; i < n; i++) {
1621         char *next = strchr(p, ',');
1622
1623         if (next)
1624             *next++ = 0;
1625
1626         t = parse_time_or_die("force_key_frames", p, 1);
1627         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1628
1629         p = next;
1630     }
1631 }
1632
1633 static int transcode_init(void)
1634 {
1635     int ret = 0, i, j, k;
1636     AVFormatContext *oc;
1637     AVCodecContext *codec;
1638     OutputStream *ost;
1639     InputStream *ist;
1640     char error[1024];
1641     int want_sdp = 1;
1642
1643     /* init framerate emulation */
1644     for (i = 0; i < nb_input_files; i++) {
1645         InputFile *ifile = input_files[i];
1646         if (ifile->rate_emu)
1647             for (j = 0; j < ifile->nb_streams; j++)
1648                 input_streams[j + ifile->ist_index]->start = av_gettime();
1649     }
1650
1651     /* output stream init */
1652     for (i = 0; i < nb_output_files; i++) {
1653         oc = output_files[i]->ctx;
1654         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1655             av_dump_format(oc, i, oc->filename, 1);
1656             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1657             return AVERROR(EINVAL);
1658         }
1659     }
1660
1661     /* init complex filtergraphs */
1662     for (i = 0; i < nb_filtergraphs; i++)
1663         if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
1664             return ret;
1665
1666     /* for each output stream, we compute the right encoding parameters */
1667     for (i = 0; i < nb_output_streams; i++) {
1668         AVCodecContext *icodec = NULL;
1669         ost = output_streams[i];
1670         oc  = output_files[ost->file_index]->ctx;
1671         ist = get_input_stream(ost);
1672
1673         if (ost->attachment_filename)
1674             continue;
1675
1676         codec  = ost->st->codec;
1677
1678         if (ist) {
1679             icodec = ist->st->codec;
1680
1681             ost->st->disposition          = ist->st->disposition;
1682             codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
1683             codec->chroma_sample_location = icodec->chroma_sample_location;
1684         }
1685
1686         if (ost->stream_copy) {
1687             AVRational sar;
1688             uint64_t extra_size;
1689
1690             av_assert0(ist && !ost->filter);
1691
1692             extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1693
1694             if (extra_size > INT_MAX) {
1695                 return AVERROR(EINVAL);
1696             }
1697
1698             /* if stream_copy is selected, no need to decode or encode */
1699             codec->codec_id   = icodec->codec_id;
1700             codec->codec_type = icodec->codec_type;
1701
1702             if (!codec->codec_tag) {
1703                 if (!oc->oformat->codec_tag ||
1704                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
1705                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
1706                     codec->codec_tag = icodec->codec_tag;
1707             }
1708
1709             codec->bit_rate       = icodec->bit_rate;
1710             codec->rc_max_rate    = icodec->rc_max_rate;
1711             codec->rc_buffer_size = icodec->rc_buffer_size;
1712             codec->field_order    = icodec->field_order;
1713             codec->extradata      = av_mallocz(extra_size);
1714             if (!codec->extradata) {
1715                 return AVERROR(ENOMEM);
1716             }
1717             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1718             codec->extradata_size = icodec->extradata_size;
1719             if (!copy_tb) {
1720                 codec->time_base      = icodec->time_base;
1721                 codec->time_base.num *= icodec->ticks_per_frame;
1722                 av_reduce(&codec->time_base.num, &codec->time_base.den,
1723                           codec->time_base.num, codec->time_base.den, INT_MAX);
1724             } else
1725                 codec->time_base = ist->st->time_base;
1726
1727             ost->parser = av_parser_init(codec->codec_id);
1728
1729             switch (codec->codec_type) {
1730             case AVMEDIA_TYPE_AUDIO:
1731                 if (audio_volume != 256) {
1732                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
1733                     exit_program(1);
1734                 }
1735                 codec->channel_layout     = icodec->channel_layout;
1736                 codec->sample_rate        = icodec->sample_rate;
1737                 codec->channels           = icodec->channels;
1738                 codec->frame_size         = icodec->frame_size;
1739                 codec->audio_service_type = icodec->audio_service_type;
1740                 codec->block_align        = icodec->block_align;
1741                 break;
1742             case AVMEDIA_TYPE_VIDEO:
1743                 codec->pix_fmt            = icodec->pix_fmt;
1744                 codec->width              = icodec->width;
1745                 codec->height             = icodec->height;
1746                 codec->has_b_frames       = icodec->has_b_frames;
1747                 if (ost->frame_aspect_ratio)
1748                     sar = av_d2q(ost->frame_aspect_ratio * codec->height / codec->width, 255);
1749                 else if (ist->st->sample_aspect_ratio.num)
1750                     sar = ist->st->sample_aspect_ratio;
1751                 else
1752                     sar = icodec->sample_aspect_ratio;
1753                 ost->st->sample_aspect_ratio = codec->sample_aspect_ratio = sar;
1754                 break;
1755             case AVMEDIA_TYPE_SUBTITLE:
1756                 codec->width  = icodec->width;
1757                 codec->height = icodec->height;
1758                 break;
1759             case AVMEDIA_TYPE_DATA:
1760             case AVMEDIA_TYPE_ATTACHMENT:
1761                 break;
1762             default:
1763                 abort();
1764             }
1765         } else {
1766             if (!ost->enc) {
1767                 /* should only happen when a default codec is not present. */
1768                 snprintf(error, sizeof(error), "Automatic encoder selection "
1769                          "failed for output stream #%d:%d. Default encoder for "
1770                          "format %s is probably disabled. Please choose an "
1771                          "encoder manually.\n", ost->file_index, ost->index,
1772                          oc->oformat->name);
1773                 ret = AVERROR(EINVAL);
1774                 goto dump_format;
1775             }
1776
1777             if (ist)
1778                 ist->decoding_needed = 1;
1779             ost->encoding_needed = 1;
1780
1781             /*
1782              * We want CFR output if and only if one of those is true:
1783              * 1) user specified output framerate with -r
1784              * 2) user specified -vsync cfr
1785              * 3) output format is CFR and the user didn't force vsync to
1786              *    something else than CFR
1787              *
1788              * in such a case, set ost->frame_rate
1789              */
1790             if (codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1791                 !ost->frame_rate.num && ist &&
1792                 (video_sync_method ==  VSYNC_CFR ||
1793                  (video_sync_method ==  VSYNC_AUTO &&
1794                   !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS))))) {
1795                 if (ist->framerate.num)
1796                     ost->frame_rate = ist->framerate;
1797                 else if (ist->st->avg_frame_rate.num)
1798                     ost->frame_rate = ist->st->avg_frame_rate;
1799                 else {
1800                     av_log(NULL, AV_LOG_WARNING, "Constant framerate requested "
1801                            "for the output stream #%d:%d, but no information "
1802                            "about the input framerate is available. Falling "
1803                            "back to a default value of 25fps. Use the -r option "
1804                            "if you want a different framerate.\n",
1805                            ost->file_index, ost->index);
1806                     ost->frame_rate = (AVRational){ 25, 1 };
1807                 }
1808
1809                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
1810                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
1811                     ost->frame_rate = ost->enc->supported_framerates[idx];
1812                 }
1813             }
1814
1815             if (!ost->filter &&
1816                 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
1817                  codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
1818                     FilterGraph *fg;
1819                     fg = init_simple_filtergraph(ist, ost);
1820                     if (configure_filtergraph(fg)) {
1821                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
1822                         exit_program(1);
1823                     }
1824             }
1825
1826             switch (codec->codec_type) {
1827             case AVMEDIA_TYPE_AUDIO:
1828                 codec->sample_fmt     = ost->filter->filter->inputs[0]->format;
1829                 codec->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
1830                 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
1831                 codec->channels       = av_get_channel_layout_nb_channels(codec->channel_layout);
1832                 codec->time_base      = (AVRational){ 1, codec->sample_rate };
1833                 break;
1834             case AVMEDIA_TYPE_VIDEO:
1835                 codec->time_base = ost->filter->filter->inputs[0]->time_base;
1836
1837                 codec->width  = ost->filter->filter->inputs[0]->w;
1838                 codec->height = ost->filter->filter->inputs[0]->h;
1839                 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
1840                     ost->frame_aspect_ratio ? // overridden by the -aspect cli option
1841                     av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
1842                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
1843                 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
1844
1845                 if (icodec &&
1846                     (codec->width   != icodec->width  ||
1847                      codec->height  != icodec->height ||
1848                      codec->pix_fmt != icodec->pix_fmt)) {
1849                     codec->bits_per_raw_sample = 0;
1850                 }
1851
1852                 if (ost->forced_keyframes)
1853                     parse_forced_key_frames(ost->forced_keyframes, ost,
1854                                             ost->st->codec);
1855                 break;
1856             case AVMEDIA_TYPE_SUBTITLE:
1857                 codec->time_base = (AVRational){1, 1000};
1858                 break;
1859             default:
1860                 abort();
1861                 break;
1862             }
1863             /* two pass mode */
1864             if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1865                 char logfilename[1024];
1866                 FILE *f;
1867
1868                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1869                          ost->logfile_prefix ? ost->logfile_prefix :
1870                                                DEFAULT_PASS_LOGFILENAME_PREFIX,
1871                          i);
1872                 if (!strcmp(ost->enc->name, "libx264")) {
1873                     av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1874                 } else {
1875                     if (codec->flags & CODEC_FLAG_PASS1) {
1876                         f = fopen(logfilename, "wb");
1877                         if (!f) {
1878                             av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1879                                    logfilename, strerror(errno));
1880                             exit_program(1);
1881                         }
1882                         ost->logfile = f;
1883                     } else {
1884                         char  *logbuffer;
1885                         size_t logbuffer_size;
1886                         if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
1887                             av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1888                                    logfilename);
1889                             exit_program(1);
1890                         }
1891                         codec->stats_in = logbuffer;
1892                     }
1893                 }
1894             }
1895         }
1896     }
1897
1898     /* open each encoder */
1899     for (i = 0; i < nb_output_streams; i++) {
1900         ost = output_streams[i];
1901         if (ost->encoding_needed) {
1902             AVCodec      *codec = ost->enc;
1903             AVCodecContext *dec = NULL;
1904
1905             if ((ist = get_input_stream(ost)))
1906                 dec = ist->st->codec;
1907             if (dec && dec->subtitle_header) {
1908                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
1909                 if (!ost->st->codec->subtitle_header) {
1910                     ret = AVERROR(ENOMEM);
1911                     goto dump_format;
1912                 }
1913                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
1914                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
1915             }
1916             if (!av_dict_get(ost->opts, "threads", NULL, 0))
1917                 av_dict_set(&ost->opts, "threads", "auto", 0);
1918             if ((ret = avcodec_open2(ost->st->codec, codec, &ost->opts)) < 0) {
1919                 if (ret == AVERROR_EXPERIMENTAL)
1920                     abort_codec_experimental(codec, 1);
1921                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1922                         ost->file_index, ost->index);
1923                 goto dump_format;
1924             }
1925             assert_avoptions(ost->opts);
1926             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
1927                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
1928                                              "It takes bits/s as argument, not kbits/s\n");
1929         } else {
1930             av_opt_set_dict(ost->st->codec, &ost->opts);
1931         }
1932     }
1933
1934     /* init input streams */
1935     for (i = 0; i < nb_input_streams; i++)
1936         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
1937             goto dump_format;
1938
1939     /* discard unused programs */
1940     for (i = 0; i < nb_input_files; i++) {
1941         InputFile *ifile = input_files[i];
1942         for (j = 0; j < ifile->ctx->nb_programs; j++) {
1943             AVProgram *p = ifile->ctx->programs[j];
1944             int discard  = AVDISCARD_ALL;
1945
1946             for (k = 0; k < p->nb_stream_indexes; k++)
1947                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
1948                     discard = AVDISCARD_DEFAULT;
1949                     break;
1950                 }
1951             p->discard = discard;
1952         }
1953     }
1954
1955     /* open files and write file headers */
1956     for (i = 0; i < nb_output_files; i++) {
1957         oc = output_files[i]->ctx;
1958         oc->interrupt_callback = int_cb;
1959         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
1960             char errbuf[128];
1961             av_strerror(ret, errbuf, sizeof(errbuf));
1962             snprintf(error, sizeof(error),
1963                      "Could not write header for output file #%d "
1964                      "(incorrect codec parameters ?): %s",
1965                      i, errbuf);
1966             ret = AVERROR(EINVAL);
1967             goto dump_format;
1968         }
1969         assert_avoptions(output_files[i]->opts);
1970         if (strcmp(oc->oformat->name, "rtp")) {
1971             want_sdp = 0;
1972         }
1973     }
1974
1975  dump_format:
1976     /* dump the file output parameters - cannot be done before in case
1977        of stream copy */
1978     for (i = 0; i < nb_output_files; i++) {
1979         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
1980     }
1981
1982     /* dump the stream mapping */
1983     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
1984     for (i = 0; i < nb_input_streams; i++) {
1985         ist = input_streams[i];
1986
1987         for (j = 0; j < ist->nb_filters; j++) {
1988             if (ist->filters[j]->graph->graph_desc) {
1989                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
1990                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
1991                        ist->filters[j]->name);
1992                 if (nb_filtergraphs > 1)
1993                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
1994                 av_log(NULL, AV_LOG_INFO, "\n");
1995             }
1996         }
1997     }
1998
1999     for (i = 0; i < nb_output_streams; i++) {
2000         ost = output_streams[i];
2001
2002         if (ost->attachment_filename) {
2003             /* an attached file */
2004             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2005                    ost->attachment_filename, ost->file_index, ost->index);
2006             continue;
2007         }
2008
2009         if (ost->filter && ost->filter->graph->graph_desc) {
2010             /* output from a complex graph */
2011             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
2012             if (nb_filtergraphs > 1)
2013                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
2014
2015             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
2016                    ost->index, ost->enc ? ost->enc->name : "?");
2017             continue;
2018         }
2019
2020         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2021                input_streams[ost->source_index]->file_index,
2022                input_streams[ost->source_index]->st->index,
2023                ost->file_index,
2024                ost->index);
2025         if (ost->sync_ist != input_streams[ost->source_index])
2026             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2027                    ost->sync_ist->file_index,
2028                    ost->sync_ist->st->index);
2029         if (ost->stream_copy)
2030             av_log(NULL, AV_LOG_INFO, " (copy)");
2031         else
2032             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
2033                    input_streams[ost->source_index]->dec->name : "?",
2034                    ost->enc ? ost->enc->name : "?");
2035         av_log(NULL, AV_LOG_INFO, "\n");
2036     }
2037
2038     if (ret) {
2039         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2040         return ret;
2041     }
2042
2043     if (want_sdp) {
2044         print_sdp();
2045     }
2046
2047     return 0;
2048 }
2049
2050 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
2051 static int need_output(void)
2052 {
2053     int i;
2054
2055     for (i = 0; i < nb_output_streams; i++) {
2056         OutputStream *ost    = output_streams[i];
2057         OutputFile *of       = output_files[ost->file_index];
2058         AVFormatContext *os  = output_files[ost->file_index]->ctx;
2059
2060         if (ost->finished ||
2061             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2062             continue;
2063         if (ost->frame_number >= ost->max_frames) {
2064             int j;
2065             for (j = 0; j < of->ctx->nb_streams; j++)
2066                 output_streams[of->ost_index + j]->finished = 1;
2067             continue;
2068         }
2069
2070         return 1;
2071     }
2072
2073     return 0;
2074 }
2075
2076 static InputFile *select_input_file(void)
2077 {
2078     InputFile *ifile = NULL;
2079     int64_t ipts_min = INT64_MAX;
2080     int i;
2081
2082     for (i = 0; i < nb_input_streams; i++) {
2083         InputStream *ist = input_streams[i];
2084         int64_t ipts     = ist->last_dts;
2085
2086         if (ist->discard || input_files[ist->file_index]->eagain)
2087             continue;
2088         if (!input_files[ist->file_index]->eof_reached) {
2089             if (ipts < ipts_min) {
2090                 ipts_min = ipts;
2091                 ifile    = input_files[ist->file_index];
2092             }
2093         }
2094     }
2095
2096     return ifile;
2097 }
2098
2099 #if HAVE_PTHREADS
2100 static void *input_thread(void *arg)
2101 {
2102     InputFile *f = arg;
2103     int ret = 0;
2104
2105     while (!transcoding_finished && ret >= 0) {
2106         AVPacket pkt;
2107         ret = av_read_frame(f->ctx, &pkt);
2108
2109         if (ret == AVERROR(EAGAIN)) {
2110             av_usleep(10000);
2111             ret = 0;
2112             continue;
2113         } else if (ret < 0)
2114             break;
2115
2116         pthread_mutex_lock(&f->fifo_lock);
2117         while (!av_fifo_space(f->fifo))
2118             pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
2119
2120         av_dup_packet(&pkt);
2121         av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
2122
2123         pthread_mutex_unlock(&f->fifo_lock);
2124     }
2125
2126     f->finished = 1;
2127     return NULL;
2128 }
2129
2130 static void free_input_threads(void)
2131 {
2132     int i;
2133
2134     if (nb_input_files == 1)
2135         return;
2136
2137     transcoding_finished = 1;
2138
2139     for (i = 0; i < nb_input_files; i++) {
2140         InputFile *f = input_files[i];
2141         AVPacket pkt;
2142
2143         if (!f->fifo || f->joined)
2144             continue;
2145
2146         pthread_mutex_lock(&f->fifo_lock);
2147         while (av_fifo_size(f->fifo)) {
2148             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2149             av_free_packet(&pkt);
2150         }
2151         pthread_cond_signal(&f->fifo_cond);
2152         pthread_mutex_unlock(&f->fifo_lock);
2153
2154         pthread_join(f->thread, NULL);
2155         f->joined = 1;
2156
2157         while (av_fifo_size(f->fifo)) {
2158             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2159             av_free_packet(&pkt);
2160         }
2161         av_fifo_free(f->fifo);
2162     }
2163 }
2164
2165 static int init_input_threads(void)
2166 {
2167     int i, ret;
2168
2169     if (nb_input_files == 1)
2170         return 0;
2171
2172     for (i = 0; i < nb_input_files; i++) {
2173         InputFile *f = input_files[i];
2174
2175         if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
2176             return AVERROR(ENOMEM);
2177
2178         pthread_mutex_init(&f->fifo_lock, NULL);
2179         pthread_cond_init (&f->fifo_cond, NULL);
2180
2181         if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
2182             return AVERROR(ret);
2183     }
2184     return 0;
2185 }
2186
2187 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
2188 {
2189     int ret = 0;
2190
2191     pthread_mutex_lock(&f->fifo_lock);
2192
2193     if (av_fifo_size(f->fifo)) {
2194         av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
2195         pthread_cond_signal(&f->fifo_cond);
2196     } else {
2197         if (f->finished)
2198             ret = AVERROR_EOF;
2199         else
2200             ret = AVERROR(EAGAIN);
2201     }
2202
2203     pthread_mutex_unlock(&f->fifo_lock);
2204
2205     return ret;
2206 }
2207 #endif
2208
2209 static int get_input_packet(InputFile *f, AVPacket *pkt)
2210 {
2211     if (f->rate_emu) {
2212         int i;
2213         for (i = 0; i < f->nb_streams; i++) {
2214             InputStream *ist = input_streams[f->ist_index + i];
2215             int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE);
2216             int64_t now = av_gettime() - ist->start;
2217             if (pts > now)
2218                 return AVERROR(EAGAIN);
2219         }
2220     }
2221
2222 #if HAVE_PTHREADS
2223     if (nb_input_files > 1)
2224         return get_input_packet_mt(f, pkt);
2225 #endif
2226     return av_read_frame(f->ctx, pkt);
2227 }
2228
2229 static int got_eagain(void)
2230 {
2231     int i;
2232     for (i = 0; i < nb_input_files; i++)
2233         if (input_files[i]->eagain)
2234             return 1;
2235     return 0;
2236 }
2237
2238 static void reset_eagain(void)
2239 {
2240     int i;
2241     for (i = 0; i < nb_input_files; i++)
2242         input_files[i]->eagain = 0;
2243 }
2244
2245 /*
2246  * Read one packet from an input file and send it for
2247  * - decoding -> lavfi (audio/video)
2248  * - decoding -> encoding -> muxing (subtitles)
2249  * - muxing (streamcopy)
2250  *
2251  * Return
2252  * - 0 -- one packet was read and processed
2253  * - AVERROR(EAGAIN) -- no packets were available for selected file,
2254  *   this function should be called again
2255  * - AVERROR_EOF -- this function should not be called again
2256  */
2257 static int process_input(void)
2258 {
2259     InputFile *ifile;
2260     AVFormatContext *is;
2261     InputStream *ist;
2262     AVPacket pkt;
2263     int ret, i, j;
2264
2265     /* select the stream that we must read now */
2266     ifile = select_input_file();
2267     /* if none, if is finished */
2268     if (!ifile) {
2269         if (got_eagain()) {
2270             reset_eagain();
2271             av_usleep(10000);
2272             return AVERROR(EAGAIN);
2273         }
2274         av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from.\n");
2275         return AVERROR_EOF;
2276     }
2277
2278     is  = ifile->ctx;
2279     ret = get_input_packet(ifile, &pkt);
2280
2281     if (ret == AVERROR(EAGAIN)) {
2282         ifile->eagain = 1;
2283         return ret;
2284     }
2285     if (ret < 0) {
2286         if (ret != AVERROR_EOF) {
2287             print_error(is->filename, ret);
2288             if (exit_on_error)
2289                 exit_program(1);
2290         }
2291         ifile->eof_reached = 1;
2292
2293         for (i = 0; i < ifile->nb_streams; i++) {
2294             ist = input_streams[ifile->ist_index + i];
2295             if (ist->decoding_needed)
2296                 output_packet(ist, NULL);
2297
2298             /* mark all outputs that don't go through lavfi as finished */
2299             for (j = 0; j < nb_output_streams; j++) {
2300                 OutputStream *ost = output_streams[j];
2301
2302                 if (ost->source_index == ifile->ist_index + i &&
2303                     (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
2304                     ost->finished= 1;
2305             }
2306         }
2307
2308         return AVERROR(EAGAIN);
2309     }
2310
2311     reset_eagain();
2312
2313     if (do_pkt_dump) {
2314         av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2315                          is->streams[pkt.stream_index]);
2316     }
2317     /* the following test is needed in case new streams appear
2318        dynamically in stream : we ignore them */
2319     if (pkt.stream_index >= ifile->nb_streams)
2320         goto discard_packet;
2321
2322     ist = input_streams[ifile->ist_index + pkt.stream_index];
2323
2324     ist->data_size += pkt.size;
2325     ist->nb_packets++;
2326
2327     if (ist->discard)
2328         goto discard_packet;
2329
2330     /* add the stream-global side data to the first packet */
2331     if (ist->nb_packets == 1)
2332         for (i = 0; i < ist->st->nb_side_data; i++) {
2333             AVPacketSideData *src_sd = &ist->st->side_data[i];
2334             uint8_t *dst_data;
2335
2336             if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
2337                 continue;
2338
2339             dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size);
2340             if (!dst_data)
2341                 exit_program(1);
2342
2343             memcpy(dst_data, src_sd->data, src_sd->size);
2344         }
2345
2346     if (pkt.dts != AV_NOPTS_VALUE)
2347         pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2348     if (pkt.pts != AV_NOPTS_VALUE)
2349         pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2350
2351     if (pkt.pts != AV_NOPTS_VALUE)
2352         pkt.pts *= ist->ts_scale;
2353     if (pkt.dts != AV_NOPTS_VALUE)
2354         pkt.dts *= ist->ts_scale;
2355
2356     if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
2357         (is->iformat->flags & AVFMT_TS_DISCONT)) {
2358         int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2359         int64_t delta   = pkt_dts - ist->next_dts;
2360
2361         if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
2362             ifile->ts_offset -= delta;
2363             av_log(NULL, AV_LOG_DEBUG,
2364                    "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2365                    delta, ifile->ts_offset);
2366             pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2367             if (pkt.pts != AV_NOPTS_VALUE)
2368                 pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2369         }
2370     }
2371
2372     ret = output_packet(ist, &pkt);
2373     if (ret < 0) {
2374         av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2375                ist->file_index, ist->st->index);
2376         if (exit_on_error)
2377             exit_program(1);
2378     }
2379
2380 discard_packet:
2381     av_free_packet(&pkt);
2382
2383     return 0;
2384 }
2385
2386 /*
2387  * The following code is the main loop of the file converter
2388  */
2389 static int transcode(void)
2390 {
2391     int ret, i, need_input = 1;
2392     AVFormatContext *os;
2393     OutputStream *ost;
2394     InputStream *ist;
2395     int64_t timer_start;
2396
2397     ret = transcode_init();
2398     if (ret < 0)
2399         goto fail;
2400
2401     av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2402     term_init();
2403
2404     timer_start = av_gettime();
2405
2406 #if HAVE_PTHREADS
2407     if ((ret = init_input_threads()) < 0)
2408         goto fail;
2409 #endif
2410
2411     while (!received_sigterm) {
2412         /* check if there's any stream where output is still needed */
2413         if (!need_output()) {
2414             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
2415             break;
2416         }
2417
2418         /* read and process one input packet if needed */
2419         if (need_input) {
2420             ret = process_input();
2421             if (ret == AVERROR_EOF)
2422                 need_input = 0;
2423         }
2424
2425         ret = poll_filters();
2426         if (ret < 0) {
2427             if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
2428                 continue;
2429
2430             av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n");
2431             break;
2432         }
2433
2434         /* dump report by using the output first video and audio streams */
2435         print_report(0, timer_start);
2436     }
2437 #if HAVE_PTHREADS
2438     free_input_threads();
2439 #endif
2440
2441     /* at the end of stream, we must flush the decoder buffers */
2442     for (i = 0; i < nb_input_streams; i++) {
2443         ist = input_streams[i];
2444         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
2445             output_packet(ist, NULL);
2446         }
2447     }
2448     poll_filters();
2449     flush_encoders();
2450
2451     term_exit();
2452
2453     /* write the trailer if needed and close file */
2454     for (i = 0; i < nb_output_files; i++) {
2455         os = output_files[i]->ctx;
2456         av_write_trailer(os);
2457     }
2458
2459     /* dump report by using the first video and audio streams */
2460     print_report(1, timer_start);
2461
2462     /* close each encoder */
2463     for (i = 0; i < nb_output_streams; i++) {
2464         ost = output_streams[i];
2465         if (ost->encoding_needed) {
2466             av_freep(&ost->st->codec->stats_in);
2467             avcodec_close(ost->st->codec);
2468         }
2469     }
2470
2471     /* close each decoder */
2472     for (i = 0; i < nb_input_streams; i++) {
2473         ist = input_streams[i];
2474         if (ist->decoding_needed) {
2475             avcodec_close(ist->st->codec);
2476             if (ist->hwaccel_uninit)
2477                 ist->hwaccel_uninit(ist->st->codec);
2478         }
2479     }
2480
2481     /* finished ! */
2482     ret = 0;
2483
2484  fail:
2485 #if HAVE_PTHREADS
2486     free_input_threads();
2487 #endif
2488
2489     if (output_streams) {
2490         for (i = 0; i < nb_output_streams; i++) {
2491             ost = output_streams[i];
2492             if (ost) {
2493                 if (ost->stream_copy)
2494                     av_freep(&ost->st->codec->extradata);
2495                 if (ost->logfile) {
2496                     fclose(ost->logfile);
2497                     ost->logfile = NULL;
2498                 }
2499                 av_freep(&ost->st->codec->subtitle_header);
2500                 av_free(ost->forced_kf_pts);
2501                 av_dict_free(&ost->opts);
2502                 av_dict_free(&ost->resample_opts);
2503             }
2504         }
2505     }
2506     return ret;
2507 }
2508
2509 static int64_t getutime(void)
2510 {
2511 #if HAVE_GETRUSAGE
2512     struct rusage rusage;
2513
2514     getrusage(RUSAGE_SELF, &rusage);
2515     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
2516 #elif HAVE_GETPROCESSTIMES
2517     HANDLE proc;
2518     FILETIME c, e, k, u;
2519     proc = GetCurrentProcess();
2520     GetProcessTimes(proc, &c, &e, &k, &u);
2521     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
2522 #else
2523     return av_gettime();
2524 #endif
2525 }
2526
2527 static int64_t getmaxrss(void)
2528 {
2529 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
2530     struct rusage rusage;
2531     getrusage(RUSAGE_SELF, &rusage);
2532     return (int64_t)rusage.ru_maxrss * 1024;
2533 #elif HAVE_GETPROCESSMEMORYINFO
2534     HANDLE proc;
2535     PROCESS_MEMORY_COUNTERS memcounters;
2536     proc = GetCurrentProcess();
2537     memcounters.cb = sizeof(memcounters);
2538     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
2539     return memcounters.PeakPagefileUsage;
2540 #else
2541     return 0;
2542 #endif
2543 }
2544
2545 int main(int argc, char **argv)
2546 {
2547     int ret;
2548     int64_t ti;
2549
2550     register_exit(avconv_cleanup);
2551
2552     av_log_set_flags(AV_LOG_SKIP_REPEATED);
2553     parse_loglevel(argc, argv, options);
2554
2555     avcodec_register_all();
2556 #if CONFIG_AVDEVICE
2557     avdevice_register_all();
2558 #endif
2559     avfilter_register_all();
2560     av_register_all();
2561     avformat_network_init();
2562
2563     show_banner();
2564
2565     /* parse options and open all input/output files */
2566     ret = avconv_parse_options(argc, argv);
2567     if (ret < 0)
2568         exit_program(1);
2569
2570     if (nb_output_files <= 0 && nb_input_files == 0) {
2571         show_usage();
2572         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
2573         exit_program(1);
2574     }
2575
2576     /* file converter / grab */
2577     if (nb_output_files <= 0) {
2578         fprintf(stderr, "At least one output file must be specified\n");
2579         exit_program(1);
2580     }
2581
2582     ti = getutime();
2583     if (transcode() < 0)
2584         exit_program(1);
2585     ti = getutime() - ti;
2586     if (do_benchmark) {
2587         int maxrss = getmaxrss() / 1024;
2588         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
2589     }
2590
2591     exit_program(0);
2592     return 0;
2593 }