avconv: link '-passlogfile' option to libx264 'stats' AVOption.
[libav.git] / avconv.c
CommitLineData
6291d7e4
AK
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 <unistd.h>
31#include "libavformat/avformat.h"
32#include "libavdevice/avdevice.h"
33#include "libswscale/swscale.h"
34#include "libavutil/opt.h"
35#include "libavcodec/audioconvert.h"
36#include "libavutil/audioconvert.h"
37#include "libavutil/parseutils.h"
38#include "libavutil/samplefmt.h"
39#include "libavutil/colorspace.h"
40#include "libavutil/fifo.h"
41#include "libavutil/intreadwrite.h"
42#include "libavutil/dict.h"
43#include "libavutil/mathematics.h"
44#include "libavutil/pixdesc.h"
45#include "libavutil/avstring.h"
46#include "libavutil/libm.h"
64dca32c 47#include "libavutil/imgutils.h"
6291d7e4
AK
48#include "libavformat/os_support.h"
49
50#if CONFIG_AVFILTER
51# include "libavfilter/avfilter.h"
52# include "libavfilter/avfiltergraph.h"
04a14d4d 53# include "libavfilter/buffersrc.h"
6291d7e4
AK
54# include "libavfilter/vsrc_buffer.h"
55#endif
56
57#if HAVE_SYS_RESOURCE_H
58#include <sys/types.h>
59#include <sys/time.h>
60#include <sys/resource.h>
61#elif HAVE_GETPROCESSTIMES
62#include <windows.h>
63#endif
64#if HAVE_GETPROCESSMEMORYINFO
65#include <windows.h>
66#include <psapi.h>
67#endif
68
69#if HAVE_SYS_SELECT_H
70#include <sys/select.h>
71#endif
72
73#include <time.h>
74
75#include "cmdutils.h"
76
77#include "libavutil/avassert.h"
78
e8c04f62
AK
79#define VSYNC_AUTO -1
80#define VSYNC_PASSTHROUGH 0
81#define VSYNC_CFR 1
82#define VSYNC_VFR 2
83
6291d7e4
AK
84const char program_name[] = "avconv";
85const int program_birth_year = 2000;
86
87/* select an input stream for an output stream */
88typedef struct StreamMap {
8d2e4a7e 89 int disabled; /** 1 is this mapping is disabled by a negative map */
6291d7e4
AK
90 int file_index;
91 int stream_index;
92 int sync_file_index;
93 int sync_stream_index;
94} StreamMap;
95
96/**
97 * select an input file for an output file
98 */
99typedef struct MetadataMap {
02494787
DB
100 int file; ///< file index
101 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
102 int index; ///< stream/chapter/program number
6291d7e4
AK
103} MetadataMap;
104
6291d7e4
AK
105static const OptionDef options[];
106
6291d7e4 107static int video_discard = 0;
f4ad238c 108static int same_quant = 0;
6291d7e4 109static int do_deinterlace = 0;
6291d7e4 110static int intra_dc_precision = 8;
6291d7e4 111static int qp_hist = 0;
6291d7e4 112
6291d7e4 113static int file_overwrite = 0;
6291d7e4
AK
114static int do_benchmark = 0;
115static int do_hex_dump = 0;
116static int do_pkt_dump = 0;
6291d7e4
AK
117static int do_pass = 0;
118static char *pass_logfilename_prefix = NULL;
e8c04f62 119static int video_sync_method = VSYNC_AUTO;
7636c8c6
AD
120static int audio_sync_method = 0;
121static float audio_drift_threshold = 0.1;
122static int copy_ts = 0;
7bb3e625 123static int copy_tb = 1;
6291d7e4
AK
124static int opt_shortest = 0;
125static char *vstats_filename;
126static FILE *vstats_file;
6291d7e4 127
6291d7e4
AK
128static int audio_volume = 256;
129
130static int exit_on_error = 0;
131static int using_stdin = 0;
6291d7e4
AK
132static int64_t video_size = 0;
133static int64_t audio_size = 0;
134static int64_t extra_size = 0;
135static int nb_frames_dup = 0;
136static int nb_frames_drop = 0;
137static int input_sync;
6291d7e4
AK
138
139static float dts_delta_threshold = 10;
140
3460dd8a
AK
141static int print_stats = 1;
142
6291d7e4 143static uint8_t *audio_buf;
ee458cb1 144static unsigned int allocated_audio_buf_size;
6291d7e4 145
6291d7e4
AK
146#define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
147
64dca32c
AK
148typedef struct FrameBuffer {
149 uint8_t *base[4];
150 uint8_t *data[4];
151 int linesize[4];
152
153 int h, w;
154 enum PixelFormat pix_fmt;
155
156 int refcount;
157 struct InputStream *ist;
158 struct FrameBuffer *next;
159} FrameBuffer;
160
6494c001
AK
161typedef struct InputStream {
162 int file_index;
163 AVStream *st;
164 int discard; /* true if stream data should be discarded */
165 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
166 AVCodec *dec;
9179f27c
JR
167 AVFrame *decoded_frame;
168 AVFrame *filtered_frame;
6494c001
AK
169
170 int64_t start; /* time when read started */
3101bb66
AK
171 /* predicted dts of the next packet read for this stream or (when there are
172 * several frames in a packet) of the next frame in current packet */
173 int64_t next_dts;
23576b3f
AK
174 /* dts of the last packet read for this stream */
175 int64_t last_dts;
6494c001
AK
176 PtsCorrectionContext pts_ctx;
177 double ts_scale;
178 int is_start; /* is 1 at the start and after a discontinuity */
179 int showed_multi_packet_warning;
180 AVDictionary *opts;
64dca32c
AK
181
182 /* a pool of free buffers for decoded data */
183 FrameBuffer *buffer_pool;
6494c001
AK
184} InputStream;
185
186typedef struct InputFile {
187 AVFormatContext *ctx;
188 int eof_reached; /* true if eof reached */
189 int ist_index; /* index of first stream in ist_table */
190 int buffer_size; /* current total buffer size */
191 int64_t ts_offset;
ed5b1326
AK
192 int nb_streams; /* number of stream that avconv is aware of; may be different
193 from ctx.nb_streams if new streams appear during av_read_frame() */
f4805328 194 int rate_emu;
6494c001 195} InputFile;
6291d7e4
AK
196
197typedef struct OutputStream {
198 int file_index; /* file index */
199 int index; /* stream index in the output file */
200 int source_index; /* InputStream index */
201 AVStream *st; /* stream in the output file */
202 int encoding_needed; /* true if encoding needed for this stream */
203 int frame_number;
204 /* input pts and corresponding output pts
205 for A/V sync */
7636c8c6 206 // double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
6291d7e4 207 struct InputStream *sync_ist; /* input stream to sync against */
7636c8c6 208 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
1270e12e
AK
209 /* pts of the first frame encoded for this stream, used for limiting
210 * recording time */
211 int64_t first_pts;
6291d7e4
AK
212 AVBitStreamFilterContext *bitstream_filters;
213 AVCodec *enc;
96139b5e 214 int64_t max_frames;
ee458cb1 215 AVFrame *output_frame;
6291d7e4
AK
216
217 /* video only */
218 int video_resample;
219 AVFrame pict_tmp; /* temporary image for resampling */
220 struct SwsContext *img_resample_ctx; /* for image resampling */
221 int resample_height;
222 int resample_width;
223 int resample_pix_fmt;
224 AVRational frame_rate;
bef737a7 225 int force_fps;
828e0bcb 226 int top_field_first;
6291d7e4
AK
227
228 float frame_aspect_ratio;
229
230 /* forced key frames */
231 int64_t *forced_kf_pts;
232 int forced_kf_count;
233 int forced_kf_index;
234
235 /* audio only */
236 int audio_resample;
237 ReSampleContext *resample; /* for audio resampling */
238 int resample_sample_fmt;
239 int resample_channels;
240 int resample_sample_rate;
241 int reformat_pair;
242 AVAudioConvert *reformat_ctx;
243 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
244 FILE *logfile;
245
246#if CONFIG_AVFILTER
247 AVFilterContext *output_video_filter;
248 AVFilterContext *input_video_filter;
249 AVFilterBufferRef *picref;
250 char *avfilter;
251 AVFilterGraph *graph;
252#endif
253
f8c314c8
AK
254 int64_t sws_flags;
255 AVDictionary *opts;
256 int is_past_recording_time;
257 int stream_copy;
258 const char *attachment_filename;
259 int copy_initial_nonkeyframes;
6291d7e4
AK
260} OutputStream;
261
6291d7e4 262
af70aa45
AK
263typedef struct OutputFile {
264 AVFormatContext *ctx;
265 AVDictionary *opts;
4288e031 266 int ost_index; /* index of the first stream in output_streams */
ef44a607 267 int64_t recording_time; /* desired length of the resulting file in microseconds */
ea065176 268 int64_t start_time; /* start time in microseconds */
f21f294e 269 uint64_t limit_filesize;
af70aa45
AK
270} OutputFile;
271
7636c8c6 272static InputStream *input_streams = NULL;
6291d7e4 273static int nb_input_streams = 0;
7636c8c6 274static InputFile *input_files = NULL;
6291d7e4
AK
275static int nb_input_files = 0;
276
4288e031
AK
277static OutputStream *output_streams = NULL;
278static int nb_output_streams = 0;
af70aa45
AK
279static OutputFile *output_files = NULL;
280static int nb_output_files = 0;
281
575ec4e1 282typedef struct OptionsContext {
6b779ccc
AK
283 /* input/output options */
284 int64_t start_time;
7041bb3b 285 const char *format;
6b779ccc 286
35e6f8c1
AK
287 SpecifierOpt *codec_names;
288 int nb_codec_names;
6a11686d
AK
289 SpecifierOpt *audio_channels;
290 int nb_audio_channels;
e2469ccf
AK
291 SpecifierOpt *audio_sample_rate;
292 int nb_audio_sample_rate;
91ea4811
AK
293 SpecifierOpt *frame_rates;
294 int nb_frame_rates;
d4397b03
AK
295 SpecifierOpt *frame_sizes;
296 int nb_frame_sizes;
b2254d83
AK
297 SpecifierOpt *frame_pix_fmts;
298 int nb_frame_pix_fmts;
35e6f8c1 299
6b779ccc
AK
300 /* input options */
301 int64_t input_ts_offset;
f4805328 302 int rate_emu;
6b779ccc 303
33f75d72
AK
304 SpecifierOpt *ts_scale;
305 int nb_ts_scale;
a2c0b830
AK
306 SpecifierOpt *dump_attachment;
307 int nb_dump_attachment;
33f75d72 308
575ec4e1
AK
309 /* output options */
310 StreamMap *stream_maps;
311 int nb_stream_maps;
847529f8
AK
312 /* first item specifies output metadata, second is input */
313 MetadataMap (*meta_data_maps)[2];
314 int nb_meta_data_maps;
315 int metadata_global_manual;
316 int metadata_streams_manual;
317 int metadata_chapters_manual;
4dbc6cee
AK
318 const char **attachments;
319 int nb_attachments;
6b779ccc 320
c5bb372e
AK
321 int chapters_input_file;
322
6b779ccc 323 int64_t recording_time;
13ccba50 324 uint64_t limit_filesize;
dc26318c
AK
325 float mux_preload;
326 float mux_max_delay;
039267f1 327
2130981a
AK
328 int video_disable;
329 int audio_disable;
330 int subtitle_disable;
331 int data_disable;
332
495ecfd1
AK
333 /* indexed by output file stream index */
334 int *streamid_map;
335 int nb_streamid_map;
336
039267f1
AK
337 SpecifierOpt *metadata;
338 int nb_metadata;
96139b5e
AK
339 SpecifierOpt *max_frames;
340 int nb_max_frames;
d821cbe2
AK
341 SpecifierOpt *bitstream_filters;
342 int nb_bitstream_filters;
013887eb
AK
343 SpecifierOpt *codec_tags;
344 int nb_codec_tags;
05bffc12
AK
345 SpecifierOpt *sample_fmts;
346 int nb_sample_fmts;
77d9c454
AK
347 SpecifierOpt *qscale;
348 int nb_qscale;
7c029672
AK
349 SpecifierOpt *forced_key_frames;
350 int nb_forced_key_frames;
bef737a7
AK
351 SpecifierOpt *force_fps;
352 int nb_force_fps;
ca46fde7
AK
353 SpecifierOpt *frame_aspect_ratios;
354 int nb_frame_aspect_ratios;
0e68c783
AK
355 SpecifierOpt *rc_overrides;
356 int nb_rc_overrides;
2c2cff16
AK
357 SpecifierOpt *intra_matrices;
358 int nb_intra_matrices;
359 SpecifierOpt *inter_matrices;
360 int nb_inter_matrices;
828e0bcb
AK
361 SpecifierOpt *top_field_first;
362 int nb_top_field_first;
a7b5e841
AK
363 SpecifierOpt *metadata_map;
364 int nb_metadata_map;
3ec34462
AK
365 SpecifierOpt *presets;
366 int nb_presets;
a2aeeb22
AK
367 SpecifierOpt *copy_initial_nonkeyframes;
368 int nb_copy_initial_nonkeyframes;
8e5ce590
AK
369#if CONFIG_AVFILTER
370 SpecifierOpt *filters;
371 int nb_filters;
372#endif
575ec4e1
AK
373} OptionsContext;
374
35e6f8c1
AK
375#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
376{\
377 int i, ret;\
378 for (i = 0; i < o->nb_ ## name; i++) {\
379 char *spec = o->name[i].specifier;\
380 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
381 outvar = o->name[i].u.type;\
382 else if (ret < 0)\
383 exit_program(1);\
384 }\
385}
386
575ec4e1
AK
387static void reset_options(OptionsContext *o)
388{
389 const OptionDef *po = options;
390
391 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
392 while (po->name) {
393 void *dst = (uint8_t*)o + po->u.off;
394
395 if (po->flags & OPT_SPEC) {
396 SpecifierOpt **so = dst;
397 int i, *count = (int*)(so + 1);
398 for (i = 0; i < *count; i++) {
399 av_freep(&(*so)[i].specifier);
400 if (po->flags & OPT_STRING)
401 av_freep(&(*so)[i].u.str);
402 }
403 av_freep(so);
404 *count = 0;
405 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
406 av_freep(dst);
407 po++;
408 }
409
410 av_freep(&o->stream_maps);
847529f8 411 av_freep(&o->meta_data_maps);
495ecfd1 412 av_freep(&o->streamid_map);
575ec4e1
AK
413
414 memset(o, 0, sizeof(*o));
6b779ccc 415
dc26318c 416 o->mux_max_delay = 0.7;
6b779ccc 417 o->recording_time = INT64_MAX;
13ccba50 418 o->limit_filesize = UINT64_MAX;
c5bb372e 419 o->chapters_input_file = INT_MAX;
6b779ccc 420
575ec4e1
AK
421 uninit_opts();
422 init_opts();
423}
424
64dca32c
AK
425static int alloc_buffer(InputStream *ist, FrameBuffer **pbuf)
426{
427 AVCodecContext *s = ist->st->codec;
428 FrameBuffer *buf = av_mallocz(sizeof(*buf));
3715d841 429 int i, ret;
64dca32c
AK
430 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
431 int h_chroma_shift, v_chroma_shift;
432 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
433 int w = s->width, h = s->height;
434
435 if (!buf)
436 return AVERROR(ENOMEM);
437
438 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
439 w += 2*edge;
440 h += 2*edge;
441 }
442
443 avcodec_align_dimensions(s, &w, &h);
444 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
445 s->pix_fmt, 32)) < 0) {
446 av_freep(&buf);
447 return ret;
448 }
449 /* XXX this shouldn't be needed, but some tests break without this line
450 * those decoders are buggy and need to be fixed.
451 * the following tests fail:
f320fb89 452 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
64dca32c
AK
453 */
454 memset(buf->base[0], 128, ret);
455
456 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
3715d841 457 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
64dca32c
AK
458 const int h_shift = i==0 ? 0 : h_chroma_shift;
459 const int v_shift = i==0 ? 0 : v_chroma_shift;
460 if (s->flags & CODEC_FLAG_EMU_EDGE)
461 buf->data[i] = buf->base[i];
462 else
463 buf->data[i] = buf->base[i] +
464 FFALIGN((buf->linesize[i]*edge >> v_shift) +
465 (pixel_size*edge >> h_shift), 32);
466 }
467 buf->w = s->width;
468 buf->h = s->height;
469 buf->pix_fmt = s->pix_fmt;
470 buf->ist = ist;
471
472 *pbuf = buf;
473 return 0;
474}
475
476static void free_buffer_pool(InputStream *ist)
477{
478 FrameBuffer *buf = ist->buffer_pool;
479 while (buf) {
480 ist->buffer_pool = buf->next;
481 av_freep(&buf->base[0]);
482 av_free(buf);
483 buf = ist->buffer_pool;
484 }
485}
486
487static void unref_buffer(InputStream *ist, FrameBuffer *buf)
488{
489 av_assert0(buf->refcount);
490 buf->refcount--;
491 if (!buf->refcount) {
492 buf->next = ist->buffer_pool;
493 ist->buffer_pool = buf;
494 }
495}
496
497static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
498{
499 InputStream *ist = s->opaque;
500 FrameBuffer *buf;
501 int ret, i;
502
503 if (!ist->buffer_pool && (ret = alloc_buffer(ist, &ist->buffer_pool)) < 0)
504 return ret;
505
506 buf = ist->buffer_pool;
507 ist->buffer_pool = buf->next;
508 buf->next = NULL;
509 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
510 av_freep(&buf->base[0]);
511 av_free(buf);
512 if ((ret = alloc_buffer(ist, &buf)) < 0)
513 return ret;
514 }
515 buf->refcount++;
516
517 frame->opaque = buf;
518 frame->type = FF_BUFFER_TYPE_USER;
519 frame->extended_data = frame->data;
520 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
521
522 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
523 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
524 frame->data[i] = buf->data[i];
525 frame->linesize[i] = buf->linesize[i];
526 }
527
528 return 0;
529}
530
531static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
532{
533 InputStream *ist = s->opaque;
534 FrameBuffer *buf = frame->opaque;
535 int i;
536
537 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
538 frame->data[i] = NULL;
539
540 unref_buffer(ist, buf);
541}
542
04a14d4d
AK
543static void filter_release_buffer(AVFilterBuffer *fb)
544{
545 FrameBuffer *buf = fb->priv;
546 av_free(fb);
547 unref_buffer(buf->ist, buf);
548}
549
6291d7e4
AK
550#if CONFIG_AVFILTER
551
552static int configure_video_filters(InputStream *ist, OutputStream *ost)
553{
554 AVFilterContext *last_filter, *filter;
555 /** filter graph containing all filters including input & output */
556 AVCodecContext *codec = ost->st->codec;
557 AVCodecContext *icodec = ist->st->codec;
abe655a4 558 SinkContext sink_ctx = { .pix_fmt = codec->pix_fmt };
6291d7e4
AK
559 AVRational sample_aspect_ratio;
560 char args[255];
561 int ret;
562
563 ost->graph = avfilter_graph_alloc();
564
7636c8c6 565 if (ist->st->sample_aspect_ratio.num) {
6291d7e4 566 sample_aspect_ratio = ist->st->sample_aspect_ratio;
7636c8c6 567 } else
6291d7e4
AK
568 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
569
570 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
571 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
572 sample_aspect_ratio.num, sample_aspect_ratio.den);
573
574 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
575 "src", args, NULL, ost->graph);
576 if (ret < 0)
577 return ret;
abe655a4
DB
578 ret = avfilter_graph_create_filter(&ost->output_video_filter, &sink,
579 "out", NULL, &sink_ctx, ost->graph);
6291d7e4
AK
580 if (ret < 0)
581 return ret;
582 last_filter = ost->input_video_filter;
583
7636c8c6 584 if (codec->width != icodec->width || codec->height != icodec->height) {
6291d7e4
AK
585 snprintf(args, 255, "%d:%d:flags=0x%X",
586 codec->width,
587 codec->height,
3b3ea346 588 (unsigned)ost->sws_flags);
6291d7e4
AK
589 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
590 NULL, args, NULL, ost->graph)) < 0)
591 return ret;
592 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
593 return ret;
594 last_filter = filter;
595 }
596
3b3ea346 597 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
6291d7e4
AK
598 ost->graph->scale_sws_opts = av_strdup(args);
599
600 if (ost->avfilter) {
601 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
602 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
603
604 outputs->name = av_strdup("in");
605 outputs->filter_ctx = last_filter;
606 outputs->pad_idx = 0;
607 outputs->next = NULL;
608
609 inputs->name = av_strdup("out");
610 inputs->filter_ctx = ost->output_video_filter;
611 inputs->pad_idx = 0;
612 inputs->next = NULL;
613
614 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
615 return ret;
6291d7e4
AK
616 } else {
617 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
618 return ret;
619 }
620
621 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
622 return ret;
623
624 codec->width = ost->output_video_filter->inputs[0]->w;
625 codec->height = ost->output_video_filter->inputs[0]->h;
626 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
bb337b4f 627 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
7636c8c6 628 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
6291d7e4
AK
629 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
630
631 return 0;
632}
633#endif /* CONFIG_AVFILTER */
634
635static void term_exit(void)
636{
637 av_log(NULL, AV_LOG_QUIET, "");
638}
639
640static volatile int received_sigterm = 0;
641static volatile int received_nb_signals = 0;
642
643static void
644sigterm_handler(int sig)
645{
646 received_sigterm = sig;
647 received_nb_signals++;
648 term_exit();
649}
650
651static void term_init(void)
652{
7636c8c6 653 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
6291d7e4
AK
654 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
655#ifdef SIGXCPU
656 signal(SIGXCPU, sigterm_handler);
657#endif
658}
659
2abe947a 660static int decode_interrupt_cb(void *ctx)
6291d7e4
AK
661{
662 return received_nb_signals > 1;
663}
664
2abe947a
MS
665static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
666
dad09ff9 667void exit_program(int ret)
6291d7e4
AK
668{
669 int i;
670
671 /* close files */
7636c8c6 672 for (i = 0; i < nb_output_files; i++) {
af70aa45 673 AVFormatContext *s = output_files[i].ctx;
6291d7e4
AK
674 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
675 avio_close(s->pb);
676 avformat_free_context(s);
af70aa45 677 av_dict_free(&output_files[i].opts);
6291d7e4 678 }
1135a071
JG
679 for (i = 0; i < nb_output_streams; i++) {
680 AVBitStreamFilterContext *bsfc = output_streams[i].bitstream_filters;
681 while (bsfc) {
682 AVBitStreamFilterContext *next = bsfc->next;
683 av_bitstream_filter_close(bsfc);
684 bsfc = next;
685 }
686 output_streams[i].bitstream_filters = NULL;
ac646076 687
ee458cb1
JR
688 if (output_streams[i].output_frame) {
689 AVFrame *frame = output_streams[i].output_frame;
690 if (frame->extended_data != frame->data)
691 av_freep(&frame->extended_data);
692 av_freep(&frame);
693 }
694
ac646076
AK
695#if CONFIG_AVFILTER
696 av_freep(&output_streams[i].avfilter);
697#endif
1135a071 698 }
7636c8c6 699 for (i = 0; i < nb_input_files; i++) {
cd3716b9 700 avformat_close_input(&input_files[i].ctx);
6291d7e4 701 }
9179f27c
JR
702 for (i = 0; i < nb_input_streams; i++) {
703 av_freep(&input_streams[i].decoded_frame);
704 av_freep(&input_streams[i].filtered_frame);
6291d7e4 705 av_dict_free(&input_streams[i].opts);
64dca32c 706 free_buffer_pool(&input_streams[i]);
9179f27c 707 }
6291d7e4 708
6291d7e4
AK
709 if (vstats_file)
710 fclose(vstats_file);
711 av_free(vstats_filename);
712
6291d7e4
AK
713 av_freep(&input_streams);
714 av_freep(&input_files);
4288e031 715 av_freep(&output_streams);
af70aa45 716 av_freep(&output_files);
6291d7e4 717
6291d7e4
AK
718 uninit_opts();
719 av_free(audio_buf);
ee458cb1 720 allocated_audio_buf_size = 0;
6291d7e4
AK
721
722#if CONFIG_AVFILTER
723 avfilter_uninit();
724#endif
776f2bb9 725 avformat_network_deinit();
6291d7e4
AK
726
727 if (received_sigterm) {
e3245b26
AK
728 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
729 (int) received_sigterm);
6291d7e4
AK
730 exit (255);
731 }
732
f75e3d25 733 exit(ret);
6291d7e4
AK
734}
735
736static void assert_avoptions(AVDictionary *m)
737{
738 AVDictionaryEntry *t;
739 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
f24facd3 740 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
6291d7e4
AK
741 exit_program(1);
742 }
743}
744
745static void assert_codec_experimental(AVCodecContext *c, int encoder)
746{
747 const char *codec_string = encoder ? "encoder" : "decoder";
748 AVCodec *codec;
749 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
750 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
f24facd3 751 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
6291d7e4
AK
752 "results.\nAdd '-strict experimental' if you want to use it.\n",
753 codec_string, c->codec->name);
754 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
755 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
f24facd3 756 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
6291d7e4
AK
757 codec_string, codec->name);
758 exit_program(1);
759 }
760}
761
6291d7e4
AK
762static void choose_sample_fmt(AVStream *st, AVCodec *codec)
763{
7636c8c6
AD
764 if (codec && codec->sample_fmts) {
765 const enum AVSampleFormat *p = codec->sample_fmts;
766 for (; *p != -1; p++) {
767 if (*p == st->codec->sample_fmt)
6291d7e4
AK
768 break;
769 }
770 if (*p == -1) {
771 av_log(NULL, AV_LOG_WARNING,
772 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
773 av_get_sample_fmt_name(st->codec->sample_fmt),
774 codec->name,
775 av_get_sample_fmt_name(codec->sample_fmts[0]));
776 st->codec->sample_fmt = codec->sample_fmts[0];
777 }
778 }
779}
780
781/**
782 * Update the requested input sample format based on the output sample format.
783 * This is currently only used to request float output from decoders which
784 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
785 * Ideally this will be removed in the future when decoders do not do format
786 * conversion and only output in their native format.
787 */
788static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
789 AVCodecContext *enc)
790{
791 /* if sample formats match or a decoder sample format has already been
792 requested, just return */
793 if (enc->sample_fmt == dec->sample_fmt ||
794 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
795 return;
796
797 /* if decoder supports more than one output format */
798 if (dec_codec && dec_codec->sample_fmts &&
799 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
800 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
801 const enum AVSampleFormat *p;
802 int min_dec = -1, min_inc = -1;
803
804 /* find a matching sample format in the encoder */
805 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
806 if (*p == enc->sample_fmt) {
807 dec->request_sample_fmt = *p;
808 return;
809 } else if (*p > enc->sample_fmt) {
810 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
811 } else
812 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
813 }
814
815 /* if none match, provide the one that matches quality closest */
816 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
817 enc->sample_fmt - min_dec;
818 }
819}
820
821static void choose_sample_rate(AVStream *st, AVCodec *codec)
822{
7636c8c6
AD
823 if (codec && codec->supported_samplerates) {
824 const int *p = codec->supported_samplerates;
825 int best = 0;
826 int best_dist = INT_MAX;
827 for (; *p; p++) {
828 int dist = abs(st->codec->sample_rate - *p);
829 if (dist < best_dist) {
830 best_dist = dist;
831 best = *p;
6291d7e4
AK
832 }
833 }
7636c8c6 834 if (best_dist) {
6291d7e4
AK
835 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
836 }
7636c8c6 837 st->codec->sample_rate = best;
6291d7e4
AK
838 }
839}
840
841static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
842{
7636c8c6
AD
843 if (codec && codec->pix_fmts) {
844 const enum PixelFormat *p = codec->pix_fmts;
845 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
846 if (st->codec->codec_id == CODEC_ID_MJPEG) {
847 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
848 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
849 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
850 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
6291d7e4
AK
851 }
852 }
105ab61c 853 for (; *p != PIX_FMT_NONE; p++) {
7636c8c6 854 if (*p == st->codec->pix_fmt)
6291d7e4
AK
855 break;
856 }
105ab61c 857 if (*p == PIX_FMT_NONE) {
7636c8c6 858 if (st->codec->pix_fmt != PIX_FMT_NONE)
6291d7e4 859 av_log(NULL, AV_LOG_WARNING,
7636c8c6
AD
860 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
861 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
862 codec->name,
863 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
6291d7e4
AK
864 st->codec->pix_fmt = codec->pix_fmts[0];
865 }
866 }
867}
868
6291d7e4 869static double
6e983902 870get_sync_ipts(const OutputStream *ost, int64_t pts)
6291d7e4 871{
ea065176 872 OutputFile *of = &output_files[ost->file_index];
6e983902 873 return (double)(pts - of->start_time) / AV_TIME_BASE;
6291d7e4
AK
874}
875
f15f02c2 876static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
7636c8c6 877{
f15f02c2
AK
878 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
879 AVCodecContext *avctx = ost->st->codec;
6291d7e4
AK
880 int ret;
881
99932847
AK
882 /*
883 * Audio encoders may split the packets -- #frames in != #packets out.
884 * But there is no reordering, so we can limit the number of output packets
885 * by simply dropping them here.
886 * Counting encoded video frames needs to be done separately because of
887 * reordering, see do_video_out()
888 */
889 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
890 if (ost->frame_number >= ost->max_frames)
891 return;
892 ost->frame_number++;
893 }
894
7636c8c6
AD
895 while (bsfc) {
896 AVPacket new_pkt = *pkt;
897 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
898 &new_pkt.data, &new_pkt.size,
899 pkt->data, pkt->size,
900 pkt->flags & AV_PKT_FLAG_KEY);
901 if (a > 0) {
6291d7e4 902 av_free_packet(pkt);
7636c8c6
AD
903 new_pkt.destruct = av_destruct_packet;
904 } else if (a < 0) {
e3245b26
AK
905 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
906 bsfc->filter->name, pkt->stream_index,
907 avctx->codec ? avctx->codec->name : "copy");
6291d7e4
AK
908 print_error("", a);
909 if (exit_on_error)
910 exit_program(1);
911 }
7636c8c6 912 *pkt = new_pkt;
6291d7e4 913
7636c8c6 914 bsfc = bsfc->next;
6291d7e4
AK
915 }
916
61a09968 917 pkt->stream_index = ost->index;
7636c8c6
AD
918 ret = av_interleaved_write_frame(s, pkt);
919 if (ret < 0) {
6291d7e4
AK
920 print_error("av_interleaved_write_frame()", ret);
921 exit_program(1);
922 }
923}
924
1270e12e
AK
925static int check_recording_time(OutputStream *ost)
926{
927 OutputFile *of = &output_files[ost->file_index];
928
929 if (of->recording_time != INT64_MAX &&
930 av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
931 AV_TIME_BASE_Q) >= 0) {
932 ost->is_past_recording_time = 1;
933 return 0;
934 }
935 return 1;
936}
937
fdab793a
AC
938static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
939{
940 int fill_char = 0x00;
941 if (sample_fmt == AV_SAMPLE_FMT_U8)
942 fill_char = 0x80;
943 memset(buf, fill_char, size);
944}
945
ee458cb1
JR
946static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
947 const uint8_t *buf, int buf_size)
948{
949 AVCodecContext *enc = ost->st->codec;
950 AVFrame *frame = NULL;
951 AVPacket pkt;
952 int ret, got_packet;
953
954 av_init_packet(&pkt);
955 pkt.data = NULL;
956 pkt.size = 0;
957
958 if (buf) {
959 if (!ost->output_frame) {
960 ost->output_frame = avcodec_alloc_frame();
961 if (!ost->output_frame) {
962 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
963 exit_program(1);
964 }
965 }
966 frame = ost->output_frame;
967 if (frame->extended_data != frame->data)
968 av_freep(&frame->extended_data);
969 avcodec_get_frame_defaults(frame);
970
971 frame->nb_samples = buf_size /
972 (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
973 if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
974 buf, buf_size, 1)) < 0) {
975 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
976 exit_program(1);
977 }
1270e12e
AK
978
979 if (!check_recording_time(ost))
980 return 0;
981
982 ost->sync_opts += frame->nb_samples;
ee458cb1
JR
983 }
984
985 got_packet = 0;
986 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
987 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
988 exit_program(1);
989 }
990
991 if (got_packet) {
ee458cb1
JR
992 if (pkt.pts != AV_NOPTS_VALUE)
993 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
a75bc764
JR
994 if (pkt.dts != AV_NOPTS_VALUE)
995 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
ee458cb1
JR
996 if (pkt.duration > 0)
997 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
998
999 write_frame(s, &pkt, ost);
1000
1001 audio_size += pkt.size;
1002 }
1003
ee458cb1
JR
1004 return pkt.size;
1005}
1006
d1241ff3
JR
1007static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1008 InputStream *ist, AVFrame *decoded_frame)
6291d7e4
AK
1009{
1010 uint8_t *buftmp;
ee458cb1 1011 int64_t audio_buf_size;
6291d7e4 1012
ee458cb1 1013 int size_out, frame_bytes, resample_changed;
7636c8c6
AD
1014 AVCodecContext *enc = ost->st->codec;
1015 AVCodecContext *dec = ist->st->codec;
6291d7e4
AK
1016 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1017 int isize = av_get_bytes_per_sample(dec->sample_fmt);
d1241ff3
JR
1018 uint8_t *buf = decoded_frame->data[0];
1019 int size = decoded_frame->nb_samples * dec->channels * isize;
1020 int64_t allocated_for_size = size;
6291d7e4
AK
1021
1022need_realloc:
7636c8c6
AD
1023 audio_buf_size = (allocated_for_size + isize * dec->channels - 1) / (isize * dec->channels);
1024 audio_buf_size = (audio_buf_size * enc->sample_rate + dec->sample_rate) / dec->sample_rate;
1025 audio_buf_size = audio_buf_size * 2 + 10000; // safety factors for the deprecated resampling API
1026 audio_buf_size = FFMAX(audio_buf_size, enc->frame_size);
1027 audio_buf_size *= osize * enc->channels;
1028
ee458cb1 1029 if (audio_buf_size > INT_MAX) {
e3245b26 1030 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
6291d7e4
AK
1031 exit_program(1);
1032 }
1033
1034 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
ee458cb1 1035 if (!audio_buf) {
e3245b26 1036 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
6291d7e4
AK
1037 exit_program(1);
1038 }
1039
1040 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
1041 ost->audio_resample = 1;
1042
1043 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1044 ost->resample_channels != dec->channels ||
1045 ost->resample_sample_rate != dec->sample_rate;
1046
1047 if ((ost->audio_resample && !ost->resample) || resample_changed) {
1048 if (resample_changed) {
9a414d89 1049 av_log(NULL, AV_LOG_INFO, "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
6291d7e4
AK
1050 ist->file_index, ist->st->index,
1051 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
1052 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
1053 ost->resample_sample_fmt = dec->sample_fmt;
1054 ost->resample_channels = dec->channels;
1055 ost->resample_sample_rate = dec->sample_rate;
1056 if (ost->resample)
1057 audio_resample_close(ost->resample);
1058 }
1059 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1060 if (audio_sync_method <= 1 &&
1061 ost->resample_sample_fmt == enc->sample_fmt &&
1062 ost->resample_channels == enc->channels &&
1063 ost->resample_sample_rate == enc->sample_rate) {
1064 ost->resample = NULL;
1065 ost->audio_resample = 0;
1066 } else if (ost->audio_resample) {
1067 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
e3245b26 1068 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
6291d7e4
AK
1069 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
1070 enc->sample_rate, dec->sample_rate,
1071 enc->sample_fmt, dec->sample_fmt,
1072 16, 10, 0, 0.8);
1073 if (!ost->resample) {
e3245b26
AK
1074 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1075 dec->channels, dec->sample_rate,
1076 enc->channels, enc->sample_rate);
6291d7e4
AK
1077 exit_program(1);
1078 }
1079 }
1080 }
1081
1082#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
7636c8c6
AD
1083 if (!ost->audio_resample && dec->sample_fmt != enc->sample_fmt &&
1084 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt) != ost->reformat_pair) {
6291d7e4
AK
1085 if (ost->reformat_ctx)
1086 av_audio_convert_free(ost->reformat_ctx);
1087 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
1088 dec->sample_fmt, 1, NULL, 0);
1089 if (!ost->reformat_ctx) {
e3245b26
AK
1090 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
1091 av_get_sample_fmt_name(dec->sample_fmt),
1092 av_get_sample_fmt_name(enc->sample_fmt));
6291d7e4
AK
1093 exit_program(1);
1094 }
7636c8c6 1095 ost->reformat_pair = MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
6291d7e4
AK
1096 }
1097
7636c8c6 1098 if (audio_sync_method) {
23576b3f 1099 double delta = get_sync_ipts(ost, ist->last_dts) * enc->sample_rate - ost->sync_opts -
7636c8c6 1100 av_fifo_size(ost->fifo) / (enc->channels * osize);
fdab793a
AC
1101 int idelta = delta * dec->sample_rate / enc->sample_rate;
1102 int byte_delta = idelta * isize * dec->channels;
6291d7e4 1103
7636c8c6
AD
1104 // FIXME resample delay
1105 if (fabs(delta) > 50) {
1106 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1107 if (byte_delta < 0) {
1108 byte_delta = FFMAX(byte_delta, -size);
6291d7e4
AK
1109 size += byte_delta;
1110 buf -= byte_delta;
fdab793a
AC
1111 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1112 -byte_delta / (isize * dec->channels));
7636c8c6 1113 if (!size)
6291d7e4 1114 return;
7636c8c6
AD
1115 ist->is_start = 0;
1116 } else {
1117 static uint8_t *input_tmp = NULL;
1118 input_tmp = av_realloc(input_tmp, byte_delta + size);
6291d7e4 1119
7636c8c6
AD
1120 if (byte_delta > allocated_for_size - size) {
1121 allocated_for_size = byte_delta + (int64_t)size;
6291d7e4
AK
1122 goto need_realloc;
1123 }
7636c8c6 1124 ist->is_start = 0;
6291d7e4 1125
fdab793a 1126 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
6291d7e4 1127 memcpy(input_tmp + byte_delta, buf, size);
7636c8c6 1128 buf = input_tmp;
6291d7e4 1129 size += byte_delta;
fdab793a 1130 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
6291d7e4 1131 }
7636c8c6
AD
1132 } else if (audio_sync_method > 1) {
1133 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
6291d7e4 1134 av_assert0(ost->audio_resample);
e3245b26
AK
1135 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1136 delta, comp, enc->sample_rate);
6291d7e4
AK
1137// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
1138 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
1139 }
1140 }
7636c8c6 1141 } else
23576b3f 1142 ost->sync_opts = lrintf(get_sync_ipts(ost, ist->last_dts) * enc->sample_rate) -
7636c8c6 1143 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
6291d7e4
AK
1144
1145 if (ost->audio_resample) {
1146 buftmp = audio_buf;
1147 size_out = audio_resample(ost->resample,
1148 (short *)buftmp, (short *)buf,
1149 size / (dec->channels * isize));
1150 size_out = size_out * enc->channels * osize;
1151 } else {
1152 buftmp = buf;
1153 size_out = size;
1154 }
1155
7636c8c6
AD
1156 if (!ost->audio_resample && dec->sample_fmt != enc->sample_fmt) {
1157 const void *ibuf[6] = { buftmp };
1158 void *obuf[6] = { audio_buf };
1159 int istride[6] = { isize };
1160 int ostride[6] = { osize };
1161 int len = size_out / istride[0];
1162 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len) < 0) {
6291d7e4
AK
1163 printf("av_audio_convert() failed\n");
1164 if (exit_on_error)
1165 exit_program(1);
1166 return;
1167 }
1168 buftmp = audio_buf;
7636c8c6 1169 size_out = len * osize;
6291d7e4
AK
1170 }
1171
1172 /* now encode as many frames as possible */
ee458cb1 1173 if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
6291d7e4
AK
1174 /* output resampled raw samples */
1175 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
e3245b26 1176 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
6291d7e4
AK
1177 exit_program(1);
1178 }
1179 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1180
1181 frame_bytes = enc->frame_size * osize * enc->channels;
1182
1183 while (av_fifo_size(ost->fifo) >= frame_bytes) {
6291d7e4 1184 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
ee458cb1 1185 encode_audio_frame(s, ost, audio_buf, frame_bytes);
6291d7e4
AK
1186 }
1187 } else {
ee458cb1 1188 encode_audio_frame(s, ost, buftmp, size_out);
6291d7e4
AK
1189 }
1190}
1191
1192static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1193{
1194 AVCodecContext *dec;
1195 AVPicture *picture2;
1196 AVPicture picture_tmp;
1197 uint8_t *buf = 0;
1198
1199 dec = ist->st->codec;
1200
1201 /* deinterlace : must be done before any resize */
1202 if (do_deinterlace) {
1203 int size;
1204
1205 /* create temporary picture */
1206 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
7636c8c6 1207 buf = av_malloc(size);
6291d7e4
AK
1208 if (!buf)
1209 return;
1210
1211 picture2 = &picture_tmp;
1212 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1213
7636c8c6 1214 if (avpicture_deinterlace(picture2, picture,
6291d7e4
AK
1215 dec->pix_fmt, dec->width, dec->height) < 0) {
1216 /* if error, do not deinterlace */
e3245b26 1217 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
6291d7e4
AK
1218 av_free(buf);
1219 buf = NULL;
1220 picture2 = picture;
1221 }
1222 } else {
1223 picture2 = picture;
1224 }
1225
1226 if (picture != picture2)
1227 *picture = *picture2;
1228 *bufp = buf;
1229}
1230
6291d7e4
AK
1231static void do_subtitle_out(AVFormatContext *s,
1232 OutputStream *ost,
1233 InputStream *ist,
1234 AVSubtitle *sub,
1235 int64_t pts)
1236{
1237 static uint8_t *subtitle_out = NULL;
1238 int subtitle_out_max_size = 1024 * 1024;
1239 int subtitle_out_size, nb, i;
1240 AVCodecContext *enc;
1241 AVPacket pkt;
1242
1243 if (pts == AV_NOPTS_VALUE) {
e3245b26 1244 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
6291d7e4
AK
1245 if (exit_on_error)
1246 exit_program(1);
1247 return;
1248 }
1249
1250 enc = ost->st->codec;
1251
1252 if (!subtitle_out) {
1253 subtitle_out = av_malloc(subtitle_out_max_size);
1254 }
1255
1256 /* Note: DVB subtitle need one packet to draw them and one other
1257 packet to clear them */
1258 /* XXX: signal it in the codec context ? */
1259 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1260 nb = 2;
1261 else
1262 nb = 1;
1263
7636c8c6 1264 for (i = 0; i < nb; i++) {
1270e12e
AK
1265 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1266 if (!check_recording_time(ost))
1267 return;
1268
6291d7e4
AK
1269 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1270 // start_display_time is required to be 0
7636c8c6
AD
1271 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1272 sub->end_display_time -= sub->start_display_time;
6291d7e4
AK
1273 sub->start_display_time = 0;
1274 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1275 subtitle_out_max_size, sub);
1276 if (subtitle_out_size < 0) {
e3245b26 1277 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
6291d7e4
AK
1278 exit_program(1);
1279 }
1280
1281 av_init_packet(&pkt);
6291d7e4
AK
1282 pkt.data = subtitle_out;
1283 pkt.size = subtitle_out_size;
7636c8c6 1284 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
6291d7e4
AK
1285 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1286 /* XXX: the pts correction is handled here. Maybe handling
1287 it in the codec would be better */
1288 if (i == 0)
1289 pkt.pts += 90 * sub->start_display_time;
1290 else
1291 pkt.pts += 90 * sub->end_display_time;
1292 }
f15f02c2 1293 write_frame(s, &pkt, ost);
6291d7e4
AK
1294 }
1295}
1296
ac646076 1297#if !CONFIG_AVFILTER
87ef060c
AC
1298static void do_video_resample(OutputStream *ost,
1299 InputStream *ist,
1300 AVFrame *in_picture,
1301 AVFrame **out_picture)
6291d7e4 1302{
87ef060c 1303 int resample_changed = 0;
87ef060c 1304 *out_picture = in_picture;
6291d7e4 1305
b2ce3b99
AK
1306 resample_changed = ost->resample_width != in_picture->width ||
1307 ost->resample_height != in_picture->height ||
1308 ost->resample_pix_fmt != in_picture->format;
6291d7e4
AK
1309
1310 if (resample_changed) {
1311 av_log(NULL, AV_LOG_INFO,
9a414d89 1312 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
6291d7e4
AK
1313 ist->file_index, ist->st->index,
1314 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
b2ce3b99 1315 in_picture->width, in_picture->height, av_get_pix_fmt_name(in_picture->format));
7636c8c6 1316 if (!ost->video_resample)
5c59fa56 1317 ost->video_resample = 1;
6291d7e4
AK
1318 }
1319
6291d7e4 1320 if (ost->video_resample) {
87ef060c 1321 *out_picture = &ost->pict_tmp;
6291d7e4
AK
1322 if (resample_changed) {
1323 /* initialize a new scaler context */
1324 sws_freeContext(ost->img_resample_ctx);
1325 ost->img_resample_ctx = sws_getContext(
1326 ist->st->codec->width,
1327 ist->st->codec->height,
1328 ist->st->codec->pix_fmt,
1329 ost->st->codec->width,
1330 ost->st->codec->height,
1331 ost->st->codec->pix_fmt,
1332 ost->sws_flags, NULL, NULL, NULL);
1333 if (ost->img_resample_ctx == NULL) {
e3245b26 1334 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
6291d7e4
AK
1335 exit_program(1);
1336 }
1337 }
87ef060c
AC
1338 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1339 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
6291d7e4 1340 }
428c59d9 1341 if (resample_changed) {
b2ce3b99
AK
1342 ost->resample_width = in_picture->width;
1343 ost->resample_height = in_picture->height;
1344 ost->resample_pix_fmt = in_picture->format;
428c59d9 1345 }
87ef060c 1346}
ac646076 1347#endif
87ef060c
AC
1348
1349
1350static void do_video_out(AVFormatContext *s,
1351 OutputStream *ost,
1352 InputStream *ist,
1353 AVFrame *in_picture,
1354 int *frame_size, float quality)
1355{
553735f5 1356 int nb_frames, i, ret, format_video_sync;
87ef060c 1357 AVFrame *final_picture;
f593628e 1358 AVCodecContext *enc;
d43040e2 1359 double sync_ipts, delta;
87ef060c
AC
1360
1361 enc = ost->st->codec;
87ef060c 1362
6e983902 1363 sync_ipts = get_sync_ipts(ost, in_picture->pts) / av_q2d(enc->time_base);
d43040e2 1364 delta = sync_ipts - ost->sync_opts;
87ef060c
AC
1365
1366 /* by default, we output a single frame */
1367 nb_frames = 1;
1368
1369 *frame_size = 0;
1370
553735f5 1371 format_video_sync = video_sync_method;
e8c04f62
AK
1372 if (format_video_sync == VSYNC_AUTO)
1373 format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
1374 (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
553735f5 1375
d43040e2
AK
1376 switch (format_video_sync) {
1377 case VSYNC_CFR:
7636c8c6 1378 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
d43040e2 1379 if (delta < -1.1)
87ef060c 1380 nb_frames = 0;
d43040e2
AK
1381 else if (delta > 1.1)
1382 nb_frames = lrintf(delta);
1383 break;
1384 case VSYNC_VFR:
1385 if (delta <= -0.6)
1386 nb_frames = 0;
1387 else if (delta > 0.6)
1388 ost->sync_opts = lrintf(sync_ipts);
1389 break;
1390 case VSYNC_PASSTHROUGH:
7636c8c6 1391 ost->sync_opts = lrintf(sync_ipts);
d43040e2
AK
1392 break;
1393 default:
1394 av_assert0(0);
1395 }
87ef060c 1396
96139b5e 1397 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
d43040e2
AK
1398 if (nb_frames == 0) {
1399 nb_frames_drop++;
1400 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
87ef060c 1401 return;
d43040e2
AK
1402 } else if (nb_frames > 1) {
1403 nb_frames_dup += nb_frames - 1;
1404 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1405 }
87ef060c 1406
ac646076 1407#if !CONFIG_AVFILTER
87ef060c 1408 do_video_resample(ost, ist, in_picture, &final_picture);
ac646076
AK
1409#else
1410 final_picture = in_picture;
1411#endif
6291d7e4 1412
1270e12e
AK
1413 if (!ost->frame_number)
1414 ost->first_pts = ost->sync_opts;
1415
6291d7e4 1416 /* duplicates frame if needed */
7636c8c6 1417 for (i = 0; i < nb_frames; i++) {
6291d7e4
AK
1418 AVPacket pkt;
1419 av_init_packet(&pkt);
8e37038a
AK
1420 pkt.data = NULL;
1421 pkt.size = 0;
6291d7e4 1422
1270e12e
AK
1423 if (!check_recording_time(ost))
1424 return;
1425
150ddbc1
MR
1426 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1427 enc->codec->id == CODEC_ID_RAWVIDEO) {
6291d7e4 1428 /* raw pictures are written as AVPicture structure to
bb337b4f 1429 avoid any copies. We support temporarily the older
6291d7e4 1430 method. */
f593628e
AC
1431 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1432 enc->coded_frame->top_field_first = in_picture->top_field_first;
7636c8c6
AD
1433 pkt.data = (uint8_t *)final_picture;
1434 pkt.size = sizeof(AVPicture);
1435 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
6291d7e4
AK
1436 pkt.flags |= AV_PKT_FLAG_KEY;
1437
f15f02c2 1438 write_frame(s, &pkt, ost);
6291d7e4 1439 } else {
8e37038a 1440 int got_packet;
6291d7e4
AK
1441 AVFrame big_picture;
1442
7636c8c6 1443 big_picture = *final_picture;
6291d7e4
AK
1444 /* better than nothing: use input picture interlaced
1445 settings */
1446 big_picture.interlaced_frame = in_picture->interlaced_frame;
1447 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
828e0bcb 1448 if (ost->top_field_first == -1)
6291d7e4
AK
1449 big_picture.top_field_first = in_picture->top_field_first;
1450 else
828e0bcb 1451 big_picture.top_field_first = !!ost->top_field_first;
6291d7e4
AK
1452 }
1453
f4ad238c 1454 /* handles same_quant here. This is not correct because it may
6291d7e4
AK
1455 not be a global option */
1456 big_picture.quality = quality;
d242d80e 1457 if (!enc->me_threshold)
6291d7e4 1458 big_picture.pict_type = 0;
7636c8c6 1459 big_picture.pts = ost->sync_opts;
6291d7e4
AK
1460 if (ost->forced_kf_index < ost->forced_kf_count &&
1461 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1462 big_picture.pict_type = AV_PICTURE_TYPE_I;
1463 ost->forced_kf_index++;
1464 }
8e37038a 1465 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
6291d7e4 1466 if (ret < 0) {
e3245b26 1467 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
6291d7e4
AK
1468 exit_program(1);
1469 }
1470
8e37038a
AK
1471 if (got_packet) {
1472 if (pkt.pts != AV_NOPTS_VALUE)
1473 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1474 if (pkt.dts != AV_NOPTS_VALUE)
1475 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
6291d7e4 1476
f15f02c2 1477 write_frame(s, &pkt, ost);
39da3b22
AK
1478 *frame_size = pkt.size;
1479 video_size += pkt.size;
324fbadf 1480
6291d7e4
AK
1481 /* if two pass, output log */
1482 if (ost->logfile && enc->stats_out) {
1483 fprintf(ost->logfile, "%s", enc->stats_out);
1484 }
1485 }
1486 }
1487 ost->sync_opts++;
99932847
AK
1488 /*
1489 * For video, number of frames in == number of packets out.
1490 * But there may be reordering, so we can't throw away frames on encoder
1491 * flush, we need to limit them here, before they go into encoder.
1492 */
1493 ost->frame_number++;
6291d7e4
AK
1494 }
1495}
1496
7636c8c6
AD
1497static double psnr(double d)
1498{
1499 return -10.0 * log(d) / log(10.0);
6291d7e4
AK
1500}
1501
1502static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1503 int frame_size)
1504{
1505 AVCodecContext *enc;
1506 int frame_number;
1507 double ti1, bitrate, avg_bitrate;
1508
1509 /* this is executed just the first time do_video_stats is called */
1510 if (!vstats_file) {
1511 vstats_file = fopen(vstats_filename, "w");
1512 if (!vstats_file) {
1513 perror("fopen");
1514 exit_program(1);
1515 }
1516 }
1517
1518 enc = ost->st->codec;
1519 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1520 frame_number = ost->frame_number;
7636c8c6 1521 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
6291d7e4 1522 if (enc->flags&CODEC_FLAG_PSNR)
7636c8c6 1523 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
6291d7e4
AK
1524
1525 fprintf(vstats_file,"f_size= %6d ", frame_size);
1526 /* compute pts value */
1527 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1528 if (ti1 < 0.01)
1529 ti1 = 0.01;
1530
7636c8c6 1531 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
6291d7e4
AK
1532 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1533 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
7636c8c6 1534 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
6291d7e4
AK
1535 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1536 }
1537}
1538
af70aa45 1539static void print_report(OutputFile *output_files,
4288e031 1540 OutputStream *ost_table, int nb_ostreams,
c5ad2c2c 1541 int is_last_report, int64_t timer_start)
6291d7e4
AK
1542{
1543 char buf[1024];
1544 OutputStream *ost;
1545 AVFormatContext *oc;
1546 int64_t total_size;
1547 AVCodecContext *enc;
1548 int frame_number, vid, i;
1549 double bitrate, ti1, pts;
1550 static int64_t last_time = -1;
1551 static int qp_histogram[52];
1552
3460dd8a
AK
1553 if (!print_stats && !is_last_report)
1554 return;
1555
6291d7e4
AK
1556 if (!is_last_report) {
1557 int64_t cur_time;
1558 /* display the report every 0.5 seconds */
1559 cur_time = av_gettime();
1560 if (last_time == -1) {
1561 last_time = cur_time;
1562 return;
1563 }
1564 if ((cur_time - last_time) < 500000)
1565 return;
1566 last_time = cur_time;
1567 }
1568
1569
af70aa45 1570 oc = output_files[0].ctx;
6291d7e4
AK
1571
1572 total_size = avio_size(oc->pb);
7636c8c6
AD
1573 if (total_size < 0) // FIXME improve avio_size() so it works with non seekable output too
1574 total_size = avio_tell(oc->pb);
6291d7e4
AK
1575
1576 buf[0] = '\0';
1577 ti1 = 1e10;
1578 vid = 0;
7636c8c6 1579 for (i = 0; i < nb_ostreams; i++) {
6291d7e4 1580 float q = -1;
4288e031 1581 ost = &ost_table[i];
6291d7e4 1582 enc = ost->st->codec;
3d813e4c 1583 if (!ost->stream_copy && enc->coded_frame)
7636c8c6 1584 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
6291d7e4
AK
1585 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1586 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1587 }
1588 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
7636c8c6 1589 float t = (av_gettime() - timer_start) / 1000000.0;
6291d7e4
AK
1590
1591 frame_number = ost->frame_number;
1592 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
7636c8c6
AD
1593 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1594 if (is_last_report)
6291d7e4 1595 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
7636c8c6 1596 if (qp_hist) {
6291d7e4
AK
1597 int j;
1598 int qp = lrintf(q);
7636c8c6 1599 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
6291d7e4 1600 qp_histogram[qp]++;
7636c8c6
AD
1601 for (j = 0; j < 32; j++)
1602 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
6291d7e4 1603 }
7636c8c6 1604 if (enc->flags&CODEC_FLAG_PSNR) {
6291d7e4 1605 int j;
7636c8c6
AD
1606 double error, error_sum = 0;
1607 double scale, scale_sum = 0;
1608 char type[3] = { 'Y','U','V' };
6291d7e4 1609 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
7636c8c6
AD
1610 for (j = 0; j < 3; j++) {
1611 if (is_last_report) {
1612 error = enc->error[j];
1613 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1614 } else {
1615 error = enc->coded_frame->error[j];
1616 scale = enc->width * enc->height * 255.0 * 255.0;
6291d7e4 1617 }
7636c8c6
AD
1618 if (j)
1619 scale /= 4;
6291d7e4
AK
1620 error_sum += error;
1621 scale_sum += scale;
7636c8c6 1622 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
6291d7e4 1623 }
7636c8c6 1624 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
6291d7e4
AK
1625 }
1626 vid = 1;
1627 }
1628 /* compute min output value */
1629 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1630 if ((pts < ti1) && (pts > 0))
1631 ti1 = pts;
1632 }
1633 if (ti1 < 0.01)
1634 ti1 = 0.01;
1635
e3245b26 1636 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
6291d7e4 1637
e3245b26 1638 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
6291d7e4
AK
1639 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1640 (double)total_size / 1024, ti1, bitrate);
1641
e3245b26
AK
1642 if (nb_frames_dup || nb_frames_drop)
1643 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1644 nb_frames_dup, nb_frames_drop);
6291d7e4 1645
f5646a32 1646 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
6291d7e4 1647
e3245b26 1648 fflush(stderr);
6291d7e4 1649
e3245b26 1650 if (is_last_report) {
6291d7e4 1651 int64_t raw= audio_size + video_size + extra_size;
e3245b26
AK
1652 av_log(NULL, AV_LOG_INFO, "\n");
1653 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
7636c8c6
AD
1654 video_size / 1024.0,
1655 audio_size / 1024.0,
1656 extra_size / 1024.0,
1657 100.0 * (total_size - raw) / raw
6291d7e4
AK
1658 );
1659 }
1660}
1661
b62b5cb6 1662static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
4a4ce2e7
AK
1663{
1664 int i, ret;
1665
1666 for (i = 0; i < nb_ostreams; i++) {
6f1c66d5
AK
1667 OutputStream *ost = &ost_table[i];
1668 AVCodecContext *enc = ost->st->codec;
1669 AVFormatContext *os = output_files[ost->file_index].ctx;
ee458cb1 1670 int stop_encoding = 0;
6f1c66d5 1671
b62b5cb6 1672 if (!ost->encoding_needed)
6f1c66d5
AK
1673 continue;
1674
7636c8c6 1675 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
6f1c66d5 1676 continue;
150ddbc1 1677 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
6f1c66d5
AK
1678 continue;
1679
7636c8c6 1680 for (;;) {
6f1c66d5 1681 AVPacket pkt;
8e37038a 1682 int fifo_bytes, got_packet;
6f1c66d5 1683 av_init_packet(&pkt);
ee458cb1
JR
1684 pkt.data = NULL;
1685 pkt.size = 0;
6f1c66d5
AK
1686
1687 switch (ost->st->codec->codec_type) {
1688 case AVMEDIA_TYPE_AUDIO:
1689 fifo_bytes = av_fifo_size(ost->fifo);
6f1c66d5 1690 if (fifo_bytes > 0) {
ee458cb1
JR
1691 /* encode any samples remaining in fifo */
1692 int frame_bytes = fifo_bytes;
6f1c66d5
AK
1693
1694 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
ee458cb1
JR
1695
1696 /* pad last frame with silence if needed */
1697 if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
1698 frame_bytes = enc->frame_size * enc->channels *
1699 av_get_bytes_per_sample(enc->sample_fmt);
6f1c66d5 1700 if (allocated_audio_buf_size < frame_bytes)
4a4ce2e7 1701 exit_program(1);
6f1c66d5 1702 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
4a4ce2e7 1703 }
ee458cb1
JR
1704 encode_audio_frame(os, ost, audio_buf, frame_bytes);
1705 } else {
1706 /* flush encoder with NULL frames until it is done
1707 returning packets */
1708 if (encode_audio_frame(os, ost, NULL, 0) == 0) {
1709 stop_encoding = 1;
1710 break;
1711 }
6f1c66d5 1712 }
6f1c66d5
AK
1713 break;
1714 case AVMEDIA_TYPE_VIDEO:
8e37038a 1715 ret = avcodec_encode_video2(enc, &pkt, NULL, &got_packet);
6f1c66d5 1716 if (ret < 0) {
e3245b26 1717 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
6f1c66d5
AK
1718 exit_program(1);
1719 }
1720 video_size += ret;
6f1c66d5
AK
1721 if (ost->logfile && enc->stats_out) {
1722 fprintf(ost->logfile, "%s", enc->stats_out);
1723 }
8e37038a 1724 if (!got_packet) {
ee458cb1
JR
1725 stop_encoding = 1;
1726 break;
1727 }
8e37038a
AK
1728 if (pkt.pts != AV_NOPTS_VALUE)
1729 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1730 if (pkt.dts != AV_NOPTS_VALUE)
1731 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
ee458cb1 1732 write_frame(os, &pkt, ost);
6f1c66d5
AK
1733 break;
1734 default:
ee458cb1 1735 stop_encoding = 1;
4a4ce2e7 1736 }
ee458cb1 1737 if (stop_encoding)
6f1c66d5 1738 break;
4a4ce2e7
AK
1739 }
1740 }
1741}
1742
7204ec1a
AK
1743/*
1744 * Check whether a packet from ist should be written into ost at this time
1745 */
1746static int check_output_constraints(InputStream *ist, OutputStream *ost)
1747{
1748 OutputFile *of = &output_files[ost->file_index];
1749 int ist_index = ist - input_streams;
1750
1751 if (ost->source_index != ist_index)
1752 return 0;
1753
23576b3f 1754 if (of->start_time && ist->last_dts < of->start_time)
7204ec1a
AK
1755 return 0;
1756
7204ec1a
AK
1757 return 1;
1758}
1759
1760static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1761{
1762 OutputFile *of = &output_files[ost->file_index];
1763 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1764 AVPacket opkt;
1765
1766 av_init_packet(&opkt);
1767
1768 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1769 !ost->copy_initial_nonkeyframes)
1770 return;
1771
1270e12e 1772 if (of->recording_time != INT64_MAX &&
23576b3f 1773 ist->last_dts >= of->recording_time + of->start_time) {
1270e12e
AK
1774 ost->is_past_recording_time = 1;
1775 return;
1776 }
1777
7204ec1a
AK
1778 /* force the input stream PTS */
1779 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1780 audio_size += pkt->size;
1781 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1782 video_size += pkt->size;
1783 ost->sync_opts++;
1784 }
1785
7204ec1a
AK
1786 if (pkt->pts != AV_NOPTS_VALUE)
1787 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1788 else
1789 opkt.pts = AV_NOPTS_VALUE;
1790
1791 if (pkt->dts == AV_NOPTS_VALUE)
23576b3f 1792 opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->st->time_base);
7204ec1a
AK
1793 else
1794 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1795 opkt.dts -= ost_tb_start_time;
1796
1797 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1798 opkt.flags = pkt->flags;
1799
7636c8c6
AD
1800 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1801 if ( ost->st->codec->codec_id != CODEC_ID_H264
7204ec1a
AK
1802 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1803 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
ae5a9355 1804 && ost->st->codec->codec_id != CODEC_ID_VC1
7204ec1a
AK
1805 ) {
1806 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1807 opkt.destruct = av_destruct_packet;
1808 } else {
1809 opkt.data = pkt->data;
1810 opkt.size = pkt->size;
1811 }
1812
f15f02c2 1813 write_frame(of->ctx, &opkt, ost);
7204ec1a 1814 ost->st->codec->frame_number++;
7204ec1a
AK
1815 av_free_packet(&opkt);
1816}
1817
2a651b71
AK
1818static void rate_emu_sleep(InputStream *ist)
1819{
1820 if (input_files[ist->file_index].rate_emu) {
23576b3f 1821 int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE);
2a651b71
AK
1822 int64_t now = av_gettime() - ist->start;
1823 if (pts > now)
1824 usleep(pts - now);
1825 }
1826}
1827
ded28ba3
AK
1828static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1829{
d1241ff3
JR
1830 AVFrame *decoded_frame;
1831 AVCodecContext *avctx = ist->st->codec;
ded28ba3 1832 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
ded28ba3
AK
1833 int i, ret;
1834
9179f27c 1835 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
d1241ff3 1836 return AVERROR(ENOMEM);
9179f27c
JR
1837 else
1838 avcodec_get_frame_defaults(ist->decoded_frame);
1839 decoded_frame = ist->decoded_frame;
ded28ba3 1840
d1241ff3
JR
1841 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1842 if (ret < 0) {
ded28ba3 1843 return ret;
d1241ff3 1844 }
ded28ba3 1845
ded28ba3
AK
1846 if (!*got_output) {
1847 /* no audio frame */
af8ad892 1848 return ret;
ded28ba3
AK
1849 }
1850
d1241ff3
JR
1851 /* if the decoder provides a pts, use it instead of the last packet pts.
1852 the decoder could be delaying output by a packet or more. */
1853 if (decoded_frame->pts != AV_NOPTS_VALUE)
3101bb66 1854 ist->next_dts = decoded_frame->pts;
d1241ff3 1855
3101bb66 1856 /* increment next_dts to use for the case where the input stream does not
d1241ff3 1857 have timestamps or there are multiple frames in the packet */
3101bb66 1858 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
d1241ff3 1859 avctx->sample_rate;
ded28ba3
AK
1860
1861 // preprocess audio (volume)
1862 if (audio_volume != 256) {
d1241ff3
JR
1863 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1864 void *samples = decoded_frame->data[0];
1865 switch (avctx->sample_fmt) {
ded28ba3
AK
1866 case AV_SAMPLE_FMT_U8:
1867 {
1868 uint8_t *volp = samples;
1869 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1870 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1871 *volp++ = av_clip_uint8(v);
1872 }
1873 break;
1874 }
1875 case AV_SAMPLE_FMT_S16:
1876 {
1877 int16_t *volp = samples;
1878 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1879 int v = ((*volp) * audio_volume + 128) >> 8;
1880 *volp++ = av_clip_int16(v);
1881 }
1882 break;
1883 }
1884 case AV_SAMPLE_FMT_S32:
1885 {
1886 int32_t *volp = samples;
1887 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1888 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1889 *volp++ = av_clipl_int32(v);
1890 }
1891 break;
1892 }
1893 case AV_SAMPLE_FMT_FLT:
1894 {
1895 float *volp = samples;
1896 float scale = audio_volume / 256.f;
1897 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1898 *volp++ *= scale;
1899 }
1900 break;
1901 }
1902 case AV_SAMPLE_FMT_DBL:
1903 {
1904 double *volp = samples;
1905 double scale = audio_volume / 256.;
1906 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1907 *volp++ *= scale;
1908 }
1909 break;
1910 }
1911 default:
1912 av_log(NULL, AV_LOG_FATAL,
1913 "Audio volume adjustment on sample format %s is not supported.\n",
1914 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1915 exit_program(1);
1916 }
1917 }
1918
1919 rate_emu_sleep(ist);
1920
1921 for (i = 0; i < nb_output_streams; i++) {
1922 OutputStream *ost = &output_streams[i];
1923
1924 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1925 continue;
d1241ff3 1926 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
ded28ba3 1927 }
110d2af2 1928
af8ad892 1929 return ret;
ded28ba3
AK
1930}
1931
45d4b66f
AK
1932static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
1933{
1934 AVFrame *decoded_frame, *filtered_frame = NULL;
1935 void *buffer_to_free = NULL;
1936 int i, ret = 0;
1937 float quality;
1938#if CONFIG_AVFILTER
1939 int frame_available = 1;
1940#endif
1941
9179f27c 1942 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
45d4b66f 1943 return AVERROR(ENOMEM);
9179f27c
JR
1944 else
1945 avcodec_get_frame_defaults(ist->decoded_frame);
1946 decoded_frame = ist->decoded_frame;
45d4b66f 1947 pkt->pts = *pkt_pts;
23576b3f 1948 pkt->dts = ist->last_dts;
45d4b66f
AK
1949 *pkt_pts = AV_NOPTS_VALUE;
1950
1951 ret = avcodec_decode_video2(ist->st->codec,
1952 decoded_frame, got_output, pkt);
1953 if (ret < 0)
9179f27c 1954 return ret;
45d4b66f
AK
1955
1956 quality = same_quant ? decoded_frame->quality : 0;
1957 if (!*got_output) {
1958 /* no picture yet */
af8ad892 1959 return ret;
45d4b66f 1960 }
b34856a1
AK
1961 decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1962 decoded_frame->pkt_dts);
45d4b66f
AK
1963 pkt->size = 0;
1964 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1965
1966 rate_emu_sleep(ist);
1967
1968 for (i = 0; i < nb_output_streams; i++) {
1969 OutputStream *ost = &output_streams[i];
ac646076 1970 int frame_size, resample_changed;
45d4b66f
AK
1971
1972 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1973 continue;
1974
1975#if CONFIG_AVFILTER
ac646076
AK
1976 resample_changed = ost->resample_width != decoded_frame->width ||
1977 ost->resample_height != decoded_frame->height ||
1978 ost->resample_pix_fmt != decoded_frame->format;
1979 if (resample_changed) {
1980 av_log(NULL, AV_LOG_INFO,
1981 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1982 ist->file_index, ist->st->index,
1983 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1984 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1985
1986 avfilter_graph_free(&ost->graph);
1987 if (configure_video_filters(ist, ost)) {
1988 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1989 exit_program(1);
1990 }
1991
1992 ost->resample_width = decoded_frame->width;
1993 ost->resample_height = decoded_frame->height;
1994 ost->resample_pix_fmt = decoded_frame->format;
1995 }
1996
04a14d4d
AK
1997 if (ist->st->sample_aspect_ratio.num)
1998 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1999 if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
2000 FrameBuffer *buf = decoded_frame->opaque;
2001 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2002 decoded_frame->data, decoded_frame->linesize,
2003 AV_PERM_READ | AV_PERM_PRESERVE,
2004 ist->st->codec->width, ist->st->codec->height,
2005 ist->st->codec->pix_fmt);
2006
2007 avfilter_copy_frame_props(fb, decoded_frame);
04a14d4d
AK
2008 fb->buf->priv = buf;
2009 fb->buf->free = filter_release_buffer;
2010
2011 buf->refcount++;
2012 av_buffersrc_buffer(ost->input_video_filter, fb);
2013 } else
2014 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame,
6e983902 2015 decoded_frame->pts, decoded_frame->sample_aspect_ratio);
04a14d4d
AK
2016
2017 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2018 av_free(buffer_to_free);
2019 return AVERROR(ENOMEM);
2020 } else
2021 avcodec_get_frame_defaults(ist->filtered_frame);
2022 filtered_frame = ist->filtered_frame;
2023
2024 frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
45d4b66f
AK
2025 while (frame_available) {
2026 AVRational ist_pts_tb;
2027 if (ost->output_video_filter)
2028 get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
2029 if (ost->picref)
6e983902 2030 filtered_frame->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
45d4b66f
AK
2031 if (ost->picref->video && !ost->frame_aspect_ratio)
2032 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
2033#else
2034 filtered_frame = decoded_frame;
2035#endif
2036
2037 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2038 same_quant ? quality : ost->st->codec->global_quality);
2039 if (vstats_filename && frame_size)
2040 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2041#if CONFIG_AVFILTER
2042 frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2043 if (ost->picref)
2044 avfilter_unref_buffer(ost->picref);
2045 }
45d4b66f
AK
2046#endif
2047 }
2048
45d4b66f 2049 av_free(buffer_to_free);
45d4b66f
AK
2050 return ret;
2051}
2052
9595234c
AK
2053static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2054{
2055 AVSubtitle subtitle;
2056 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2057 &subtitle, got_output, pkt);
2058 if (ret < 0)
2059 return ret;
2060 if (!*got_output)
af8ad892 2061 return ret;
9595234c
AK
2062
2063 rate_emu_sleep(ist);
2064
2065 for (i = 0; i < nb_output_streams; i++) {
2066 OutputStream *ost = &output_streams[i];
2067
2068 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2069 continue;
2070
2071 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2072 }
2073
2074 avsubtitle_free(&subtitle);
af8ad892 2075 return ret;
9595234c
AK
2076}
2077
6291d7e4 2078/* pkt = NULL means EOF (needed to flush decoder buffers) */
06d4e2fa 2079static int output_packet(InputStream *ist,
4288e031 2080 OutputStream *ost_table, int nb_ostreams,
6291d7e4
AK
2081 const AVPacket *pkt)
2082{
ffa0674e 2083 int i;
6291d7e4 2084 int got_output;
6291d7e4 2085 int64_t pkt_pts = AV_NOPTS_VALUE;
6291d7e4 2086 AVPacket avpkt;
6291d7e4 2087
3101bb66 2088 if (ist->next_dts == AV_NOPTS_VALUE)
23576b3f 2089 ist->next_dts = ist->last_dts;
6291d7e4
AK
2090
2091 if (pkt == NULL) {
2092 /* EOF handling */
2093 av_init_packet(&avpkt);
2094 avpkt.data = NULL;
2095 avpkt.size = 0;
2096 goto handle_eof;
2097 } else {
2098 avpkt = *pkt;
2099 }
2100
7636c8c6 2101 if (pkt->dts != AV_NOPTS_VALUE)
23576b3f 2102 ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
7636c8c6 2103 if (pkt->pts != AV_NOPTS_VALUE)
6291d7e4
AK
2104 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2105
7636c8c6 2106 // while we have more to decode or while the decoder did output something on EOF
2a651b71 2107 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
ffa0674e 2108 int ret = 0;
6291d7e4 2109 handle_eof:
6291d7e4 2110
23576b3f 2111 ist->last_dts = ist->next_dts;
8b0268a8
AK
2112
2113 if (avpkt.size && avpkt.size != pkt->size) {
e3245b26
AK
2114 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2115 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
8b0268a8
AK
2116 ist->showed_multi_packet_warning = 1;
2117 }
6291d7e4 2118
7636c8c6 2119 switch (ist->st->codec->codec_type) {
82963f8f
AK
2120 case AVMEDIA_TYPE_AUDIO:
2121 ret = transcode_audio (ist, &avpkt, &got_output);
2122 break;
2123 case AVMEDIA_TYPE_VIDEO:
2124 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
b34856a1
AK
2125 if (avpkt.duration)
2126 ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
722410ad
AK
2127 else if (ist->st->r_frame_rate.num)
2128 ist->next_dts += av_rescale_q(1, (AVRational){ist->st->r_frame_rate.den,
2129 ist->st->r_frame_rate.num},
2130 AV_TIME_BASE_Q);
b34856a1
AK
2131 else if (ist->st->codec->time_base.num != 0) {
2132 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
2133 ist->st->codec->ticks_per_frame;
2134 ist->next_dts += av_rescale_q(ticks, ist->st->codec->time_base, AV_TIME_BASE_Q);
2135 }
82963f8f
AK
2136 break;
2137 case AVMEDIA_TYPE_SUBTITLE:
2138 ret = transcode_subtitles(ist, &avpkt, &got_output);
2139 break;
78162b4e
AK
2140 default:
2141 return -1;
2142 }
6291d7e4 2143
d3c1d37a
AK
2144 if (ret < 0)
2145 return ret;
aa38cff2
JG
2146 // touch data and size only if not EOF
2147 if (pkt) {
2148 avpkt.data += ret;
2149 avpkt.size -= ret;
2150 }
82963f8f 2151 if (!got_output) {
af8ad892 2152 continue;
82963f8f 2153 }
6291d7e4 2154 }
6291d7e4 2155
7204ec1a 2156 /* handle stream copy */
2a651b71
AK
2157 if (!ist->decoding_needed) {
2158 rate_emu_sleep(ist);
23576b3f 2159 ist->last_dts = ist->next_dts;
2a651b71
AK
2160 switch (ist->st->codec->codec_type) {
2161 case AVMEDIA_TYPE_AUDIO:
3101bb66 2162 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2a651b71
AK
2163 ist->st->codec->sample_rate;
2164 break;
2165 case AVMEDIA_TYPE_VIDEO:
2166 if (ist->st->codec->time_base.num != 0) {
7636c8c6 2167 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
3101bb66 2168 ist->next_dts += ((int64_t)AV_TIME_BASE *
2a651b71
AK
2169 ist->st->codec->time_base.num * ticks) /
2170 ist->st->codec->time_base.den;
2171 }
2172 break;
2173 }
2174 }
7204ec1a 2175 for (i = 0; pkt && i < nb_ostreams; i++) {
ffa0674e 2176 OutputStream *ost = &ost_table[i];
7204ec1a
AK
2177
2178 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2179 continue;
2180
2181 do_streamcopy(ist, ost, pkt);
2182 }
2183
6291d7e4
AK
2184 return 0;
2185}
2186
af70aa45 2187static void print_sdp(OutputFile *output_files, int n)
6291d7e4
AK
2188{
2189 char sdp[2048];
af70aa45 2190 int i;
7636c8c6 2191 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
af70aa45
AK
2192
2193 if (!avc)
2194 exit_program(1);
2195 for (i = 0; i < n; i++)
2196 avc[i] = output_files[i].ctx;
6291d7e4
AK
2197
2198 av_sdp_create(avc, n, sdp, sizeof(sdp));
2199 printf("SDP:\n%s\n", sdp);
2200 fflush(stdout);
af70aa45 2201 av_freep(&avc);
6291d7e4
AK
2202}
2203
630902a1
AK
2204static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2205 char *error, int error_len)
2206{
2207 int i;
2208 InputStream *ist = &input_streams[ist_index];
2209 if (ist->decoding_needed) {
2210 AVCodec *codec = ist->dec;
630902a1 2211 if (!codec) {
9a414d89 2212 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
630902a1
AK
2213 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2214 return AVERROR(EINVAL);
2215 }
2216
2217 /* update requested sample format for the decoder based on the
2218 corresponding encoder sample format */
2219 for (i = 0; i < nb_output_streams; i++) {
2220 OutputStream *ost = &output_streams[i];
2221 if (ost->source_index == ist_index) {
2222 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2223 break;
2224 }
2225 }
2226
64dca32c
AK
2227 if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2228 ist->st->codec->get_buffer = codec_get_buffer;
2229 ist->st->codec->release_buffer = codec_release_buffer;
2230 ist->st->codec->opaque = ist;
2231 }
2232
2473a45c
JG
2233 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2234 av_dict_set(&ist->opts, "threads", "auto", 0);
630902a1 2235 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
9a414d89 2236 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
630902a1
AK
2237 ist->file_index, ist->st->index);
2238 return AVERROR(EINVAL);
2239 }
2240 assert_codec_experimental(ist->st->codec, 0);
2241 assert_avoptions(ist->opts);
2242 }
2243
23576b3f 2244 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;
3101bb66 2245 ist->next_dts = AV_NOPTS_VALUE;
630902a1
AK
2246 init_pts_correction(&ist->pts_ctx);
2247 ist->is_start = 1;
2248
2249 return 0;
2250}
2251
eaf2d37a
AC
2252static int transcode_init(OutputFile *output_files,
2253 int nb_output_files,
2254 InputFile *input_files,
2255 int nb_input_files)
6291d7e4 2256{
2c474ddb 2257 int ret = 0, i, j, k;
1bb77e51 2258 AVFormatContext *oc;
6291d7e4 2259 AVCodecContext *codec, *icodec;
4288e031 2260 OutputStream *ost;
6291d7e4
AK
2261 InputStream *ist;
2262 char error[1024];
2263 int want_sdp = 1;
b0c9e8e0 2264
f4805328
AK
2265 /* init framerate emulation */
2266 for (i = 0; i < nb_input_files; i++) {
2267 InputFile *ifile = &input_files[i];
2268 if (ifile->rate_emu)
2269 for (j = 0; j < ifile->nb_streams; j++)
2270 input_streams[j + ifile->ist_index].start = av_gettime();
2271 }
6291d7e4
AK
2272
2273 /* output stream init */
03f30c83 2274 for (i = 0; i < nb_output_files; i++) {
1bb77e51
AK
2275 oc = output_files[i].ctx;
2276 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2277 av_dump_format(oc, i, oc->filename, 1);
e3245b26 2278 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
eaf2d37a 2279 return AVERROR(EINVAL);
6291d7e4 2280 }
6291d7e4
AK
2281 }
2282
2283 /* for each output stream, we compute the right encoding parameters */
4288e031
AK
2284 for (i = 0; i < nb_output_streams; i++) {
2285 ost = &output_streams[i];
03f30c83 2286 oc = output_files[ost->file_index].ctx;
6291d7e4
AK
2287 ist = &input_streams[ost->source_index];
2288
4dbc6cee
AK
2289 if (ost->attachment_filename)
2290 continue;
2291
03f30c83 2292 codec = ost->st->codec;
6291d7e4
AK
2293 icodec = ist->st->codec;
2294
03f30c83
AK
2295 ost->st->disposition = ist->st->disposition;
2296 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
6291d7e4
AK
2297 codec->chroma_sample_location = icodec->chroma_sample_location;
2298
3d813e4c 2299 if (ost->stream_copy) {
6291d7e4
AK
2300 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2301
e6d2b737 2302 if (extra_size > INT_MAX) {
eaf2d37a 2303 return AVERROR(EINVAL);
e6d2b737 2304 }
6291d7e4
AK
2305
2306 /* if stream_copy is selected, no need to decode or encode */
03f30c83 2307 codec->codec_id = icodec->codec_id;
6291d7e4
AK
2308 codec->codec_type = icodec->codec_type;
2309
03f30c83
AK
2310 if (!codec->codec_tag) {
2311 if (!oc->oformat->codec_tag ||
2312 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2313 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
6291d7e4
AK
2314 codec->codec_tag = icodec->codec_tag;
2315 }
2316
03f30c83 2317 codec->bit_rate = icodec->bit_rate;
6291d7e4
AK
2318 codec->rc_max_rate = icodec->rc_max_rate;
2319 codec->rc_buffer_size = icodec->rc_buffer_size;
4bf3c8f2 2320 codec->field_order = icodec->field_order;
03f30c83 2321 codec->extradata = av_mallocz(extra_size);
e6d2b737 2322 if (!codec->extradata) {
eaf2d37a 2323 return AVERROR(ENOMEM);
e6d2b737 2324 }
6291d7e4 2325 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
03f30c83 2326 codec->extradata_size = icodec->extradata_size;
7bb3e625 2327 if (!copy_tb) {
03f30c83 2328 codec->time_base = icodec->time_base;
6291d7e4
AK
2329 codec->time_base.num *= icodec->ticks_per_frame;
2330 av_reduce(&codec->time_base.num, &codec->time_base.den,
2331 codec->time_base.num, codec->time_base.den, INT_MAX);
03f30c83 2332 } else
6291d7e4 2333 codec->time_base = ist->st->time_base;
03f30c83 2334
7636c8c6 2335 switch (codec->codec_type) {
6291d7e4 2336 case AVMEDIA_TYPE_AUDIO:
7636c8c6 2337 if (audio_volume != 256) {
e3245b26 2338 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
6291d7e4
AK
2339 exit_program(1);
2340 }
03f30c83
AK
2341 codec->channel_layout = icodec->channel_layout;
2342 codec->sample_rate = icodec->sample_rate;
2343 codec->channels = icodec->channels;
2344 codec->frame_size = icodec->frame_size;
6291d7e4 2345 codec->audio_service_type = icodec->audio_service_type;
03f30c83 2346 codec->block_align = icodec->block_align;
6291d7e4
AK
2347 break;
2348 case AVMEDIA_TYPE_VIDEO:
03f30c83
AK
2349 codec->pix_fmt = icodec->pix_fmt;
2350 codec->width = icodec->width;
2351 codec->height = icodec->height;
2352 codec->has_b_frames = icodec->has_b_frames;
6291d7e4 2353 if (!codec->sample_aspect_ratio.num) {
03f30c83 2354 codec->sample_aspect_ratio =
6291d7e4
AK
2355 ost->st->sample_aspect_ratio =
2356 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2357 ist->st->codec->sample_aspect_ratio.num ?
2358 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2359 }
2360 break;
2361 case AVMEDIA_TYPE_SUBTITLE:
03f30c83 2362 codec->width = icodec->width;
6291d7e4
AK
2363 codec->height = icodec->height;
2364 break;
2365 case AVMEDIA_TYPE_DATA:
3ccd1580 2366 case AVMEDIA_TYPE_ATTACHMENT:
6291d7e4
AK
2367 break;
2368 default:
2369 abort();
2370 }
2371 } else {
2372 if (!ost->enc)
2373 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
03f30c83 2374
11fdb7e1
AK
2375 ist->decoding_needed = 1;
2376 ost->encoding_needed = 1;
03f30c83 2377
7636c8c6 2378 switch (codec->codec_type) {
6291d7e4 2379 case AVMEDIA_TYPE_AUDIO:
03f30c83 2380 ost->fifo = av_fifo_alloc(1024);
e6d2b737 2381 if (!ost->fifo) {
eaf2d37a 2382 return AVERROR(ENOMEM);
e6d2b737 2383 }
6291d7e4 2384 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
03f30c83 2385
d0a19696 2386 if (!codec->sample_rate)
6291d7e4 2387 codec->sample_rate = icodec->sample_rate;
6291d7e4 2388 choose_sample_rate(ost->st, ost->enc);
7636c8c6 2389 codec->time_base = (AVRational){ 1, codec->sample_rate };
03f30c83 2390
6291d7e4
AK
2391 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2392 codec->sample_fmt = icodec->sample_fmt;
2393 choose_sample_fmt(ost->st, ost->enc);
03f30c83 2394
6291d7e4
AK
2395 if (!codec->channels)
2396 codec->channels = icodec->channels;
2397 codec->channel_layout = icodec->channel_layout;
2398 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2399 codec->channel_layout = 0;
03f30c83
AK
2400
2401 ost->audio_resample = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2402 icodec->request_channels = codec-> channels;
6291d7e4
AK
2403 ost->resample_sample_fmt = icodec->sample_fmt;
2404 ost->resample_sample_rate = icodec->sample_rate;
2405 ost->resample_channels = icodec->channels;
2406 break;
2407 case AVMEDIA_TYPE_VIDEO:
2408 if (codec->pix_fmt == PIX_FMT_NONE)
2409 codec->pix_fmt = icodec->pix_fmt;
2410 choose_pixel_fmt(ost->st, ost->enc);
2411
2412 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
e3245b26 2413 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
6291d7e4
AK
2414 exit_program(1);
2415 }
2416
2417 if (!codec->width || !codec->height) {
2418 codec->width = icodec->width;
2419 codec->height = icodec->height;
2420 }
2421
2422 ost->video_resample = codec->width != icodec->width ||
2423 codec->height != icodec->height ||
2424 codec->pix_fmt != icodec->pix_fmt;
2425 if (ost->video_resample) {
2426#if !CONFIG_AVFILTER
2427 avcodec_get_frame_defaults(&ost->pict_tmp);
7636c8c6 2428 if (avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
6291d7e4 2429 codec->width, codec->height)) {
e3245b26 2430 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
6291d7e4
AK
2431 exit_program(1);
2432 }
2433 ost->img_resample_ctx = sws_getContext(
2434 icodec->width,
2435 icodec->height,
2436 icodec->pix_fmt,
2437 codec->width,
2438 codec->height,
2439 codec->pix_fmt,
2440 ost->sws_flags, NULL, NULL, NULL);
2441 if (ost->img_resample_ctx == NULL) {
e3245b26 2442 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
6291d7e4
AK
2443 exit_program(1);
2444 }
2445#endif
7636c8c6 2446 codec->bits_per_raw_sample = 0;
6291d7e4
AK
2447 }
2448
03f30c83
AK
2449 ost->resample_height = icodec->height;
2450 ost->resample_width = icodec->width;
2451 ost->resample_pix_fmt = icodec->pix_fmt;
6291d7e4 2452
832ba44d
AK
2453 /*
2454 * We want CFR output if and only if one of those is true:
2455 * 1) user specified output framerate with -r
2456 * 2) user specified -vsync cfr
2457 * 3) output format is CFR and the user didn't force vsync to
2458 * something else than CFR
2459 *
2460 * in such a case, set ost->frame_rate
2461 */
2462 if (!ost->frame_rate.num &&
2463 (video_sync_method == VSYNC_CFR ||
2464 (video_sync_method == VSYNC_AUTO &&
2465 !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS))))) {
2466 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
2467 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2468 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2469 ost->frame_rate = ost->enc->supported_framerates[idx];
2470 }
6291d7e4 2471 }
832ba44d
AK
2472 if (ost->frame_rate.num) {
2473 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2474 video_sync_method = VSYNC_CFR;
2475 } else
2476 codec->time_base = ist->st->time_base;
6291d7e4
AK
2477
2478#if CONFIG_AVFILTER
2479 if (configure_video_filters(ist, ost)) {
e3245b26 2480 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
6291d7e4
AK
2481 exit(1);
2482 }
2483#endif
2484 break;
2485 case AVMEDIA_TYPE_SUBTITLE:
c9af8326 2486 codec->time_base = (AVRational){1, 1000};
6291d7e4
AK
2487 break;
2488 default:
2489 abort();
2490 break;
2491 }
2492 /* two pass mode */
515901fa 2493 if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
6291d7e4
AK
2494 char logfilename[1024];
2495 FILE *f;
2496
2497 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2498 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2499 i);
6e8be949
AK
2500 if (!strcmp(ost->enc->name, "libx264")) {
2501 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
2502 } else {
6291d7e4
AK
2503 if (codec->flags & CODEC_FLAG_PASS1) {
2504 f = fopen(logfilename, "wb");
2505 if (!f) {
e3245b26
AK
2506 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2507 logfilename, strerror(errno));
6291d7e4
AK
2508 exit_program(1);
2509 }
2510 ost->logfile = f;
2511 } else {
2512 char *logbuffer;
2513 size_t logbuffer_size;
02170990 2514 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
e3245b26
AK
2515 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2516 logfilename);
6291d7e4
AK
2517 exit_program(1);
2518 }
2519 codec->stats_in = logbuffer;
2520 }
6e8be949 2521 }
6291d7e4
AK
2522 }
2523 }
6291d7e4
AK
2524 }
2525
2526 /* open each encoder */
4288e031
AK
2527 for (i = 0; i < nb_output_streams; i++) {
2528 ost = &output_streams[i];
6291d7e4 2529 if (ost->encoding_needed) {
03f30c83 2530 AVCodec *codec = ost->enc;
6291d7e4
AK
2531 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2532 if (!codec) {
9a414d89 2533 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
6291d7e4
AK
2534 ost->st->codec->codec_id, ost->file_index, ost->index);
2535 ret = AVERROR(EINVAL);
2536 goto dump_format;
2537 }
2538 if (dec->subtitle_header) {
2539 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2540 if (!ost->st->codec->subtitle_header) {
2541 ret = AVERROR(ENOMEM);
2542 goto dump_format;
2543 }
2544 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2545 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2546 }
2473a45c
JG
2547 if (!av_dict_get(ost->opts, "threads", NULL, 0))
2548 av_dict_set(&ost->opts, "threads", "auto", 0);
6291d7e4 2549 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
9a414d89 2550 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
6291d7e4
AK
2551 ost->file_index, ost->index);
2552 ret = AVERROR(EINVAL);
2553 goto dump_format;
2554 }
2555 assert_codec_experimental(ost->st->codec, 1);
2556 assert_avoptions(ost->opts);
2557 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2558 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2559 "It takes bits/s as argument, not kbits/s\n");
2560 extra_size += ost->st->codec->extradata_size;
d242d80e
AK
2561
2562 if (ost->st->codec->me_threshold)
2563 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
6291d7e4
AK
2564 }
2565 }
2566
630902a1
AK
2567 /* init input streams */
2568 for (i = 0; i < nb_input_streams; i++)
62486948 2569 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
630902a1 2570 goto dump_format;
6291d7e4 2571
2c474ddb
AK
2572 /* discard unused programs */
2573 for (i = 0; i < nb_input_files; i++) {
2574 InputFile *ifile = &input_files[i];
2575 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2576 AVProgram *p = ifile->ctx->programs[j];
2577 int discard = AVDISCARD_ALL;
2578
2579 for (k = 0; k < p->nb_stream_indexes; k++)
2580 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2581 discard = AVDISCARD_DEFAULT;
2582 break;
2583 }
2584 p->discard = discard;
2585 }
2586 }
2587
6291d7e4 2588 /* open files and write file headers */
af70aa45 2589 for (i = 0; i < nb_output_files; i++) {
1bb77e51
AK
2590 oc = output_files[i].ctx;
2591 oc->interrupt_callback = int_cb;
2592 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
6291d7e4
AK
2593 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2594 ret = AVERROR(EINVAL);
2595 goto dump_format;
2596 }
af70aa45 2597 assert_avoptions(output_files[i].opts);
1bb77e51 2598 if (strcmp(oc->oformat->name, "rtp")) {
6291d7e4
AK
2599 want_sdp = 0;
2600 }
2601 }
2602
2603 dump_format:
2604 /* dump the file output parameters - cannot be done before in case
2605 of stream copy */
03f30c83 2606 for (i = 0; i < nb_output_files; i++) {
af70aa45 2607 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
6291d7e4
AK
2608 }
2609
2610 /* dump the stream mapping */
e3245b26
AK
2611 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2612 for (i = 0; i < nb_output_streams; i++) {
2613 ost = &output_streams[i];
4dbc6cee
AK
2614
2615 if (ost->attachment_filename) {
2616 /* an attached file */
2617 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2618 ost->attachment_filename, ost->file_index, ost->index);
2619 continue;
2620 }
9a414d89 2621 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
e3245b26
AK
2622 input_streams[ost->source_index].file_index,
2623 input_streams[ost->source_index].st->index,
2624 ost->file_index,
2625 ost->index);
2626 if (ost->sync_ist != &input_streams[ost->source_index])
9a414d89 2627 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
e3245b26
AK
2628 ost->sync_ist->file_index,
2629 ost->sync_ist->st->index);
3d813e4c 2630 if (ost->stream_copy)
e3245b26
AK
2631 av_log(NULL, AV_LOG_INFO, " (copy)");
2632 else
2633 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2634 input_streams[ost->source_index].dec->name : "?",
2635 ost->enc ? ost->enc->name : "?");
2636 av_log(NULL, AV_LOG_INFO, "\n");
6291d7e4
AK
2637 }
2638
2639 if (ret) {
e3245b26 2640 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
eaf2d37a 2641 return ret;
6291d7e4
AK
2642 }
2643
2644 if (want_sdp) {
2645 print_sdp(output_files, nb_output_files);
2646 }
2647
eaf2d37a
AC
2648 return 0;
2649}
2650
2651/*
2652 * The following code is the main loop of the file converter
2653 */
2654static int transcode(OutputFile *output_files,
2655 int nb_output_files,
2656 InputFile *input_files,
2657 int nb_input_files)
2658{
2659 int ret, i;
2660 AVFormatContext *is, *os;
2661 OutputStream *ost;
2662 InputStream *ist;
2663 uint8_t *no_packet;
7636c8c6 2664 int no_packet_count = 0;
eaf2d37a
AC
2665 int64_t timer_start;
2666
2667 if (!(no_packet = av_mallocz(nb_input_files)))
2668 exit_program(1);
2669
2670 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2671 if (ret < 0)
2672 goto fail;
2673
e3245b26 2674 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
6291d7e4
AK
2675 term_init();
2676
2677 timer_start = av_gettime();
2678
7636c8c6 2679 for (; received_sigterm == 0;) {
6291d7e4
AK
2680 int file_index, ist_index;
2681 AVPacket pkt;
9be3c124 2682 int64_t ipts_min;
6291d7e4
AK
2683 double opts_min;
2684
9be3c124 2685 ipts_min = INT64_MAX;
7636c8c6 2686 opts_min = 1e100;
6291d7e4
AK
2687
2688 /* select the stream that we must read now by looking at the
2689 smallest output pts */
2690 file_index = -1;
4288e031 2691 for (i = 0; i < nb_output_streams; i++) {
f21f294e 2692 OutputFile *of;
9be3c124
AC
2693 int64_t ipts;
2694 double opts;
4288e031 2695 ost = &output_streams[i];
f21f294e 2696 of = &output_files[ost->file_index];
af70aa45 2697 os = output_files[ost->file_index].ctx;
6291d7e4 2698 ist = &input_streams[ost->source_index];
f21f294e
AK
2699 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2700 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
6291d7e4 2701 continue;
c0931508 2702 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
23576b3f 2703 ipts = ist->last_dts;
7636c8c6
AD
2704 if (!input_files[ist->file_index].eof_reached) {
2705 if (ipts < ipts_min) {
6291d7e4 2706 ipts_min = ipts;
7636c8c6
AD
2707 if (input_sync)
2708 file_index = ist->file_index;
6291d7e4 2709 }
7636c8c6 2710 if (opts < opts_min) {
6291d7e4 2711 opts_min = opts;
7636c8c6 2712 if (!input_sync) file_index = ist->file_index;
6291d7e4
AK
2713 }
2714 }
96139b5e
AK
2715 if (ost->frame_number >= ost->max_frames) {
2716 int j;
9b921a82
AK
2717 for (j = 0; j < of->ctx->nb_streams; j++)
2718 output_streams[of->ost_index + j].is_past_recording_time = 1;
96139b5e 2719 continue;
6291d7e4
AK
2720 }
2721 }
2722 /* if none, if is finished */
2723 if (file_index < 0) {
7636c8c6
AD
2724 if (no_packet_count) {
2725 no_packet_count = 0;
b0c9e8e0 2726 memset(no_packet, 0, nb_input_files);
6291d7e4
AK
2727 usleep(10000);
2728 continue;
2729 }
2730 break;
2731 }
2732
6291d7e4 2733 /* read a frame from it and output it in the fifo */
7636c8c6
AD
2734 is = input_files[file_index].ctx;
2735 ret = av_read_frame(is, &pkt);
2736 if (ret == AVERROR(EAGAIN)) {
2737 no_packet[file_index] = 1;
6291d7e4
AK
2738 no_packet_count++;
2739 continue;
2740 }
2741 if (ret < 0) {
2742 input_files[file_index].eof_reached = 1;
2743 if (opt_shortest)
2744 break;
2745 else
2746 continue;
2747 }
2748
7636c8c6 2749 no_packet_count = 0;
b0c9e8e0 2750 memset(no_packet, 0, nb_input_files);
6291d7e4
AK
2751
2752 if (do_pkt_dump) {
2753 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2754 is->streams[pkt.stream_index]);
2755 }
2756 /* the following test is needed in case new streams appear
2757 dynamically in stream : we ignore them */
ed5b1326 2758 if (pkt.stream_index >= input_files[file_index].nb_streams)
6291d7e4
AK
2759 goto discard_packet;
2760 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2761 ist = &input_streams[ist_index];
2762 if (ist->discard)
2763 goto discard_packet;
2764
2765 if (pkt.dts != AV_NOPTS_VALUE)
2766 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2767 if (pkt.pts != AV_NOPTS_VALUE)
2768 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2769
7636c8c6 2770 if (pkt.pts != AV_NOPTS_VALUE)
33f75d72 2771 pkt.pts *= ist->ts_scale;
7636c8c6 2772 if (pkt.dts != AV_NOPTS_VALUE)
33f75d72 2773 pkt.dts *= ist->ts_scale;
6291d7e4 2774
7636c8c6 2775 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
3101bb66 2776 // ist->next_dts,
7636c8c6
AD
2777 // pkt.dts, input_files[ist->file_index].ts_offset,
2778 // ist->st->codec->codec_type);
3101bb66 2779 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE
6291d7e4 2780 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
7636c8c6 2781 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3101bb66 2782 int64_t delta = pkt_dts - ist->next_dts;
23576b3f 2783 if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
6291d7e4 2784 input_files[ist->file_index].ts_offset -= delta;
7636c8c6
AD
2785 av_log(NULL, AV_LOG_DEBUG,
2786 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
e3245b26 2787 delta, input_files[ist->file_index].ts_offset);
6291d7e4 2788 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
7636c8c6 2789 if (pkt.pts != AV_NOPTS_VALUE)
6291d7e4
AK
2790 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2791 }
2792 }
2793
7636c8c6 2794 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
06d4e2fa 2795 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
6291d7e4 2796
9a414d89 2797 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
e3245b26 2798 ist->file_index, ist->st->index);
6291d7e4
AK
2799 if (exit_on_error)
2800 exit_program(1);
2801 av_free_packet(&pkt);
b9630bcf 2802 continue;
6291d7e4
AK
2803 }
2804
2805 discard_packet:
2806 av_free_packet(&pkt);
2807
2808 /* dump report by using the output first video and audio streams */
c5ad2c2c 2809 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
6291d7e4
AK
2810 }
2811
2812 /* at the end of stream, we must flush the decoder buffers */
2813 for (i = 0; i < nb_input_streams; i++) {
2814 ist = &input_streams[i];
2815 if (ist->decoding_needed) {
06d4e2fa 2816 output_packet(ist, output_streams, nb_output_streams, NULL);
6291d7e4
AK
2817 }
2818 }
b62b5cb6 2819 flush_encoders(output_streams, nb_output_streams);
6291d7e4
AK
2820
2821 term_exit();
2822
2823 /* write the trailer if needed and close file */
7636c8c6 2824 for (i = 0; i < nb_output_files; i++) {
af70aa45 2825 os = output_files[i].ctx;
6291d7e4
AK
2826 av_write_trailer(os);
2827 }
2828
2829 /* dump report by using the first video and audio streams */
c5ad2c2c 2830 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
6291d7e4
AK
2831
2832 /* close each encoder */
4288e031
AK
2833 for (i = 0; i < nb_output_streams; i++) {
2834 ost = &output_streams[i];
6291d7e4
AK
2835 if (ost->encoding_needed) {
2836 av_freep(&ost->st->codec->stats_in);
2837 avcodec_close(ost->st->codec);
2838 }
2839#if CONFIG_AVFILTER
2840 avfilter_graph_free(&ost->graph);
2841#endif
2842 }
2843
2844 /* close each decoder */
2845 for (i = 0; i < nb_input_streams; i++) {
2846 ist = &input_streams[i];
2847 if (ist->decoding_needed) {
2848 avcodec_close(ist->st->codec);
2849 }
2850 }
2851
2852 /* finished ! */
2853 ret = 0;
2854
2855 fail:
b0c9e8e0 2856 av_freep(&no_packet);
6291d7e4 2857
4288e031
AK
2858 if (output_streams) {
2859 for (i = 0; i < nb_output_streams; i++) {
2860 ost = &output_streams[i];
6291d7e4 2861 if (ost) {
3d813e4c 2862 if (ost->stream_copy)
6291d7e4
AK
2863 av_freep(&ost->st->codec->extradata);
2864 if (ost->logfile) {
2865 fclose(ost->logfile);
2866 ost->logfile = NULL;
2867 }
2868 av_fifo_free(ost->fifo); /* works even if fifo is not
2869 initialized but set to zero */
2870 av_freep(&ost->st->codec->subtitle_header);
2871 av_free(ost->pict_tmp.data[0]);
2872 av_free(ost->forced_kf_pts);
2873 if (ost->video_resample)
2874 sws_freeContext(ost->img_resample_ctx);
2875 if (ost->resample)
2876 audio_resample_close(ost->resample);
2877 if (ost->reformat_ctx)
2878 av_audio_convert_free(ost->reformat_ctx);
2879 av_dict_free(&ost->opts);
6291d7e4
AK
2880 }
2881 }
6291d7e4
AK
2882 }
2883 return ret;
2884}
2885
ca46fde7 2886static double parse_frame_aspect_ratio(const char *arg)
6291d7e4
AK
2887{
2888 int x = 0, y = 0;
2889 double ar = 0;
2890 const char *p;
2891 char *end;
2892
2893 p = strchr(arg, ':');
2894 if (p) {
2895 x = strtol(arg, &end, 10);
2896 if (end == p)
7636c8c6 2897 y = strtol(end + 1, &end, 10);
6291d7e4
AK
2898 if (x > 0 && y > 0)
2899 ar = (double)x / (double)y;
2900 } else
2901 ar = strtod(arg, NULL);
2902
2903 if (!ar) {
e3245b26 2904 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
ca46fde7 2905 exit_program(1);
6291d7e4 2906 }
ca46fde7 2907 return ar;
6291d7e4
AK
2908}
2909
35e6f8c1 2910static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
6291d7e4 2911{
35e6f8c1 2912 return parse_option(o, "codec:a", arg, options);
6291d7e4
AK
2913}
2914
35e6f8c1 2915static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
6291d7e4 2916{
35e6f8c1 2917 return parse_option(o, "codec:v", arg, options);
6291d7e4
AK
2918}
2919
35e6f8c1 2920static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
6291d7e4 2921{
35e6f8c1 2922 return parse_option(o, "codec:s", arg, options);
6291d7e4
AK
2923}
2924
35e6f8c1 2925static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
6291d7e4 2926{
35e6f8c1 2927 return parse_option(o, "codec:d", arg, options);
6291d7e4
AK
2928}
2929
575ec4e1 2930static int opt_map(OptionsContext *o, const char *opt, const char *arg)
6291d7e4 2931{
8d2e4a7e
AK
2932 StreamMap *m = NULL;
2933 int i, negative = 0, file_idx;
2934 int sync_file_idx = -1, sync_stream_idx;
2935 char *p, *sync;
2936 char *map;
6291d7e4 2937
8d2e4a7e
AK
2938 if (*arg == '-') {
2939 negative = 1;
2940 arg++;
2941 }
2942 map = av_strdup(arg);
6291d7e4 2943
8d2e4a7e
AK
2944 /* parse sync stream first, just pick first matching stream */
2945 if (sync = strchr(map, ',')) {
2946 *sync = 0;
2947 sync_file_idx = strtol(sync + 1, &sync, 0);
2948 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
f24facd3 2949 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
8d2e4a7e
AK
2950 exit_program(1);
2951 }
2952 if (*sync)
2953 sync++;
ed5b1326 2954 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
8d2e4a7e
AK
2955 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2956 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2957 sync_stream_idx = i;
2958 break;
2959 }
ed5b1326 2960 if (i == input_files[sync_file_idx].nb_streams) {
f24facd3 2961 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
8d2e4a7e
AK
2962 "match any streams.\n", arg);
2963 exit_program(1);
2964 }
2965 }
6291d7e4 2966
8d2e4a7e
AK
2967
2968 file_idx = strtol(map, &p, 0);
2969 if (file_idx >= nb_input_files || file_idx < 0) {
f24facd3 2970 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
8d2e4a7e 2971 exit_program(1);
6291d7e4 2972 }
8d2e4a7e
AK
2973 if (negative)
2974 /* disable some already defined maps */
575ec4e1
AK
2975 for (i = 0; i < o->nb_stream_maps; i++) {
2976 m = &o->stream_maps[i];
e6674f68
AK
2977 if (file_idx == m->file_index &&
2978 check_stream_specifier(input_files[m->file_index].ctx,
8d2e4a7e
AK
2979 input_files[m->file_index].ctx->streams[m->stream_index],
2980 *p == ':' ? p + 1 : p) > 0)
2981 m->disabled = 1;
2982 }
2983 else
ed5b1326 2984 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
8d2e4a7e
AK
2985 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2986 *p == ':' ? p + 1 : p) <= 0)
2987 continue;
575ec4e1
AK
2988 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2989 &o->nb_stream_maps, o->nb_stream_maps + 1);
2990 m = &o->stream_maps[o->nb_stream_maps - 1];
8d2e4a7e
AK
2991
2992 m->file_index = file_idx;
2993 m->stream_index = i;
2994
2995 if (sync_file_idx >= 0) {
2996 m->sync_file_index = sync_file_idx;
2997 m->sync_stream_index = sync_stream_idx;
2998 } else {
2999 m->sync_file_index = file_idx;
3000 m->sync_stream_index = i;
3001 }
3002 }
3003
3004 if (!m) {
f24facd3 3005 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
8d2e4a7e
AK
3006 exit_program(1);
3007 }
3008
3009 av_freep(&map);
6291d7e4
AK
3010 return 0;
3011}
3012
4dbc6cee
AK
3013static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3014{
3015 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3016 &o->nb_attachments, o->nb_attachments + 1);
3017 o->attachments[o->nb_attachments - 1] = arg;
3018 return 0;
3019}
3020
a7b5e841
AK
3021/**
3022 * Parse a metadata specifier in arg.
3023 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3024 * @param index for type c/p, chapter/program index is written here
3025 * @param stream_spec for type s, the stream specifier is written here
3026 */
3027static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
6291d7e4 3028{
039267f1 3029 if (*arg) {
a2a38d96 3030 *type = *arg;
6291d7e4
AK
3031 switch (*arg) {
3032 case 'g':
3033 break;
3034 case 's':
a7b5e841
AK
3035 if (*(++arg) && *arg != ':') {
3036 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3037 exit_program(1);
3038 }
3039 *stream_spec = *arg == ':' ? arg + 1 : "";
3040 break;
6291d7e4
AK
3041 case 'c':
3042 case 'p':
e6e6060c
AK
3043 if (*(++arg) == ':')
3044 *index = strtol(++arg, NULL, 0);
6291d7e4
AK
3045 break;
3046 default:
e3245b26 3047 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
6291d7e4
AK
3048 exit_program(1);
3049 }
3050 } else
3051 *type = 'g';
3052}
3053
a7b5e841 3054static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
6291d7e4 3055{
a7b5e841
AK
3056 AVDictionary **meta_in = NULL;
3057 AVDictionary **meta_out;
3058 int i, ret = 0;
3059 char type_in, type_out;
3060 const char *istream_spec = NULL, *ostream_spec = NULL;
3061 int idx_in = 0, idx_out = 0;
6291d7e4 3062
a7b5e841
AK
3063 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3064 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
6291d7e4 3065
a7b5e841 3066 if (type_in == 'g' || type_out == 'g')
847529f8 3067 o->metadata_global_manual = 1;
a7b5e841 3068 if (type_in == 's' || type_out == 's')
847529f8 3069 o->metadata_streams_manual = 1;
a7b5e841 3070 if (type_in == 'c' || type_out == 'c')
847529f8 3071 o->metadata_chapters_manual = 1;
6291d7e4 3072
a7b5e841
AK
3073#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3074 if ((index) < 0 || (index) >= (nb_elems)) {\
3075 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3076 (desc), (index));\
3077 exit_program(1);\
3078 }
3079
3080#define SET_DICT(type, meta, context, index)\
3081 switch (type) {\
3082 case 'g':\
3083 meta = &context->metadata;\
3084 break;\
3085 case 'c':\
3086 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3087 meta = &context->chapters[index]->metadata;\
3088 break;\
3089 case 'p':\
3090 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3091 meta = &context->programs[index]->metadata;\
3092 break;\
3093 }\
3094
3095 SET_DICT(type_in, meta_in, ic, idx_in);
3096 SET_DICT(type_out, meta_out, oc, idx_out);
3097
3098 /* for input streams choose first matching stream */
3099 if (type_in == 's') {
3100 for (i = 0; i < ic->nb_streams; i++) {
3101 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3102 meta_in = &ic->streams[i]->metadata;
3103 break;
3104 } else if (ret < 0)
3105 exit_program(1);
3106 }
3107 if (!meta_in) {
3108 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3109 exit_program(1);
3110 }
3111 }
3112
3113 if (type_out == 's') {
3114 for (i = 0; i < oc->nb_streams; i++) {
3115 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3116 meta_out = &oc->streams[i]->metadata;
3117 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3118 } else if (ret < 0)
3119 exit_program(1);
3120 }
3121 } else
3122 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3123
6291d7e4
AK
3124 return 0;
3125}
3126
1b648c7c 3127static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
169f0647
AK
3128{
3129 const char *codec_string = encoder ? "encoder" : "decoder";
3130 AVCodec *codec;
3131
169f0647
AK
3132 codec = encoder ?
3133 avcodec_find_encoder_by_name(name) :
3134 avcodec_find_decoder_by_name(name);
7636c8c6 3135 if (!codec) {
f24facd3 3136 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
169f0647
AK
3137 exit_program(1);
3138 }
7636c8c6 3139 if (codec->type != type) {
f24facd3 3140 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
169f0647
AK
3141 exit_program(1);
3142 }
1b648c7c 3143 return codec;
169f0647
AK
3144}
3145
1b648c7c 3146static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
169f0647 3147{
169f0647 3148 char *codec_name = NULL;
169f0647 3149
35e6f8c1 3150 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
1b648c7c
AK
3151 if (codec_name) {
3152 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3153 st->codec->codec_id = codec->id;
3154 return codec;
3155 } else
3156 return avcodec_find_decoder(st->codec->codec_id);
169f0647 3157}
6291d7e4 3158
88867844
AK
3159/**
3160 * Add all the streams from the given input file to the global
3161 * list of input streams.
3162 */
35e6f8c1 3163static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
88867844 3164{
c88d5319 3165 int i;
88867844
AK
3166
3167 for (i = 0; i < ic->nb_streams; i++) {
3168 AVStream *st = ic->streams[i];
3169 AVCodecContext *dec = st->codec;
3170 InputStream *ist;
3171
88867844
AK
3172 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3173 ist = &input_streams[nb_input_streams - 1];
3174 ist->st = st;
3175 ist->file_index = nb_input_files;
3176 ist->discard = 1;
13f6917c 3177 st->discard = AVDISCARD_ALL;
88867844
AK
3178 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3179
059fb8c8
AK
3180 ist->ts_scale = 1.0;
3181 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
88867844 3182
1b648c7c 3183 ist->dec = choose_decoder(o, ic, st);
88867844
AK
3184
3185 switch (dec->codec_type) {
88867844 3186 case AVMEDIA_TYPE_VIDEO:
88867844
AK
3187 if (dec->lowres) {
3188 dec->flags |= CODEC_FLAG_EMU_EDGE;
3189 dec->height >>= dec->lowres;
3190 dec->width >>= dec->lowres;
3191 }
88867844 3192
88867844 3193 break;
13f6917c 3194 case AVMEDIA_TYPE_AUDIO:
88867844 3195 case AVMEDIA_TYPE_DATA:
88867844 3196 case AVMEDIA_TYPE_SUBTITLE:
88867844
AK
3197 case AVMEDIA_TYPE_ATTACHMENT:
3198 case AVMEDIA_TYPE_UNKNOWN:
3199 break;
3200 default:
3201 abort();
3202 }
3203 }
3204}
3205
a2c0b830
AK
3206static void assert_file_overwrite(const char *filename)
3207{
3208 if (!file_overwrite &&
3209 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3210 av_strstart(filename, "file:", NULL))) {
3211 if (avio_check(filename, 0) == 0) {
3212 if (!using_stdin) {
3213 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3214 fflush(stderr);
3215 if (!read_yesno()) {
3216 fprintf(stderr, "Not overwriting - exiting\n");
3217 exit_program(1);
3218 }
3219 }
3220 else {
3221 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3222 exit_program(1);
3223 }
3224 }
3225 }
3226}
3227
3228static void dump_attachment(AVStream *st, const char *filename)
3229{
3230 int ret;
3231 AVIOContext *out = NULL;
3232 AVDictionaryEntry *e;
3233
3234 if (!st->codec->extradata_size) {
3235 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3236 nb_input_files - 1, st->index);
3237 return;
3238 }
3239 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3240 filename = e->value;
3241 if (!*filename) {
3242 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3243 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3244 exit_program(1);
3245 }
3246
3247 assert_file_overwrite(filename);
3248
2abe947a 3249 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
a2c0b830
AK
3250 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3251 filename);
3252 exit_program(1);
3253 }
3254
3255 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3256 avio_flush(out);
3257 avio_close(out);
3258}
3259
575ec4e1 3260static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
6291d7e4
AK
3261{
3262 AVFormatContext *ic;
3263 AVInputFormat *file_iformat = NULL;
88867844 3264 int err, i, ret;
6291d7e4
AK
3265 int64_t timestamp;
3266 uint8_t buf[128];
3267 AVDictionary **opts;
3268 int orig_nb_streams; // number of streams before avformat_find_stream_info
3269
7041bb3b
AK
3270 if (o->format) {
3271 if (!(file_iformat = av_find_input_format(o->format))) {
e3245b26 3272 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
6291d7e4
AK
3273 exit_program(1);
3274 }
6291d7e4
AK
3275 }
3276
3277 if (!strcmp(filename, "-"))
3278 filename = "pipe:";
3279
3280 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3281 !strcmp(filename, "/dev/stdin");
3282
3283 /* get default parameters from command line */
3284 ic = avformat_alloc_context();
3285 if (!ic) {
3286 print_error(filename, AVERROR(ENOMEM));
3287 exit_program(1);
3288 }
e2469ccf
AK
3289 if (o->nb_audio_sample_rate) {
3290 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
6291d7e4
AK
3291 av_dict_set(&format_opts, "sample_rate", buf, 0);
3292 }
6a11686d
AK
3293 if (o->nb_audio_channels) {
3294 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
6291d7e4
AK
3295 av_dict_set(&format_opts, "channels", buf, 0);
3296 }
91ea4811
AK
3297 if (o->nb_frame_rates) {
3298 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
6291d7e4 3299 }
d4397b03
AK
3300 if (o->nb_frame_sizes) {
3301 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
6291d7e4 3302 }
b2254d83
AK
3303 if (o->nb_frame_pix_fmts)
3304 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
6291d7e4 3305
6291d7e4 3306 ic->flags |= AVFMT_FLAG_NONBLOCK;
2abe947a 3307 ic->interrupt_callback = int_cb;
6291d7e4
AK
3308
3309 /* open the input file with generic libav function */
3310 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3311 if (err < 0) {
3312 print_error(filename, err);
3313 exit_program(1);
3314 }
3315 assert_avoptions(format_opts);
3316
92f1940e
AK
3317 /* apply forced codec ids */
3318 for (i = 0; i < ic->nb_streams; i++)
1b648c7c 3319 choose_decoder(o, ic, ic->streams[i]);
92f1940e 3320
6291d7e4
AK
3321 /* Set AVCodecContext options for avformat_find_stream_info */
3322 opts = setup_find_stream_info_opts(ic, codec_opts);
3323 orig_nb_streams = ic->nb_streams;
3324
3325 /* If not enough info to get the stream parameters, we decode the
3326 first frames to get it. (used in mpeg case for example) */
3327 ret = avformat_find_stream_info(ic, opts);
e3245b26
AK
3328 if (ret < 0) {
3329 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
cd3716b9 3330 avformat_close_input(&ic);
6291d7e4
AK
3331 exit_program(1);
3332 }
3333
6b779ccc 3334 timestamp = o->start_time;
6291d7e4
AK
3335 /* add the stream start time */
3336 if (ic->start_time != AV_NOPTS_VALUE)
3337 timestamp += ic->start_time;
3338
3339 /* if seeking requested, we execute it */
6b779ccc 3340 if (o->start_time != 0) {
6291d7e4
AK
3341 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3342 if (ret < 0) {
e3245b26
AK
3343 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3344 filename, (double)timestamp / AV_TIME_BASE);
6291d7e4 3345 }
6291d7e4
AK
3346 }
3347
3348 /* update the current parameters so that they match the one of the input stream */
35e6f8c1 3349 add_input_streams(o, ic);
6291d7e4
AK
3350
3351 /* dump the file content */
e3245b26 3352 av_dump_format(ic, nb_input_files, filename, 0);
6291d7e4
AK
3353
3354 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3355 input_files[nb_input_files - 1].ctx = ic;
3356 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
6b779ccc 3357 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
ed5b1326 3358 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
dc3e76f3 3359 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
6291d7e4 3360
a2c0b830
AK
3361 for (i = 0; i < o->nb_dump_attachment; i++) {
3362 int j;
3363
3364 for (j = 0; j < ic->nb_streams; j++) {
3365 AVStream *st = ic->streams[j];
3366
3367 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3368 dump_attachment(st, o->dump_attachment[i].u.str);
3369 }
3370 }
3371
6291d7e4
AK
3372 for (i = 0; i < orig_nb_streams; i++)
3373 av_dict_free(&opts[i]);
3374 av_freep(&opts);
575ec4e1
AK
3375
3376 reset_options(o);
6291d7e4
AK
3377 return 0;
3378}
3379
f233cfed
AK
3380static void parse_forced_key_frames(char *kf, OutputStream *ost,
3381 AVCodecContext *avctx)
3382{
3383 char *p;
3384 int n = 1, i;
3385 int64_t t;
3386
3387 for (p = kf; *p; p++)
3388 if (*p == ',')
3389 n++;
3390 ost->forced_kf_count = n;
7636c8c6 3391 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
f233cfed
AK
3392 if (!ost->forced_kf_pts) {
3393 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3394 exit_program(1);
3395 }
3396 for (i = 0; i < n; i++) {
3397 p = i ? strchr(p, ',') + 1 : kf;
3398 t = parse_time_or_die("force_key_frames", p, 1);
3399 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3400 }
3401}
3402
3ec34462
AK
3403static uint8_t *get_line(AVIOContext *s)
3404{
3405 AVIOContext *line;
3406 uint8_t *buf;
3407 char c;
3408
3409 if (avio_open_dyn_buf(&line) < 0) {
3410 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3411 exit_program(1);
3412 }
3413
3414 while ((c = avio_r8(s)) && c != '\n')
3415 avio_w8(line, c);
3416 avio_w8(line, 0);
3417 avio_close_dyn_buf(line, &buf);
3418
3419 return buf;
3420}
3421
3422static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3423{
3424 int i, ret = 1;
3425 char filename[1000];
3426 const char *base[3] = { getenv("AVCONV_DATADIR"),
3427 getenv("HOME"),
3428 AVCONV_DATADIR,
3429 };
3430
3431 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3432 if (!base[i])
3433 continue;
3434 if (codec_name) {
3435 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3436 i != 1 ? "" : "/.avconv", codec_name, preset_name);
2abe947a 3437 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3ec34462
AK
3438 }
3439 if (ret) {
3440 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3441 i != 1 ? "" : "/.avconv", preset_name);
2abe947a 3442 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3ec34462
AK
3443 }
3444 }
3445 return ret;
3446}
3447
1b648c7c
AK
3448static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3449{
3450 char *codec_name = NULL;
3451
3452 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3453 if (!codec_name) {
3454 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3455 NULL, ost->st->codec->codec_type);
3456 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3457 } else if (!strcmp(codec_name, "copy"))
3d813e4c 3458 ost->stream_copy = 1;
1b648c7c
AK
3459 else {
3460 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3461 ost->st->codec->codec_id = ost->enc->id;
3462 }
3463}
3464
35e6f8c1 3465static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
169f0647
AK
3466{
3467 OutputStream *ost;
84ad31ff 3468 AVStream *st = avformat_new_stream(oc, NULL);
3ec34462 3469 int idx = oc->nb_streams - 1, ret = 0;
013887eb 3470 char *bsf = NULL, *next, *codec_tag = NULL;
d821cbe2 3471 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
77d9c454 3472 double qscale = -1;
3ec34462
AK
3473 char *buf = NULL, *arg = NULL, *preset = NULL;
3474 AVIOContext *s = NULL;
169f0647
AK
3475
3476 if (!st) {
f24facd3 3477 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
169f0647
AK
3478 exit_program(1);
3479 }
3480
84ad31ff
AK
3481 if (oc->nb_streams - 1 < o->nb_streamid_map)
3482 st->id = o->streamid_map[oc->nb_streams - 1];
3483
4288e031
AK
3484 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3485 nb_output_streams + 1);
3486 ost = &output_streams[nb_output_streams - 1];
40fc2810 3487 ost->file_index = nb_output_files;
7636c8c6
AD
3488 ost->index = idx;
3489 ost->st = st;
169f0647 3490 st->codec->codec_type = type;
1b648c7c 3491 choose_encoder(o, oc, ost);
169f0647
AK
3492 if (ost->enc) {
3493 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3494 }
3495
3496 avcodec_get_context_defaults3(st->codec, ost->enc);
3497 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3498
3ec34462
AK
3499 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3500 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3501 do {
3502 buf = get_line(s);
3503 if (!buf[0] || buf[0] == '#') {
3504 av_free(buf);
3505 continue;
3506 }
3507 if (!(arg = strchr(buf, '='))) {
3508 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");