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