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