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