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