avconv: cosmetics, move OutputStream.
[libav.git] / avconv.c
CommitLineData
6291d7e4
AK
1/*
2 * avconv main
3 * Copyright (c) 2000-2011 The libav developers.
4 *
5 * This file is part of Libav.
6 *
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include "config.h"
23#include <ctype.h>
24#include <string.h>
25#include <math.h>
26#include <stdlib.h>
27#include <errno.h>
28#include <signal.h>
29#include <limits.h>
30#include <unistd.h>
31#include "libavformat/avformat.h"
32#include "libavdevice/avdevice.h"
33#include "libswscale/swscale.h"
34#include "libavutil/opt.h"
35#include "libavcodec/audioconvert.h"
36#include "libavutil/audioconvert.h"
37#include "libavutil/parseutils.h"
38#include "libavutil/samplefmt.h"
39#include "libavutil/colorspace.h"
40#include "libavutil/fifo.h"
41#include "libavutil/intreadwrite.h"
42#include "libavutil/dict.h"
43#include "libavutil/mathematics.h"
44#include "libavutil/pixdesc.h"
45#include "libavutil/avstring.h"
46#include "libavutil/libm.h"
47#include "libavformat/os_support.h"
48
49#if CONFIG_AVFILTER
50# include "libavfilter/avfilter.h"
51# include "libavfilter/avfiltergraph.h"
52# include "libavfilter/vsrc_buffer.h"
53#endif
54
55#if HAVE_SYS_RESOURCE_H
56#include <sys/types.h>
57#include <sys/time.h>
58#include <sys/resource.h>
59#elif HAVE_GETPROCESSTIMES
60#include <windows.h>
61#endif
62#if HAVE_GETPROCESSMEMORYINFO
63#include <windows.h>
64#include <psapi.h>
65#endif
66
67#if HAVE_SYS_SELECT_H
68#include <sys/select.h>
69#endif
70
71#include <time.h>
72
73#include "cmdutils.h"
74
75#include "libavutil/avassert.h"
76
77const char program_name[] = "avconv";
78const int program_birth_year = 2000;
79
80/* select an input stream for an output stream */
81typedef struct StreamMap {
8d2e4a7e 82 int disabled; /** 1 is this mapping is disabled by a negative map */
6291d7e4
AK
83 int file_index;
84 int stream_index;
85 int sync_file_index;
86 int sync_stream_index;
87} StreamMap;
88
89/**
90 * select an input file for an output file
91 */
92typedef struct MetadataMap {
93 int file; //< file index
94 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
95 int index; //< stream/chapter/program number
96} MetadataMap;
97
6291d7e4
AK
98static const OptionDef options[];
99
6291d7e4 100static const char *last_asked_format = NULL;
09af7fb3 101static AVDictionary *ts_scale;
6291d7e4 102
6291d7e4
AK
103static StreamMap *stream_maps = NULL;
104static int nb_stream_maps;
105
92f1940e
AK
106static AVDictionary *codec_names;
107
6291d7e4
AK
108/* first item specifies output metadata, second is input */
109static MetadataMap (*meta_data_maps)[2] = NULL;
110static int nb_meta_data_maps;
111static int metadata_global_autocopy = 1;
112static int metadata_streams_autocopy = 1;
113static int metadata_chapters_autocopy = 1;
114
b9aac90b 115static int chapters_input_file = INT_MAX;
6291d7e4
AK
116
117/* indexed by output file stream index */
118static int *streamid_map = NULL;
119static int nb_streamid_map = 0;
120
121static int frame_width = 0;
122static int frame_height = 0;
123static float frame_aspect_ratio = 0;
124static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
125static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
126static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
127static AVRational frame_rate;
128static float video_qscale = 0;
129static uint16_t *intra_matrix = NULL;
130static uint16_t *inter_matrix = NULL;
131static const char *video_rc_override_string=NULL;
132static int video_disable = 0;
133static int video_discard = 0;
6291d7e4
AK
134static unsigned int video_codec_tag = 0;
135static char *video_language = NULL;
f4ad238c 136static int same_quant = 0;
6291d7e4
AK
137static int do_deinterlace = 0;
138static int top_field_first = -1;
139static int me_threshold = 0;
140static int intra_dc_precision = 8;
6291d7e4
AK
141static int qp_hist = 0;
142#if CONFIG_AVFILTER
143static char *vfilters = NULL;
144#endif
145
146static int intra_only = 0;
147static int audio_sample_rate = 0;
148#define QSCALE_NONE -99999
149static float audio_qscale = QSCALE_NONE;
150static int audio_disable = 0;
151static int audio_channels = 0;
6291d7e4
AK
152static unsigned int audio_codec_tag = 0;
153static char *audio_language = NULL;
154
155static int subtitle_disable = 0;
6291d7e4
AK
156static char *subtitle_language = NULL;
157static unsigned int subtitle_codec_tag = 0;
158
159static int data_disable = 0;
6291d7e4
AK
160static unsigned int data_codec_tag = 0;
161
162static float mux_preload= 0.5;
163static float mux_max_delay= 0.7;
164
165static int64_t recording_time = INT64_MAX;
166static int64_t start_time = 0;
167static int64_t input_ts_offset = 0;
168static int file_overwrite = 0;
169static AVDictionary *metadata;
170static int do_benchmark = 0;
171static int do_hex_dump = 0;
172static int do_pkt_dump = 0;
173static int do_psnr = 0;
174static int do_pass = 0;
175static char *pass_logfilename_prefix = NULL;
6291d7e4
AK
176static int video_sync_method= -1;
177static int audio_sync_method= 0;
178static float audio_drift_threshold= 0.1;
179static int copy_ts= 0;
180static int copy_tb;
181static int opt_shortest = 0;
182static char *vstats_filename;
183static FILE *vstats_file;
184static int opt_programid = 0;
185static int copy_initial_nonkeyframes = 0;
186
187static int rate_emu = 0;
188
189static int audio_volume = 256;
190
191static int exit_on_error = 0;
192static int using_stdin = 0;
193static int verbose = 1;
194static int thread_count= 1;
195static int64_t video_size = 0;
196static int64_t audio_size = 0;
197static int64_t extra_size = 0;
198static int nb_frames_dup = 0;
199static int nb_frames_drop = 0;
200static int input_sync;
201static uint64_t limit_filesize = 0;
202static int force_fps = 0;
203static char *forced_key_frames = NULL;
204
205static float dts_delta_threshold = 10;
206
207static int64_t timer_start;
208
209static uint8_t *audio_buf;
210static uint8_t *audio_out;
211static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
212
213static short *samples;
214
215static AVBitStreamFilterContext *video_bitstream_filters=NULL;
216static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
217static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
218
219#define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
220
6494c001
AK
221typedef struct InputStream {
222 int file_index;
223 AVStream *st;
224 int discard; /* true if stream data should be discarded */
225 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
226 AVCodec *dec;
227
228 int64_t start; /* time when read started */
229 int64_t next_pts; /* synthetic pts for cases where pkt.pts
230 is not defined */
231 int64_t pts; /* current pts */
232 PtsCorrectionContext pts_ctx;
233 double ts_scale;
234 int is_start; /* is 1 at the start and after a discontinuity */
235 int showed_multi_packet_warning;
236 AVDictionary *opts;
237} InputStream;
238
239typedef struct InputFile {
240 AVFormatContext *ctx;
241 int eof_reached; /* true if eof reached */
242 int ist_index; /* index of first stream in ist_table */
243 int buffer_size; /* current total buffer size */
244 int64_t ts_offset;
245} InputFile;
6291d7e4
AK
246
247typedef struct OutputStream {
248 int file_index; /* file index */
249 int index; /* stream index in the output file */
250 int source_index; /* InputStream index */
251 AVStream *st; /* stream in the output file */
252 int encoding_needed; /* true if encoding needed for this stream */
253 int frame_number;
254 /* input pts and corresponding output pts
255 for A/V sync */
256 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
257 struct InputStream *sync_ist; /* input stream to sync against */
258 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
259 AVBitStreamFilterContext *bitstream_filters;
260 AVCodec *enc;
261
262 /* video only */
263 int video_resample;
264 AVFrame pict_tmp; /* temporary image for resampling */
265 struct SwsContext *img_resample_ctx; /* for image resampling */
266 int resample_height;
267 int resample_width;
268 int resample_pix_fmt;
269 AVRational frame_rate;
270
271 float frame_aspect_ratio;
272
273 /* forced key frames */
274 int64_t *forced_kf_pts;
275 int forced_kf_count;
276 int forced_kf_index;
277
278 /* audio only */
279 int audio_resample;
280 ReSampleContext *resample; /* for audio resampling */
281 int resample_sample_fmt;
282 int resample_channels;
283 int resample_sample_rate;
284 int reformat_pair;
285 AVAudioConvert *reformat_ctx;
286 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
287 FILE *logfile;
288
289#if CONFIG_AVFILTER
290 AVFilterContext *output_video_filter;
291 AVFilterContext *input_video_filter;
292 AVFilterBufferRef *picref;
293 char *avfilter;
294 AVFilterGraph *graph;
295#endif
296
297 int sws_flags;
298 AVDictionary *opts;
ef44a607 299 int is_past_recording_time;
6291d7e4
AK
300} OutputStream;
301
6291d7e4 302
af70aa45
AK
303typedef struct OutputFile {
304 AVFormatContext *ctx;
305 AVDictionary *opts;
4288e031 306 int ost_index; /* index of the first stream in output_streams */
ef44a607 307 int64_t recording_time; /* desired length of the resulting file in microseconds */
ea065176 308 int64_t start_time; /* start time in microseconds */
af70aa45
AK
309} OutputFile;
310
6291d7e4
AK
311static InputStream *input_streams = NULL;
312static int nb_input_streams = 0;
313static InputFile *input_files = NULL;
314static int nb_input_files = 0;
315
4288e031
AK
316static OutputStream *output_streams = NULL;
317static int nb_output_streams = 0;
af70aa45
AK
318static OutputFile *output_files = NULL;
319static int nb_output_files = 0;
320
6291d7e4
AK
321#if CONFIG_AVFILTER
322
323static int configure_video_filters(InputStream *ist, OutputStream *ost)
324{
325 AVFilterContext *last_filter, *filter;
326 /** filter graph containing all filters including input & output */
327 AVCodecContext *codec = ost->st->codec;
328 AVCodecContext *icodec = ist->st->codec;
329 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
330 AVRational sample_aspect_ratio;
331 char args[255];
332 int ret;
333
334 ost->graph = avfilter_graph_alloc();
335
336 if (ist->st->sample_aspect_ratio.num){
337 sample_aspect_ratio = ist->st->sample_aspect_ratio;
338 }else
339 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
340
341 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
342 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
343 sample_aspect_ratio.num, sample_aspect_ratio.den);
344
345 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
346 "src", args, NULL, ost->graph);
347 if (ret < 0)
348 return ret;
349 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
350 "out", NULL, &ffsink_ctx, ost->graph);
351 if (ret < 0)
352 return ret;
353 last_filter = ost->input_video_filter;
354
355 if (codec->width != icodec->width || codec->height != icodec->height) {
356 snprintf(args, 255, "%d:%d:flags=0x%X",
357 codec->width,
358 codec->height,
359 ost->sws_flags);
360 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
361 NULL, args, NULL, ost->graph)) < 0)
362 return ret;
363 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
364 return ret;
365 last_filter = filter;
366 }
367
368 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
369 ost->graph->scale_sws_opts = av_strdup(args);
370
371 if (ost->avfilter) {
372 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
373 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
374
375 outputs->name = av_strdup("in");
376 outputs->filter_ctx = last_filter;
377 outputs->pad_idx = 0;
378 outputs->next = NULL;
379
380 inputs->name = av_strdup("out");
381 inputs->filter_ctx = ost->output_video_filter;
382 inputs->pad_idx = 0;
383 inputs->next = NULL;
384
385 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
386 return ret;
387 av_freep(&ost->avfilter);
388 } else {
389 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
390 return ret;
391 }
392
393 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
394 return ret;
395
396 codec->width = ost->output_video_filter->inputs[0]->w;
397 codec->height = ost->output_video_filter->inputs[0]->h;
398 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
399 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
400 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
401 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
402
403 return 0;
404}
405#endif /* CONFIG_AVFILTER */
406
407static void term_exit(void)
408{
409 av_log(NULL, AV_LOG_QUIET, "");
410}
411
412static volatile int received_sigterm = 0;
413static volatile int received_nb_signals = 0;
414
415static void
416sigterm_handler(int sig)
417{
418 received_sigterm = sig;
419 received_nb_signals++;
420 term_exit();
421}
422
423static void term_init(void)
424{
425 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
426 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
427#ifdef SIGXCPU
428 signal(SIGXCPU, sigterm_handler);
429#endif
430}
431
432static int decode_interrupt_cb(void)
433{
434 return received_nb_signals > 1;
435}
436
437static int exit_program(int ret)
438{
439 int i;
440
441 /* close files */
442 for(i=0;i<nb_output_files;i++) {
af70aa45 443 AVFormatContext *s = output_files[i].ctx;
6291d7e4
AK
444 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
445 avio_close(s->pb);
446 avformat_free_context(s);
af70aa45 447 av_dict_free(&output_files[i].opts);
6291d7e4
AK
448 }
449 for(i=0;i<nb_input_files;i++) {
450 av_close_input_file(input_files[i].ctx);
451 }
452 for (i = 0; i < nb_input_streams; i++)
453 av_dict_free(&input_streams[i].opts);
454
455 av_free(intra_matrix);
456 av_free(inter_matrix);
457
458 if (vstats_file)
459 fclose(vstats_file);
460 av_free(vstats_filename);
461
462 av_free(streamid_map);
6291d7e4
AK
463 av_free(meta_data_maps);
464
465 av_freep(&input_streams);
466 av_freep(&input_files);
4288e031 467 av_freep(&output_streams);
af70aa45 468 av_freep(&output_files);
6291d7e4 469
6291d7e4
AK
470 uninit_opts();
471 av_free(audio_buf);
472 av_free(audio_out);
473 allocated_audio_buf_size= allocated_audio_out_size= 0;
474 av_free(samples);
475
476#if CONFIG_AVFILTER
477 avfilter_uninit();
478#endif
479
480 if (received_sigterm) {
481 fprintf(stderr,
482 "Received signal %d: terminating.\n",
483 (int) received_sigterm);
484 exit (255);
485 }
486
487 exit(ret); /* not all OS-es handle main() return value */
488 return ret;
489}
490
491static void assert_avoptions(AVDictionary *m)
492{
493 AVDictionaryEntry *t;
494 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
495 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
496 exit_program(1);
497 }
498}
499
500static void assert_codec_experimental(AVCodecContext *c, int encoder)
501{
502 const char *codec_string = encoder ? "encoder" : "decoder";
503 AVCodec *codec;
504 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
505 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
506 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
507 "results.\nAdd '-strict experimental' if you want to use it.\n",
508 codec_string, c->codec->name);
509 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
510 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
511 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
512 codec_string, codec->name);
513 exit_program(1);
514 }
515}
516
517/* similar to ff_dynarray_add() and av_fast_realloc() */
518static void *grow_array(void *array, int elem_size, int *size, int new_size)
519{
520 if (new_size >= INT_MAX / elem_size) {
521 fprintf(stderr, "Array too big.\n");
522 exit_program(1);
523 }
524 if (*size < new_size) {
525 uint8_t *tmp = av_realloc(array, new_size*elem_size);
526 if (!tmp) {
527 fprintf(stderr, "Could not alloc buffer.\n");
528 exit_program(1);
529 }
530 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
531 *size = new_size;
532 return tmp;
533 }
534 return array;
535}
536
537static void choose_sample_fmt(AVStream *st, AVCodec *codec)
538{
539 if(codec && codec->sample_fmts){
540 const enum AVSampleFormat *p= codec->sample_fmts;
541 for(; *p!=-1; p++){
542 if(*p == st->codec->sample_fmt)
543 break;
544 }
545 if (*p == -1) {
546 av_log(NULL, AV_LOG_WARNING,
547 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
548 av_get_sample_fmt_name(st->codec->sample_fmt),
549 codec->name,
550 av_get_sample_fmt_name(codec->sample_fmts[0]));
551 st->codec->sample_fmt = codec->sample_fmts[0];
552 }
553 }
554}
555
556/**
557 * Update the requested input sample format based on the output sample format.
558 * This is currently only used to request float output from decoders which
559 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
560 * Ideally this will be removed in the future when decoders do not do format
561 * conversion and only output in their native format.
562 */
563static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
564 AVCodecContext *enc)
565{
566 /* if sample formats match or a decoder sample format has already been
567 requested, just return */
568 if (enc->sample_fmt == dec->sample_fmt ||
569 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
570 return;
571
572 /* if decoder supports more than one output format */
573 if (dec_codec && dec_codec->sample_fmts &&
574 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
575 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
576 const enum AVSampleFormat *p;
577 int min_dec = -1, min_inc = -1;
578
579 /* find a matching sample format in the encoder */
580 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
581 if (*p == enc->sample_fmt) {
582 dec->request_sample_fmt = *p;
583 return;
584 } else if (*p > enc->sample_fmt) {
585 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
586 } else
587 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
588 }
589
590 /* if none match, provide the one that matches quality closest */
591 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
592 enc->sample_fmt - min_dec;
593 }
594}
595
596static void choose_sample_rate(AVStream *st, AVCodec *codec)
597{
598 if(codec && codec->supported_samplerates){
599 const int *p= codec->supported_samplerates;
600 int best=0;
601 int best_dist=INT_MAX;
602 for(; *p; p++){
603 int dist= abs(st->codec->sample_rate - *p);
604 if(dist < best_dist){
605 best_dist= dist;
606 best= *p;
607 }
608 }
609 if(best_dist){
610 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
611 }
612 st->codec->sample_rate= best;
613 }
614}
615
616static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
617{
618 if(codec && codec->pix_fmts){
619 const enum PixelFormat *p= codec->pix_fmts;
620 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
621 if(st->codec->codec_id==CODEC_ID_MJPEG){
622 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
623 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
624 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};
625 }
626 }
627 for(; *p!=-1; p++){
628 if(*p == st->codec->pix_fmt)
629 break;
630 }
631 if (*p == -1) {
632 if(st->codec->pix_fmt != PIX_FMT_NONE)
633 av_log(NULL, AV_LOG_WARNING,
634 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
635 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
636 codec->name,
637 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
638 st->codec->pix_fmt = codec->pix_fmts[0];
639 }
640 }
641}
642
6291d7e4
AK
643static double
644get_sync_ipts(const OutputStream *ost)
645{
646 const InputStream *ist = ost->sync_ist;
ea065176
AK
647 OutputFile *of = &output_files[ost->file_index];
648 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
6291d7e4
AK
649}
650
651static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
652 int ret;
653
654 while(bsfc){
655 AVPacket new_pkt= *pkt;
656 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
657 &new_pkt.data, &new_pkt.size,
658 pkt->data, pkt->size,
659 pkt->flags & AV_PKT_FLAG_KEY);
660 if(a>0){
661 av_free_packet(pkt);
662 new_pkt.destruct= av_destruct_packet;
663 } else if(a<0){
664 fprintf(stderr, "%s failed for stream %d, codec %s",
665 bsfc->filter->name, pkt->stream_index,
666 avctx->codec ? avctx->codec->name : "copy");
667 print_error("", a);
668 if (exit_on_error)
669 exit_program(1);
670 }
671 *pkt= new_pkt;
672
673 bsfc= bsfc->next;
674 }
675
676 ret= av_interleaved_write_frame(s, pkt);
677 if(ret < 0){
678 print_error("av_interleaved_write_frame()", ret);
679 exit_program(1);
680 }
681}
682
6291d7e4
AK
683static void do_audio_out(AVFormatContext *s,
684 OutputStream *ost,
685 InputStream *ist,
686 unsigned char *buf, int size)
687{
688 uint8_t *buftmp;
689 int64_t audio_out_size, audio_buf_size;
690 int64_t allocated_for_size= size;
691
692 int size_out, frame_bytes, ret, resample_changed;
693 AVCodecContext *enc= ost->st->codec;
694 AVCodecContext *dec= ist->st->codec;
695 int osize = av_get_bytes_per_sample(enc->sample_fmt);
696 int isize = av_get_bytes_per_sample(dec->sample_fmt);
697 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
698
699need_realloc:
700 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
701 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
702 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
703 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
704 audio_buf_size*= osize*enc->channels;
705
706 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
707 if(coded_bps > 8*osize)
708 audio_out_size= audio_out_size * coded_bps / (8*osize);
709 audio_out_size += FF_MIN_BUFFER_SIZE;
710
711 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
712 fprintf(stderr, "Buffer sizes too large\n");
713 exit_program(1);
714 }
715
716 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
717 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
718 if (!audio_buf || !audio_out){
719 fprintf(stderr, "Out of memory in do_audio_out\n");
720 exit_program(1);
721 }
722
723 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
724 ost->audio_resample = 1;
725
726 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
727 ost->resample_channels != dec->channels ||
728 ost->resample_sample_rate != dec->sample_rate;
729
730 if ((ost->audio_resample && !ost->resample) || resample_changed) {
731 if (resample_changed) {
732 av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
733 ist->file_index, ist->st->index,
734 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
735 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
736 ost->resample_sample_fmt = dec->sample_fmt;
737 ost->resample_channels = dec->channels;
738 ost->resample_sample_rate = dec->sample_rate;
739 if (ost->resample)
740 audio_resample_close(ost->resample);
741 }
742 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
743 if (audio_sync_method <= 1 &&
744 ost->resample_sample_fmt == enc->sample_fmt &&
745 ost->resample_channels == enc->channels &&
746 ost->resample_sample_rate == enc->sample_rate) {
747 ost->resample = NULL;
748 ost->audio_resample = 0;
749 } else if (ost->audio_resample) {
750 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
751 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
752 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
753 enc->sample_rate, dec->sample_rate,
754 enc->sample_fmt, dec->sample_fmt,
755 16, 10, 0, 0.8);
756 if (!ost->resample) {
757 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
758 dec->channels, dec->sample_rate,
759 enc->channels, enc->sample_rate);
760 exit_program(1);
761 }
762 }
763 }
764
765#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
766 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
767 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
768 if (ost->reformat_ctx)
769 av_audio_convert_free(ost->reformat_ctx);
770 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
771 dec->sample_fmt, 1, NULL, 0);
772 if (!ost->reformat_ctx) {
773 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
774 av_get_sample_fmt_name(dec->sample_fmt),
775 av_get_sample_fmt_name(enc->sample_fmt));
776 exit_program(1);
777 }
778 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
779 }
780
781 if(audio_sync_method){
782 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
783 - av_fifo_size(ost->fifo)/(enc->channels * 2);
784 double idelta= delta*dec->sample_rate / enc->sample_rate;
785 int byte_delta= ((int)idelta)*2*dec->channels;
786
787 //FIXME resample delay
788 if(fabs(delta) > 50){
789 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
790 if(byte_delta < 0){
791 byte_delta= FFMAX(byte_delta, -size);
792 size += byte_delta;
793 buf -= byte_delta;
794 if(verbose > 2)
795 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
796 if(!size)
797 return;
798 ist->is_start=0;
799 }else{
800 static uint8_t *input_tmp= NULL;
801 input_tmp= av_realloc(input_tmp, byte_delta + size);
802
803 if(byte_delta > allocated_for_size - size){
804 allocated_for_size= byte_delta + (int64_t)size;
805 goto need_realloc;
806 }
807 ist->is_start=0;
808
809 memset(input_tmp, 0, byte_delta);
810 memcpy(input_tmp + byte_delta, buf, size);
811 buf= input_tmp;
812 size += byte_delta;
813 if(verbose > 2)
814 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
815 }
816 }else if(audio_sync_method>1){
817 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
818 av_assert0(ost->audio_resample);
819 if(verbose > 2)
820 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
821// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
822 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
823 }
824 }
825 }else
826 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
827 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
828
829 if (ost->audio_resample) {
830 buftmp = audio_buf;
831 size_out = audio_resample(ost->resample,
832 (short *)buftmp, (short *)buf,
833 size / (dec->channels * isize));
834 size_out = size_out * enc->channels * osize;
835 } else {
836 buftmp = buf;
837 size_out = size;
838 }
839
840 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
841 const void *ibuf[6]= {buftmp};
842 void *obuf[6]= {audio_buf};
843 int istride[6]= {isize};
844 int ostride[6]= {osize};
845 int len= size_out/istride[0];
846 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
847 printf("av_audio_convert() failed\n");
848 if (exit_on_error)
849 exit_program(1);
850 return;
851 }
852 buftmp = audio_buf;
853 size_out = len*osize;
854 }
855
856 /* now encode as many frames as possible */
857 if (enc->frame_size > 1) {
858 /* output resampled raw samples */
859 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
860 fprintf(stderr, "av_fifo_realloc2() failed\n");
861 exit_program(1);
862 }
863 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
864
865 frame_bytes = enc->frame_size * osize * enc->channels;
866
867 while (av_fifo_size(ost->fifo) >= frame_bytes) {
868 AVPacket pkt;
869 av_init_packet(&pkt);
870
871 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
872
873 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
874
875 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
876 (short *)audio_buf);
877 if (ret < 0) {
878 fprintf(stderr, "Audio encoding failed\n");
879 exit_program(1);
880 }
881 audio_size += ret;
882 pkt.stream_index= ost->index;
883 pkt.data= audio_out;
884 pkt.size= ret;
885 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
886 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
887 pkt.flags |= AV_PKT_FLAG_KEY;
888 write_frame(s, &pkt, enc, ost->bitstream_filters);
889
890 ost->sync_opts += enc->frame_size;
891 }
892 } else {
893 AVPacket pkt;
894 av_init_packet(&pkt);
895
896 ost->sync_opts += size_out / (osize * enc->channels);
897
898 /* output a pcm frame */
899 /* determine the size of the coded buffer */
900 size_out /= osize;
901 if (coded_bps)
902 size_out = size_out*coded_bps/8;
903
904 if(size_out > audio_out_size){
905 fprintf(stderr, "Internal error, buffer size too small\n");
906 exit_program(1);
907 }
908
909 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
910 ret = avcodec_encode_audio(enc, audio_out, size_out,
911 (short *)buftmp);
912 if (ret < 0) {
913 fprintf(stderr, "Audio encoding failed\n");
914 exit_program(1);
915 }
916 audio_size += ret;
917 pkt.stream_index= ost->index;
918 pkt.data= audio_out;
919 pkt.size= ret;
920 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
921 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
922 pkt.flags |= AV_PKT_FLAG_KEY;
923 write_frame(s, &pkt, enc, ost->bitstream_filters);
924 }
925}
926
927static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
928{
929 AVCodecContext *dec;
930 AVPicture *picture2;
931 AVPicture picture_tmp;
932 uint8_t *buf = 0;
933
934 dec = ist->st->codec;
935
936 /* deinterlace : must be done before any resize */
937 if (do_deinterlace) {
938 int size;
939
940 /* create temporary picture */
941 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
942 buf = av_malloc(size);
943 if (!buf)
944 return;
945
946 picture2 = &picture_tmp;
947 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
948
949 if(avpicture_deinterlace(picture2, picture,
950 dec->pix_fmt, dec->width, dec->height) < 0) {
951 /* if error, do not deinterlace */
952 fprintf(stderr, "Deinterlacing failed\n");
953 av_free(buf);
954 buf = NULL;
955 picture2 = picture;
956 }
957 } else {
958 picture2 = picture;
959 }
960
961 if (picture != picture2)
962 *picture = *picture2;
963 *bufp = buf;
964}
965
6291d7e4
AK
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
af70aa45 1273static void print_report(OutputFile *output_files,
4288e031 1274 OutputStream *ost_table, int nb_ostreams,
6291d7e4
AK
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
af70aa45 1301 oc = output_files[0].ctx;
6291d7e4
AK
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;
4288e031 1312 ost = &ost_table[i];
6291d7e4
AK
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,
4288e031 1405 OutputStream *ost_table, int nb_ostreams,
6291d7e4
AK
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
6291d7e4
AK
1552 // preprocess audio (volume)
1553 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1554 if (audio_volume != 256) {
1555 short *volp;
1556 volp = samples;
1557 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1558 int v = ((*volp) * audio_volume + 128) >> 8;
1559 if (v < -32768) v = -32768;
1560 if (v > 32767) v = 32767;
1561 *volp++ = v;
1562 }
1563 }
1564 }
1565
1566 /* frame rate emulation */
1567 if (rate_emu) {
1568 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1569 int64_t now = av_gettime() - ist->start;
1570 if (pts > now)
1571 usleep(pts - now);
1572 }
1573 /* if output time reached then transcode raw format,
1574 encode packets and output them */
ea065176 1575 for (i = 0; i < nb_ostreams; i++) {
45f86128
AK
1576 OutputFile *of = &output_files[ost_table[i].file_index];
1577 int frame_size;
6291d7e4 1578
45f86128
AK
1579 ost = &ost_table[i];
1580 if (ost->source_index != ist_index)
1581 continue;
f1176d41 1582
45f86128
AK
1583 if (of->start_time && ist->pts < of->start_time)
1584 continue;
ea065176 1585
45f86128
AK
1586 if (of->recording_time != INT64_MAX &&
1587 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1588 (AVRational){1, 1000000}) >= 0) {
1589 ost->is_past_recording_time = 1;
1590 continue;
1591 }
ef44a607 1592
6291d7e4 1593#if CONFIG_AVFILTER
45f86128
AK
1594 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1595 ost->input_video_filter) {
1596 AVRational sar;
1597 if (ist->st->sample_aspect_ratio.num)
1598 sar = ist->st->sample_aspect_ratio;
1599 else
1600 sar = ist->st->codec->sample_aspect_ratio;
1601 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
1602 }
1603 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1604 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1605 while (frame_available) {
1606 AVRational ist_pts_tb;
1607 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1608 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1609 if (ost->picref)
1610 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
6291d7e4 1611#endif
45f86128
AK
1612 os = output_files[ost->file_index].ctx;
1613
1614 /* set the input output pts pairs */
1615 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1616
1617 if (ost->encoding_needed) {
1618 av_assert0(ist->decoding_needed);
1619 switch(ost->st->codec->codec_type) {
1620 case AVMEDIA_TYPE_AUDIO:
1621 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1622 break;
1623 case AVMEDIA_TYPE_VIDEO:
6291d7e4 1624#if CONFIG_AVFILTER
45f86128
AK
1625 if (ost->picref->video && !ost->frame_aspect_ratio)
1626 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
6291d7e4 1627#endif
45f86128
AK
1628 do_video_out(os, ost, ist, &picture, &frame_size,
1629 same_quant ? quality : ost->st->codec->global_quality);
1630 if (vstats_filename && frame_size)
1631 do_video_stats(os, ost, frame_size);
1632 break;
1633 case AVMEDIA_TYPE_SUBTITLE:
1634 do_subtitle_out(os, ost, ist, &subtitle,
1635 pkt->pts);
1636 break;
1637 default:
1638 abort();
1639 }
1640 } else {
1641 AVFrame avframe; //FIXME/XXX remove this
1642 AVPacket opkt;
1643 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
6291d7e4 1644
45f86128 1645 av_init_packet(&opkt);
6291d7e4 1646
45f86128 1647 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
6291d7e4 1648#if !CONFIG_AVFILTER
45f86128 1649 continue;
6291d7e4 1650#else
45f86128 1651 goto cont;
6291d7e4
AK
1652#endif
1653
45f86128
AK
1654 /* no reencoding needed : output the packet directly */
1655 /* force the input stream PTS */
1656
1657 avcodec_get_frame_defaults(&avframe);
1658 ost->st->codec->coded_frame= &avframe;
1659 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1660
1661 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1662 audio_size += data_size;
1663 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1664 video_size += data_size;
1665 ost->sync_opts++;
6291d7e4 1666 }
45f86128
AK
1667
1668 opkt.stream_index= ost->index;
1669 if(pkt->pts != AV_NOPTS_VALUE)
1670 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1671 else
1672 opkt.pts= AV_NOPTS_VALUE;
1673
1674 if (pkt->dts == AV_NOPTS_VALUE)
1675 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1676 else
1677 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1678 opkt.dts -= ost_tb_start_time;
1679
1680 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1681 opkt.flags= pkt->flags;
1682
1683 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1684 if( ost->st->codec->codec_id != CODEC_ID_H264
1685 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1686 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1687 ) {
1688 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1689 opkt.destruct= av_destruct_packet;
1690 } else {
1691 opkt.data = data_buf;
1692 opkt.size = data_size;
1693 }
1694
1695 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1696 ost->st->codec->frame_number++;
1697 ost->frame_number++;
1698 av_free_packet(&opkt);
6291d7e4 1699 }
45f86128
AK
1700#if CONFIG_AVFILTER
1701 cont:
1702 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1703 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1704 if (ost->picref)
1705 avfilter_unref_buffer(ost->picref);
1706 }
6291d7e4 1707#endif
6291d7e4
AK
1708 }
1709
1710 av_free(buffer_to_free);
1711 /* XXX: allocate the subtitles in the codec ? */
1712 if (subtitle_to_free) {
1713 avsubtitle_free(subtitle_to_free);
1714 subtitle_to_free = NULL;
1715 }
1716 }
1717 discard_packet:
1718 if (pkt == NULL) {
1719 /* EOF handling */
1720
1721 for(i=0;i<nb_ostreams;i++) {
4288e031 1722 ost = &ost_table[i];
6291d7e4
AK
1723 if (ost->source_index == ist_index) {
1724 AVCodecContext *enc= ost->st->codec;
af70aa45 1725 os = output_files[ost->file_index].ctx;
6291d7e4
AK
1726
1727 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1728 continue;
1729 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1730 continue;
1731
1732 if (ost->encoding_needed) {
1733 for(;;) {
1734 AVPacket pkt;
1735 int fifo_bytes;
1736 av_init_packet(&pkt);
1737 pkt.stream_index= ost->index;
1738
1739 switch(ost->st->codec->codec_type) {
1740 case AVMEDIA_TYPE_AUDIO:
1741 fifo_bytes = av_fifo_size(ost->fifo);
1742 ret = 0;
1743 /* encode any samples remaining in fifo */
1744 if (fifo_bytes > 0) {
1745 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1746 int fs_tmp = enc->frame_size;
1747
1748 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1749 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1750 enc->frame_size = fifo_bytes / (osize * enc->channels);
1751 } else { /* pad */
1752 int frame_bytes = enc->frame_size*osize*enc->channels;
1753 if (allocated_audio_buf_size < frame_bytes)
1754 exit_program(1);
1755 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1756 }
1757
1758 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1759 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1760 ost->st->time_base.num, enc->sample_rate);
1761 enc->frame_size = fs_tmp;
1762 }
1763 if(ret <= 0) {
1764 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1765 }
1766 if (ret < 0) {
1767 fprintf(stderr, "Audio encoding failed\n");
1768 exit_program(1);
1769 }
1770 audio_size += ret;
1771 pkt.flags |= AV_PKT_FLAG_KEY;
1772 break;
1773 case AVMEDIA_TYPE_VIDEO:
1774 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1775 if (ret < 0) {
1776 fprintf(stderr, "Video encoding failed\n");
1777 exit_program(1);
1778 }
1779 video_size += ret;
1780 if(enc->coded_frame && enc->coded_frame->key_frame)
1781 pkt.flags |= AV_PKT_FLAG_KEY;
1782 if (ost->logfile && enc->stats_out) {
1783 fprintf(ost->logfile, "%s", enc->stats_out);
1784 }
1785 break;
1786 default:
1787 ret=-1;
1788 }
1789
1790 if(ret<=0)
1791 break;
1792 pkt.data= bit_buffer;
1793 pkt.size= ret;
1794 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1795 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1796 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1797 }
1798 }
1799 }
1800 }
1801 }
1802
1803 return 0;
1804}
1805
af70aa45 1806static void print_sdp(OutputFile *output_files, int n)
6291d7e4
AK
1807{
1808 char sdp[2048];
af70aa45
AK
1809 int i;
1810 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1811
1812 if (!avc)
1813 exit_program(1);
1814 for (i = 0; i < n; i++)
1815 avc[i] = output_files[i].ctx;
6291d7e4
AK
1816
1817 av_sdp_create(avc, n, sdp, sizeof(sdp));
1818 printf("SDP:\n%s\n", sdp);
1819 fflush(stdout);
af70aa45 1820 av_freep(&avc);
6291d7e4
AK
1821}
1822
6291d7e4
AK
1823/*
1824 * The following code is the main loop of the file converter
1825 */
af70aa45 1826static int transcode(OutputFile *output_files,
6291d7e4
AK
1827 int nb_output_files,
1828 InputFile *input_files,
3d4f0dab 1829 int nb_input_files)
6291d7e4 1830{
4288e031 1831 int ret = 0, i, j;
6291d7e4
AK
1832 AVFormatContext *is, *os;
1833 AVCodecContext *codec, *icodec;
4288e031 1834 OutputStream *ost;
6291d7e4
AK
1835 InputStream *ist;
1836 char error[1024];
1837 int want_sdp = 1;
b0c9e8e0 1838 uint8_t *no_packet;
6291d7e4
AK
1839 int no_packet_count=0;
1840
b0c9e8e0
AK
1841 if (!(no_packet = av_mallocz(nb_input_files)))
1842 exit_program(1);
1843
6291d7e4
AK
1844 if (rate_emu)
1845 for (i = 0; i < nb_input_streams; i++)
1846 input_streams[i].start = av_gettime();
1847
1848 /* output stream init */
6291d7e4 1849 for(i=0;i<nb_output_files;i++) {
af70aa45 1850 os = output_files[i].ctx;
6291d7e4 1851 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
af70aa45 1852 av_dump_format(os, i, os->filename, 1);
6291d7e4
AK
1853 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1854 ret = AVERROR(EINVAL);
1855 goto fail;
1856 }
6291d7e4
AK
1857 }
1858
1859 /* for each output stream, we compute the right encoding parameters */
4288e031
AK
1860 for (i = 0; i < nb_output_streams; i++) {
1861 ost = &output_streams[i];
af70aa45 1862 os = output_files[ost->file_index].ctx;
6291d7e4
AK
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 */
4288e031
AK
2089 for (i = 0; i < nb_output_streams; i++) {
2090 ost = &output_streams[i];
6291d7e4
AK
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 */
4288e031
AK
2140 for (j = 0; j < nb_output_streams; j++) {
2141 ost = &output_streams[j];
6291d7e4
AK
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 2170 /* open files and write file headers */
af70aa45
AK
2171 for (i = 0; i < nb_output_files; i++) {
2172 os = output_files[i].ctx;
2173 if (avformat_write_header(os, &output_files[i].opts) < 0) {
6291d7e4
AK
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 }
af70aa45
AK
2178 assert_avoptions(output_files[i].opts);
2179 if (strcmp(os->oformat->name, "rtp")) {
6291d7e4
AK
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++) {
af70aa45 2188 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
6291d7e4
AK
2189 }
2190
2191 /* dump the stream mapping */
2192 if (verbose >= 0) {
2193 fprintf(stderr, "Stream mapping:\n");
4288e031
AK
2194 for (i = 0; i < nb_output_streams;i ++) {
2195 ost = &output_streams[i];
6291d7e4
AK
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;
4288e031 2239 for (i = 0; i < nb_output_streams; i++) {
9be3c124
AC
2240 int64_t ipts;
2241 double opts;
4288e031 2242 ost = &output_streams[i];
af70aa45 2243 os = output_files[ost->file_index].ctx;
6291d7e4 2244 ist = &input_streams[ost->source_index];
ef44a607 2245 if(ost->is_past_recording_time || no_packet[ist->file_index])
6291d7e4
AK
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;
b0c9e8e0 2268 memset(no_packet, 0, nb_input_files);
6291d7e4
AK
2269 usleep(10000);
2270 continue;
2271 }
2272 break;
2273 }
2274
2275 /* finish if limit size exhausted */
af70aa45 2276 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0].ctx->pb))
6291d7e4
AK
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;
b0c9e8e0 2296 memset(no_packet, 0, nb_input_files);
6291d7e4
AK
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
6291d7e4 2339 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
4288e031 2340 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
6291d7e4
AK
2341
2342 if (verbose >= 0)
2343 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2344 ist->file_index, ist->st->index);
2345 if (exit_on_error)
2346 exit_program(1);
2347 av_free_packet(&pkt);
2348 goto redo;
2349 }
2350
2351 discard_packet:
2352 av_free_packet(&pkt);
2353
2354 /* dump report by using the output first video and audio streams */
4288e031 2355 print_report(output_files, output_streams, nb_output_streams, 0);
6291d7e4
AK
2356 }
2357
2358 /* at the end of stream, we must flush the decoder buffers */
2359 for (i = 0; i < nb_input_streams; i++) {
2360 ist = &input_streams[i];
2361 if (ist->decoding_needed) {
4288e031 2362 output_packet(ist, i, output_streams, nb_output_streams, NULL);
6291d7e4
AK
2363 }
2364 }
2365
2366 term_exit();
2367
2368 /* write the trailer if needed and close file */
2369 for(i=0;i<nb_output_files;i++) {
af70aa45 2370 os = output_files[i].ctx;
6291d7e4
AK
2371 av_write_trailer(os);
2372 }
2373
2374 /* dump report by using the first video and audio streams */
4288e031 2375 print_report(output_files, output_streams, nb_output_streams, 1);
6291d7e4
AK
2376
2377 /* close each encoder */
4288e031
AK
2378 for (i = 0; i < nb_output_streams; i++) {
2379 ost = &output_streams[i];
6291d7e4
AK
2380 if (ost->encoding_needed) {
2381 av_freep(&ost->st->codec->stats_in);
2382 avcodec_close(ost->st->codec);
2383 }
2384#if CONFIG_AVFILTER
2385 avfilter_graph_free(&ost->graph);
2386#endif
2387 }
2388
2389 /* close each decoder */
2390 for (i = 0; i < nb_input_streams; i++) {
2391 ist = &input_streams[i];
2392 if (ist->decoding_needed) {
2393 avcodec_close(ist->st->codec);
2394 }
2395 }
2396
2397 /* finished ! */
2398 ret = 0;
2399
2400 fail:
2401 av_freep(&bit_buffer);
b0c9e8e0 2402 av_freep(&no_packet);
6291d7e4 2403
4288e031
AK
2404 if (output_streams) {
2405 for (i = 0; i < nb_output_streams; i++) {
2406 ost = &output_streams[i];
6291d7e4
AK
2407 if (ost) {
2408 if (ost->st->stream_copy)
2409 av_freep(&ost->st->codec->extradata);
2410 if (ost->logfile) {
2411 fclose(ost->logfile);
2412 ost->logfile = NULL;
2413 }
2414 av_fifo_free(ost->fifo); /* works even if fifo is not
2415 initialized but set to zero */
2416 av_freep(&ost->st->codec->subtitle_header);
2417 av_free(ost->pict_tmp.data[0]);
2418 av_free(ost->forced_kf_pts);
2419 if (ost->video_resample)
2420 sws_freeContext(ost->img_resample_ctx);
2421 if (ost->resample)
2422 audio_resample_close(ost->resample);
2423 if (ost->reformat_ctx)
2424 av_audio_convert_free(ost->reformat_ctx);
2425 av_dict_free(&ost->opts);
6291d7e4
AK
2426 }
2427 }
6291d7e4
AK
2428 }
2429 return ret;
2430}
2431
2432static int opt_format(const char *opt, const char *arg)
2433{
2434 last_asked_format = arg;
2435 return 0;
2436}
2437
2438static int opt_video_rc_override_string(const char *opt, const char *arg)
2439{
2440 video_rc_override_string = arg;
2441 return 0;
2442}
2443
2444static int opt_me_threshold(const char *opt, const char *arg)
2445{
2446 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2447 return 0;
2448}
2449
2450static int opt_verbose(const char *opt, const char *arg)
2451{
2452 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2453 return 0;
2454}
2455
2456static int opt_frame_rate(const char *opt, const char *arg)
2457{
2458 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2459 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2460 exit_program(1);
2461 }
2462 return 0;
2463}
2464
2465static int opt_frame_crop(const char *opt, const char *arg)
2466{
2467 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2468 return AVERROR(EINVAL);
2469}
2470
2471static int opt_frame_size(const char *opt, const char *arg)
2472{
2473 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2474 fprintf(stderr, "Incorrect frame size\n");
2475 return AVERROR(EINVAL);
2476 }
2477 return 0;
2478}
2479
2480static int opt_pad(const char *opt, const char *arg) {
2481 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2482 return -1;
2483}
2484
2485static int opt_frame_pix_fmt(const char *opt, const char *arg)
2486{
2487 if (strcmp(arg, "list")) {
2488 frame_pix_fmt = av_get_pix_fmt(arg);
2489 if (frame_pix_fmt == PIX_FMT_NONE) {
2490 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2491 return AVERROR(EINVAL);
2492 }
2493 } else {
2494 show_pix_fmts();
2495 exit_program(0);
2496 }
2497 return 0;
2498}
2499
2500static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2501{
2502 int x = 0, y = 0;
2503 double ar = 0;
2504 const char *p;
2505 char *end;
2506
2507 p = strchr(arg, ':');
2508 if (p) {
2509 x = strtol(arg, &end, 10);
2510 if (end == p)
2511 y = strtol(end+1, &end, 10);
2512 if (x > 0 && y > 0)
2513 ar = (double)x / (double)y;
2514 } else
2515 ar = strtod(arg, NULL);
2516
2517 if (!ar) {
2518 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2519 return AVERROR(EINVAL);
2520 }
2521 frame_aspect_ratio = ar;
2522 return 0;
2523}
2524
2525static int opt_metadata(const char *opt, const char *arg)
2526{
2527 char *mid= strchr(arg, '=');
2528
2529 if(!mid){
2530 fprintf(stderr, "Missing =\n");
2531 exit_program(1);
2532 }
2533 *mid++= 0;
2534
2535 av_dict_set(&metadata, arg, mid, 0);
2536
2537 return 0;
2538}
2539
2540static int opt_qscale(const char *opt, const char *arg)
2541{
2542 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2543 if (video_qscale == 0) {
2544 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2545 return AVERROR(EINVAL);
2546 }
2547 return 0;
2548}
2549
2550static int opt_top_field_first(const char *opt, const char *arg)
2551{
2552 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2553 return 0;
2554}
2555
2556static int opt_thread_count(const char *opt, const char *arg)
2557{
2558 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2559#if !HAVE_THREADS
2560 if (verbose >= 0)
2561 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2562#endif
2563 return 0;
2564}
2565
2566static int opt_audio_sample_fmt(const char *opt, const char *arg)
2567{
2568 if (strcmp(arg, "list")) {
2569 audio_sample_fmt = av_get_sample_fmt(arg);
2570 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2571 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2572 return AVERROR(EINVAL);
2573 }
2574 } else {
2575 int i;
2576 char fmt_str[128];
2577 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2578 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2579 exit_program(0);
2580 }
2581 return 0;
2582}
2583
2584static int opt_audio_rate(const char *opt, const char *arg)
2585{
2586 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2587 return 0;
2588}
2589
2590static int opt_audio_channels(const char *opt, const char *arg)
2591{
2592 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2593 return 0;
2594}
2595
92f1940e 2596static int opt_codec(const char *opt, const char *arg)
6291d7e4 2597{
92f1940e 2598 return av_dict_set(&codec_names, opt, arg, 0);
6291d7e4
AK
2599}
2600
2601static int opt_audio_codec(const char *opt, const char *arg)
2602{
92f1940e 2603 return opt_codec("codec:a", arg);
6291d7e4
AK
2604}
2605
2606static int opt_video_codec(const char *opt, const char *arg)
2607{
92f1940e 2608 return opt_codec("codec:v", arg);
6291d7e4
AK
2609}
2610
2611static int opt_subtitle_codec(const char *opt, const char *arg)
2612{
92f1940e 2613 return opt_codec("codec:s", arg);
6291d7e4
AK
2614}
2615
2616static int opt_data_codec(const char *opt, const char *arg)
2617{
92f1940e 2618 return opt_codec("codec:d", arg);
6291d7e4
AK
2619}
2620
2621static int opt_codec_tag(const char *opt, const char *arg)
2622{
2623 char *tail;
2624 uint32_t *codec_tag;
2625
2626 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2627 !strcmp(opt, "vtag") ? &video_codec_tag :
2628 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2629 if (!codec_tag)
2630 return -1;
2631
2632 *codec_tag = strtol(arg, &tail, 0);
2633 if (!tail || *tail)
2634 *codec_tag = AV_RL32(arg);
2635
2636 return 0;
2637}
2638
2639static int opt_map(const char *opt, const char *arg)
2640{
8d2e4a7e
AK
2641 StreamMap *m = NULL;
2642 int i, negative = 0, file_idx;
2643 int sync_file_idx = -1, sync_stream_idx;
2644 char *p, *sync;
2645 char *map;
6291d7e4 2646
8d2e4a7e
AK
2647 if (*arg == '-') {
2648 negative = 1;
2649 arg++;
2650 }
2651 map = av_strdup(arg);
6291d7e4 2652
8d2e4a7e
AK
2653 /* parse sync stream first, just pick first matching stream */
2654 if (sync = strchr(map, ',')) {
2655 *sync = 0;
2656 sync_file_idx = strtol(sync + 1, &sync, 0);
2657 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2658 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2659 exit_program(1);
2660 }
2661 if (*sync)
2662 sync++;
2663 for (i = 0; i < input_files[sync_file_idx].ctx->nb_streams; i++)
2664 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2665 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2666 sync_stream_idx = i;
2667 break;
2668 }
2669 if (i == input_files[sync_file_idx].ctx->nb_streams) {
2670 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2671 "match any streams.\n", arg);
2672 exit_program(1);
2673 }
2674 }
6291d7e4 2675
8d2e4a7e
AK
2676
2677 file_idx = strtol(map, &p, 0);
2678 if (file_idx >= nb_input_files || file_idx < 0) {
2679 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2680 exit_program(1);
6291d7e4 2681 }
8d2e4a7e
AK
2682 if (negative)
2683 /* disable some already defined maps */
2684 for (i = 0; i < nb_stream_maps; i++) {
2685 m = &stream_maps[i];
2686 if (check_stream_specifier(input_files[m->file_index].ctx,
2687 input_files[m->file_index].ctx->streams[m->stream_index],
2688 *p == ':' ? p + 1 : p) > 0)
2689 m->disabled = 1;
2690 }
2691 else
2692 for (i = 0; i < input_files[file_idx].ctx->nb_streams; i++) {
2693 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2694 *p == ':' ? p + 1 : p) <= 0)
2695 continue;
2696 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2697 m = &stream_maps[nb_stream_maps - 1];
2698
2699 m->file_index = file_idx;
2700 m->stream_index = i;
2701
2702 if (sync_file_idx >= 0) {
2703 m->sync_file_index = sync_file_idx;
2704 m->sync_stream_index = sync_stream_idx;
2705 } else {
2706 m->sync_file_index = file_idx;
2707 m->sync_stream_index = i;
2708 }
2709 }
2710
2711 if (!m) {
2712 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2713 exit_program(1);
2714 }
2715
2716 av_freep(&map);
6291d7e4
AK
2717 return 0;
2718}
2719
e6e6060c 2720static void parse_meta_type(char *arg, char *type, int *index)
6291d7e4 2721{
e6e6060c 2722 if (*arg == ':') {
6291d7e4
AK
2723 *type = *(++arg);
2724 switch (*arg) {
2725 case 'g':
2726 break;
2727 case 's':
2728 case 'c':
2729 case 'p':
e6e6060c
AK
2730 if (*(++arg) == ':')
2731 *index = strtol(++arg, NULL, 0);
6291d7e4
AK
2732 break;
2733 default:
2734 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2735 exit_program(1);
2736 }
2737 } else
2738 *type = 'g';
2739}
2740
2741static int opt_map_metadata(const char *opt, const char *arg)
2742{
2743 MetadataMap *m, *m1;
2744 char *p;
2745
2746 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2747 &nb_meta_data_maps, nb_meta_data_maps + 1);
2748
e6e6060c 2749 m = &meta_data_maps[nb_meta_data_maps - 1][1];
6291d7e4 2750 m->file = strtol(arg, &p, 0);
e6e6060c 2751 parse_meta_type(p, &m->type, &m->index);
6291d7e4 2752
e6e6060c
AK
2753 m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2754 if (p = strchr(opt, ':'))
2755 parse_meta_type(p, &m1->type, &m1->index);
2756 else
2757 m1->type = 'g';
6291d7e4
AK
2758
2759 if (m->type == 'g' || m1->type == 'g')
2760 metadata_global_autocopy = 0;
2761 if (m->type == 's' || m1->type == 's')
2762 metadata_streams_autocopy = 0;
2763 if (m->type == 'c' || m1->type == 'c')
2764 metadata_chapters_autocopy = 0;
2765
2766 return 0;
2767}
2768
6291d7e4
AK
2769static int opt_input_ts_scale(const char *opt, const char *arg)
2770{
09af7fb3 2771 return av_dict_set(&ts_scale, opt, arg, 0);
6291d7e4
AK
2772}
2773
2774static int opt_recording_time(const char *opt, const char *arg)
2775{
2776 recording_time = parse_time_or_die(opt, arg, 1);
2777 return 0;
2778}
2779
2780static int opt_start_time(const char *opt, const char *arg)
2781{
2782 start_time = parse_time_or_die(opt, arg, 1);
2783 return 0;
2784}
2785
6291d7e4
AK
2786static int opt_input_ts_offset(const char *opt, const char *arg)
2787{
2788 input_ts_offset = parse_time_or_die(opt, arg, 1);
2789 return 0;
2790}
2791
169f0647
AK
2792static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2793{
2794 const char *codec_string = encoder ? "encoder" : "decoder";
2795 AVCodec *codec;
2796
2797 if(!name)
2798 return CODEC_ID_NONE;
2799 codec = encoder ?
2800 avcodec_find_encoder_by_name(name) :
2801 avcodec_find_decoder_by_name(name);
2802 if(!codec) {
2803 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2804 exit_program(1);
2805 }
2806 if(codec->type != type) {
2807 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2808 exit_program(1);
2809 }
2810 return codec->id;
2811}
2812
2813static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
2814{
2815 AVDictionaryEntry *e = NULL;
2816 char *codec_name = NULL;
2817 int ret;
2818
2819 while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
2820 char *p = strchr(e->key, ':');
2821
2822 if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
2823 codec_name = e->value;
2824 else if (ret < 0)
2825 exit_program(1);
2826 }
2827
2828 if (!codec_name) {
6cd9d0f7
AK
2829 if (s->oformat) {
2830 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2831 return avcodec_find_encoder(st->codec->codec_id);
2832 }
169f0647
AK
2833 } else if (!strcmp(codec_name, "copy"))
2834 st->stream_copy = 1;
2835 else {
2836 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2837 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2838 avcodec_find_decoder_by_name(codec_name);
2839 }
2840
2841 return NULL;
2842}
6291d7e4 2843
88867844
AK
2844/**
2845 * Add all the streams from the given input file to the global
2846 * list of input streams.
2847 */
2848static void add_input_streams(AVFormatContext *ic)
2849{
09af7fb3 2850 int i, rfps, rfps_base, ret;
88867844
AK
2851
2852 for (i = 0; i < ic->nb_streams; i++) {
2853 AVStream *st = ic->streams[i];
2854 AVCodecContext *dec = st->codec;
09af7fb3 2855 AVDictionaryEntry *e = NULL;
88867844 2856 InputStream *ist;
09af7fb3 2857 char *scale = NULL;
88867844
AK
2858
2859 dec->thread_count = thread_count;
2860
2861 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2862 ist = &input_streams[nb_input_streams - 1];
2863 ist->st = st;
2864 ist->file_index = nb_input_files;
2865 ist->discard = 1;
2866 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2867
09af7fb3
AK
2868 while (e = av_dict_get(ts_scale, "", e, AV_DICT_IGNORE_SUFFIX)) {
2869 char *p = strchr(e->key, ':');
2870
2871 if ((ret = check_stream_specifier(ic, st, p ? p + 1 : "")) > 0)
2872 scale = e->value;
2873 else if (ret < 0)
2874 exit_program(1);
2875 }
2876 if (scale)
2877 ist->ts_scale = strtod(scale, NULL);
88867844
AK
2878
2879 ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
2880
2881 switch (dec->codec_type) {
2882 case AVMEDIA_TYPE_AUDIO:
2883 if(audio_disable)
2884 st->discard= AVDISCARD_ALL;
2885 break;
2886 case AVMEDIA_TYPE_VIDEO:
2887 rfps = ic->streams[i]->r_frame_rate.num;
2888 rfps_base = ic->streams[i]->r_frame_rate.den;
2889 if (dec->lowres) {
2890 dec->flags |= CODEC_FLAG_EMU_EDGE;
2891 dec->height >>= dec->lowres;
2892 dec->width >>= dec->lowres;
2893 }
2894 if(me_threshold)
2895 dec->debug |= FF_DEBUG_MV;
2896
2897 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2898
2899 if (verbose >= 0)
2900 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2901 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2902
2903 (float)rfps / rfps_base, rfps, rfps_base);
2904 }
2905
2906 if(video_disable)
2907 st->discard= AVDISCARD_ALL;
2908 else if(video_discard)
2909 st->discard= video_discard;
2910 break;
2911 case AVMEDIA_TYPE_DATA:
2912 break;
2913 case AVMEDIA_TYPE_SUBTITLE:
2914 if(subtitle_disable)
2915 st->discard = AVDISCARD_ALL;
2916 break;
2917 case AVMEDIA_TYPE_ATTACHMENT:
2918 case AVMEDIA_TYPE_UNKNOWN:
2919 break;
2920 default:
2921 abort();
2922 }
2923 }
2924}
2925
6291d7e4
AK
2926static int opt_input_file(const char *opt, const char *filename)
2927{
2928 AVFormatContext *ic;
2929 AVInputFormat *file_iformat = NULL;
88867844 2930 int err, i, ret;
6291d7e4
AK
2931 int64_t timestamp;
2932 uint8_t buf[128];
2933 AVDictionary **opts;
2934 int orig_nb_streams; // number of streams before avformat_find_stream_info
2935
2936 if (last_asked_format) {
2937 if (!(file_iformat = av_find_input_format(last_asked_format))) {
2938 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2939 exit_program(1);
2940 }
2941 last_asked_format = NULL;
2942 }
2943
2944 if (!strcmp(filename, "-"))
2945 filename = "pipe:";
2946
2947 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2948 !strcmp(filename, "/dev/stdin");
2949
2950 /* get default parameters from command line */
2951 ic = avformat_alloc_context();
2952 if (!ic) {
2953 print_error(filename, AVERROR(ENOMEM));
2954 exit_program(1);
2955 }
2956 if (audio_sample_rate) {
2957 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
2958 av_dict_set(&format_opts, "sample_rate", buf, 0);
2959 }
2960 if (audio_channels) {
2961 snprintf(buf, sizeof(buf), "%d", audio_channels);
2962 av_dict_set(&format_opts, "channels", buf, 0);
2963 }
2964 if (frame_rate.num) {
2965 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
2966 av_dict_set(&format_opts, "framerate", buf, 0);
2967 }
2968 if (frame_width && frame_height) {
2969 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
2970 av_dict_set(&format_opts, "video_size", buf, 0);
2971 }
2972 if (frame_pix_fmt != PIX_FMT_NONE)
2973 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
2974
6291d7e4
AK
2975 ic->flags |= AVFMT_FLAG_NONBLOCK;
2976
2977 /* open the input file with generic libav function */
2978 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2979 if (err < 0) {
2980 print_error(filename, err);
2981 exit_program(1);
2982 }
2983 assert_avoptions(format_opts);
2984
2985 if(opt_programid) {
2986 int i, j;
2987 int found=0;
2988 for(i=0; i<ic->nb_streams; i++){
2989 ic->streams[i]->discard= AVDISCARD_ALL;
2990 }
2991 for(i=0; i<ic->nb_programs; i++){
2992 AVProgram *p= ic->programs[i];
2993 if(p->id != opt_programid){
2994 p->discard = AVDISCARD_ALL;
2995 }else{
2996 found=1;
2997 for(j=0; j<p->nb_stream_indexes; j++){
2998 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
2999 }
3000 }
3001 }
3002 if(!found){
3003 fprintf(stderr, "Specified program id not found\n");
3004 exit_program(1);
3005 }
3006 opt_programid=0;
3007 }
3008
92f1940e
AK
3009 /* apply forced codec ids */
3010 for (i = 0; i < ic->nb_streams; i++)
3011 choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
3012
6291d7e4
AK
3013 /* Set AVCodecContext options for avformat_find_stream_info */
3014 opts = setup_find_stream_info_opts(ic, codec_opts);
3015 orig_nb_streams = ic->nb_streams;
3016
3017 /* If not enough info to get the stream parameters, we decode the
3018 first frames to get it. (used in mpeg case for example) */
3019 ret = avformat_find_stream_info(ic, opts);
3020 if (ret < 0 && verbose >= 0) {
3021 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3022 av_close_input_file(ic);
3023 exit_program(1);
3024 }
3025
3026 timestamp = start_time;
3027 /* add the stream start time */
3028 if (ic->start_time != AV_NOPTS_VALUE)
3029 timestamp += ic->start_time;
3030
3031 /* if seeking requested, we execute it */
3032 if (start_time != 0) {
3033 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3034 if (ret < 0) {
3035 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3036 filename, (double)timestamp / AV_TIME_BASE);
3037 }
3038 /* reset seek info */
3039 start_time = 0;
3040 }
3041
3042 /* update the current parameters so that they match the one of the input stream */
88867844 3043 add_input_streams(ic);
6291d7e4
AK
3044
3045 /* dump the file content */
3046 if (verbose >= 0)
3047 av_dump_format(ic, nb_input_files, filename, 0);
3048
3049 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3050 input_files[nb_input_files - 1].ctx = ic;
3051 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3052 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3053
3054 frame_rate = (AVRational){0, 0};
3055 frame_pix_fmt = PIX_FMT_NONE;
3056 frame_height = 0;
3057 frame_width = 0;
3058 audio_sample_rate = 0;
3059 audio_channels = 0;
3060 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
09af7fb3 3061 av_dict_free(&ts_scale);
6291d7e4
AK
3062
3063 for (i = 0; i < orig_nb_streams; i++)
3064 av_dict_free(&opts[i]);
3065 av_freep(&opts);
92f1940e 3066 av_dict_free(&codec_names);
6291d7e4
AK
3067 uninit_opts();
3068 init_opts();
3069 return 0;
3070}
3071
f233cfed
AK
3072static void parse_forced_key_frames(char *kf, OutputStream *ost,
3073 AVCodecContext *avctx)
3074{
3075 char *p;
3076 int n = 1, i;
3077 int64_t t;
3078
3079 for (p = kf; *p; p++)
3080 if (*p == ',')
3081 n++;
3082 ost->forced_kf_count = n;
3083 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3084 if (!ost->forced_kf_pts) {
3085 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3086 exit_program(1);
3087 }
3088 for (i = 0; i < n; i++) {
3089 p = i ? strchr(p, ',') + 1 : kf;
3090 t = parse_time_or_die("force_key_frames", p, 1);
3091 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3092 }
3093}
3094
6cd9d0f7 3095static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
169f0647
AK
3096{
3097 OutputStream *ost;
3098 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3099 int idx = oc->nb_streams - 1;
3100
3101 if (!st) {
3102 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3103 exit_program(1);
3104 }
3105
4288e031
AK
3106 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3107 nb_output_streams + 1);
3108 ost = &output_streams[nb_output_streams - 1];
40fc2810 3109 ost->file_index = nb_output_files;
169f0647
AK
3110 ost->index = idx;
3111 ost->st = st;
3112 st->codec->codec_type = type;
3113 ost->enc = choose_codec(oc, st, type, codec_names);
3114 if (ost->enc) {
3115 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3116 }
3117
3118 avcodec_get_context_defaults3(st->codec, ost->enc);
3119 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3120
3121 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3122 return ost;
3123}
3124
6cd9d0f7 3125static OutputStream *new_video_stream(AVFormatContext *oc)
6291d7e4
AK
3126{
3127 AVStream *st;
3128 OutputStream *ost;
3129 AVCodecContext *video_enc;
6291d7e4 3130
6cd9d0f7 3131 ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
6291d7e4 3132 st = ost->st;
92f1940e 3133 if (!st->stream_copy) {
6291d7e4
AK
3134 ost->frame_aspect_ratio = frame_aspect_ratio;
3135 frame_aspect_ratio = 0;
3136#if CONFIG_AVFILTER
3137 ost->avfilter= vfilters;
3138 vfilters = NULL;
3139#endif
3140 }
3141
3142 ost->bitstream_filters = video_bitstream_filters;
3143 video_bitstream_filters= NULL;
3144
3145 st->codec->thread_count= thread_count;
3146
3147 video_enc = st->codec;
3148
3149 if(video_codec_tag)
3150 video_enc->codec_tag= video_codec_tag;
3151
3152 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3153 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3154 }
3155
92f1940e 3156 if (st->stream_copy) {
6291d7e4
AK
3157 video_enc->sample_aspect_ratio =
3158 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3159 } else {
3160 const char *p;
3161 int i;
3162
3163 if (frame_rate.num)
3164 ost->frame_rate = frame_rate;
6291d7e4
AK
3165
3166 video_enc->width = frame_width;
3167 video_enc->height = frame_height;
3168 video_enc->pix_fmt = frame_pix_fmt;
3169 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3170
3171 if (intra_only)
3172 video_enc->gop_size = 0;
f4ad238c 3173 if (video_qscale || same_quant) {
6291d7e4
AK
3174 video_enc->flags |= CODEC_FLAG_QSCALE;
3175 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3176 }
3177
3178 if(intra_matrix)
3179 video_enc->intra_matrix = intra_matrix;
3180 if(inter_matrix)
3181 video_enc->inter_matrix = inter_matrix;
3182
3183 p= video_rc_override_string;
3184 for(i=0; p; i++){
3185 int start, end, q;
3186 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3187 if(e!=3){
3188 fprintf(stderr, "error parsing rc_override\n");
3189 exit_program(1);
3190 }
3191 video_enc->rc_override=
3192 av_realloc(video_enc->rc_override,
3193 sizeof(RcOverride)*(i+1));
3194 video_enc->rc_override[i].start_frame= start;
3195 video_enc->rc_override[i].end_frame = end;
3196 if(q>0){
3197 video_enc->rc_override[i].qscale= q;
3198 video_enc->rc_override[i].quality_factor= 1.0;
3199 }
3200 else{
3201 video_enc->rc_override[i].qscale= 0;
3202 video_enc->rc_override[i].quality_factor= -q/100.0;
3203 }
3204 p= strchr(p, '/');
3205 if(p) p++;
3206 }
3207 video_enc->rc_override_count=i;
3208 if (!video_enc->rc_initial_buffer_occupancy)
3209 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3210 video_enc->me_threshold= me_threshold;
3211 video_enc->intra_dc_precision= intra_dc_precision - 8;
3212
3213 if (do_psnr)
3214 video_enc->flags|= CODEC_FLAG_PSNR;
3215
3216 /* two pass mode */
3217 if (do_pass) {
3218 if (do_pass == 1) {
3219 video_enc->flags |= CODEC_FLAG_PASS1;
3220 } else {
3221 video_enc->flags |= CODEC_FLAG_PASS2;
3222 }
3223 }
3224
3225 if (forced_key_frames)
3226 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3227 }
3228 if (video_language) {
3229 av_dict_set(&st->metadata, "language", video_language, 0);
3230 av_freep(&video_language);
3231 }
3232
3233 /* reset some key parameters */
3234 video_disable = 0;
6291d7e4 3235 av_freep(&forced_key_frames);
6291d7e4 3236 frame_pix_fmt = PIX_FMT_NONE;
3d4f0dab 3237 return ost;
6291d7e4
AK
3238}
3239
6cd9d0f7 3240static OutputStream *new_audio_stream(AVFormatContext *oc)
6291d7e4
AK
3241{
3242 AVStream *st;
3243 OutputStream *ost;
6291d7e4 3244 AVCodecContext *audio_enc;
6291d7e4 3245
6cd9d0f7 3246 ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
6291d7e4
AK
3247 st = ost->st;
3248
3249 ost->bitstream_filters = audio_bitstream_filters;
3250 audio_bitstream_filters= NULL;
3251
3252 st->codec->thread_count= thread_count;
3253
3254 audio_enc = st->codec;
3255 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3256
3257 if(audio_codec_tag)
3258 audio_enc->codec_tag= audio_codec_tag;
3259
3260 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3261 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3262 }
92f1940e 3263 if (!st->stream_copy) {
6291d7e4
AK
3264 if (audio_qscale > QSCALE_NONE) {
3265 audio_enc->flags |= CODEC_FLAG_QSCALE;
3266 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3267 }
3268 if (audio_channels)
3269 audio_enc->channels = audio_channels;
3270 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3271 audio_enc->sample_fmt = audio_sample_fmt;
3272 if (audio_sample_rate)
3273 audio_enc->sample_rate = audio_sample_rate;
3274 }
3275 if (audio_language) {
3276 av_dict_set(&st->metadata, "language", audio_language, 0);
3277 av_freep(&audio_language);
3278 }
3279
3280 /* reset some key parameters */
3281 audio_disable = 0;
3d4f0dab
AK
3282
3283 return ost;
6291d7e4
AK
3284}
3285
6cd9d0f7 3286static OutputStream *new_data_stream(AVFormatContext *oc)
6291d7e4
AK
3287{
3288 AVStream *st;
3289 OutputStream *ost;
3290 AVCodecContext *data_enc;
3291
6cd9d0f7 3292 ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
6291d7e4
AK
3293 st = ost->st;
3294 data_enc = st->codec;
92f1940e 3295 if (!st->stream_copy) {
6291d7e4
AK
3296 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3297 exit_program(1);
3298 }
3299
6291d7e4
AK
3300 if (data_codec_tag)
3301 data_enc->codec_tag= data_codec_tag;
3302
3303 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3304 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3305 }
6291d7e4
AK
3306
3307 data_disable = 0;
3d4f0dab 3308 return ost;
6291d7e4
AK
3309}
3310
6cd9d0f7 3311static OutputStream *new_subtitle_stream(AVFormatContext *oc)
6291d7e4
AK
3312{
3313 AVStream *st;
3314 OutputStream *ost;
6291d7e4 3315 AVCodecContext *subtitle_enc;
6291d7e4 3316
6cd9d0f7 3317 ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
6291d7e4
AK
3318 st = ost->st;
3319 subtitle_enc = st->codec;
3320
3321 ost->bitstream_filters = subtitle_bitstream_filters;
3322 subtitle_bitstream_filters= NULL;
3323
3324 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3325
3326 if(subtitle_codec_tag)
3327 subtitle_enc->codec_tag= subtitle_codec_tag;
3328
3329 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3330 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3331 }
6291d7e4
AK
3332
3333 if (subtitle_language) {
3334 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3335 av_freep(&subtitle_language);
3336 }
3337
3338 subtitle_disable = 0;
3d4f0dab 3339 return ost;
6291d7e4
AK
3340}
3341
3342/* arg format is "output-stream-index:streamid-value". */
3343static int opt_streamid(const char *opt, const char *arg)
3344{
3345 int idx;
3346 char *p;
3347 char idx_str[16];
3348
3349 av_strlcpy(idx_str, arg, sizeof(idx_str));
3350 p = strchr(idx_str, ':');
3351 if (!p) {
3352 fprintf(stderr,
3353 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3354 arg, opt);
3355 exit_program(1);
3356 }
3357 *p++ = '\0';
3358 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3359 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3360 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3361 return 0;
3362}
3363
86530f41
AK
3364static int copy_chapters(int infile, int outfile)
3365{
3366 AVFormatContext *is = input_files[infile].ctx;
af70aa45 3367 AVFormatContext *os = output_files[outfile].ctx;
86530f41
AK
3368 int i;
3369
3370 for (i = 0; i < is->nb_chapters; i++) {
3371 AVChapter *in_ch = is->chapters[i], *out_ch;
3372 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
3373 AV_TIME_BASE_Q, in_ch->time_base);
3374 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
3375 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3376
3377
3378 if (in_ch->end < ts_off)
3379 continue;
3380 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3381 break;
3382
3383 out_ch = av_mallocz(sizeof(AVChapter));
3384 if (!out_ch)
3385 return AVERROR(ENOMEM);
3386
3387 out_ch->id = in_ch->id;
3388 out_ch->time_base = in_ch->time_base;
3389 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3390 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3391
3392 if (metadata_chapters_autocopy)
3393 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3394
3395 os->nb_chapters++;
3396 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3397 if (!os->chapters)
3398 return AVERROR(ENOMEM);
3399 os->chapters[os->nb_chapters - 1] = out_ch;
3400 }
3401 return 0;
3402}
3403
169f0647
AK
3404static int read_avserver_streams(AVFormatContext *s, const char *filename)
3405{
3406 int i, err;
3407 AVFormatContext *ic = NULL;
169f0647
AK
3408
3409 err = avformat_open_input(&ic, filename, NULL, NULL);
3410 if (err < 0)
3411 return err;
3412 /* copy stream format */
3413 for(i=0;i<ic->nb_streams;i++) {
3414 AVStream *st;
3415 OutputStream *ost;
3416 AVCodec *codec;
3417
3418 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
6cd9d0f7 3419 ost = new_output_stream(s, codec->type);
169f0647
AK
3420 st = ost->st;
3421
3422 // FIXME: a more elegant solution is needed
3423 memcpy(st, ic->streams[i], sizeof(AVStream));
3424 st->info = NULL;
3425 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3426
3427 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3428 choose_sample_fmt(st, codec);
3429 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3430 choose_pixel_fmt(st, codec);
169f0647
AK
3431 }
3432
3433 av_close_input_file(ic);
3434 return 0;
3435}
3436
6291d7e4
AK
3437static void opt_output_file(const char *filename)
3438{
3439 AVFormatContext *oc;
3d4f0dab 3440 int i, err;
6291d7e4 3441 AVOutputFormat *file_oformat;
3d4f0dab
AK
3442 OutputStream *ost;
3443 InputStream *ist;
6291d7e4
AK
3444
3445 if (!strcmp(filename, "-"))
3446 filename = "pipe:";
3447
3448 oc = avformat_alloc_context();
3449 if (!oc) {
3450 print_error(filename, AVERROR(ENOMEM));
3451 exit_program(1);
3452 }
3453
3454 if (last_asked_format) {
3455 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3456 if (!file_oformat) {
3457 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3458 exit_program(1);
3459 }
3460 last_asked_format = NULL;
3461 } else {
3462 file_oformat = av_guess_format(NULL, filename, NULL);
3463 if (!file_oformat) {
3464 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3465 filename);
3466 exit_program(1);
3467 }
3468 }
3469
3470 oc->oformat = file_oformat;
3471 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3472
3473 if (!strcmp(file_oformat->name, "ffm") &&
3474 av_strstart(filename, "http:", NULL)) {
3475 /* special case for files sent to avserver: we get the stream
3476 parameters from avserver */
3477 int err = read_avserver_streams(oc, filename);
3478 if (err < 0) {
3479 print_error(filename, err);
3480 exit_program(1);
3481 }
3d4f0dab
AK
3482 } else if (!nb_stream_maps) {
3483 /* pick the "best" stream of each type */
3484#define NEW_STREAM(type, index)\
3485 if (index >= 0) {\
6cd9d0f7 3486 ost = new_ ## type ## _stream(oc);\
3d4f0dab
AK
3487 ost->source_index = index;\
3488 ost->sync_ist = &input_streams[index];\
3489 input_streams[index].discard = 0;\
3490 }
3491
3492 /* video: highest resolution */
3493 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3494 int area = 0, idx = -1;
3495 for (i = 0; i < nb_input_streams; i++) {
3496 ist = &input_streams[i];
3497 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3498 ist->st->codec->width * ist->st->codec->height > area) {
3499 area = ist->st->codec->width * ist->st->codec->height;
3500 idx = i;
3501 }
3502 }
3503 NEW_STREAM(video, idx);
3504 }
3505
3506 /* audio: most channels */
3507 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3508 int channels = 0, idx = -1;
3509 for (i = 0; i < nb_input_streams; i++) {
3510 ist = &input_streams[i];
3511 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3512 ist->st->codec->channels > channels) {
3513 channels = ist->st->codec->channels;
3514 idx = i;
3515 }
3516 }
3517 NEW_STREAM(audio, idx);
3518 }
3519
3520 /* subtitles: pick first */
3521 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3522 for (i = 0; i < nb_input_streams; i++)
3523 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3524 NEW_STREAM(subtitle, i);
3525 break;
3526 }
3527 }
3528 /* do something with data? */
6291d7e4 3529 } else {
3d4f0dab
AK
3530 for (i = 0; i < nb_stream_maps; i++) {
3531 StreamMap *map = &stream_maps[i];
3d4f0dab 3532
8d2e4a7e
AK
3533 if (map->disabled)
3534 continue;
3d4f0dab 3535
6cd9d0f7 3536 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3d4f0dab 3537 switch (ist->st->codec->codec_type) {
6cd9d0f7
AK
3538 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(oc); break;
3539 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc); break;
3540 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3541 case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc); break;
3d4f0dab
AK
3542 default:
3543 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3544 map->file_index, map->stream_index);
3545 exit_program(1);
3546 }
3547
6cd9d0f7 3548 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3d4f0dab
AK
3549 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3550 map->sync_stream_index];
3551 ist->discard = 0;
3552 }
6291d7e4
AK
3553 }
3554
3d4f0dab
AK
3555 av_dict_copy(&oc->metadata, metadata, 0);
3556 av_dict_free(&metadata);
3557
af70aa45 3558
af70aa45
AK
3559 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3560 output_files[nb_output_files - 1].ctx = oc;
4288e031 3561 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
ef44a607 3562 output_files[nb_output_files - 1].recording_time = recording_time;
ea065176 3563 output_files[nb_output_files - 1].start_time = start_time;
af70aa45 3564 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
6291d7e4
AK
3565
3566 /* check filename in case of an image number is expected */
3567 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3568 if (!av_filename_number_test(oc->filename)) {
3569 print_error(oc->filename, AVERROR(EINVAL));
3570 exit_program(1);
3571 }
3572 }
3573
3574 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3575 /* test if it already exists to avoid loosing precious files */
3576 if (!file_overwrite &&
3577 (strchr(filename, ':') == NULL ||
3578 filename[1] == ':' ||
3579 av_strstart(filename, "file:", NULL))) {
3580 if (avio_check(filename, 0) == 0) {
3581 if (!using_stdin) {
3582 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3583 fflush(stderr);
3584 if (!read_yesno()) {
3585 fprintf(stderr, "Not overwriting - exiting\n");
3586 exit_program(1);
3587 }
3588 }
3589 else {
3590 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3591 exit_program(1);
3592 }
3593 }
3594 }
3595
3596 /* open the file */
3597 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3598 print_error(filename, err);
3599 exit_program(1);
3600 }
3601 }
3602
3603 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3604 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
6291d7e4
AK
3605 oc->flags |= AVFMT_FLAG_NONBLOCK;
3606
b9aac90b
AK
3607 /* copy chapters */
3608 if (chapters_input_file >= nb_input_files) {
3609 if (chapters_input_file == INT_MAX) {
3610 /* copy chapters from the first input file that has them*/
3611 chapters_input_file = -1;
3612 for (i = 0; i < nb_input_files; i++)
3613 if (input_files[i].ctx->nb_chapters) {
3614 chapters_input_file = i;
3615 break;
3616 }
3617 } else {
3618 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3619 chapters_input_file);
3620 exit_program(1);
3621 }
3622 }
3623 if (chapters_input_file >= 0)
3624 copy_chapters(chapters_input_file, nb_output_files - 1);
3625
e6e6060c
AK
3626 /* copy metadata */
3627 for (i = 0; i < nb_meta_data_maps; i++) {
3628 AVFormatContext *files[2];
3629 AVDictionary **meta[2];
3630 int j;
3631
3632#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3633 if ((index) < 0 || (index) >= (nb_elems)) {\
3634 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3635 (desc), (index));\
3636 exit_program(1);\
3637 }
3638
3639 int in_file_index = meta_data_maps[i][1].file;
3640 if (in_file_index < 0)
3641 continue;
3642 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3643
3644 files[0] = oc;
3645 files[1] = input_files[in_file_index].ctx;
3646
3647 for (j = 0; j < 2; j++) {
3648 MetadataMap *map = &meta_data_maps[i][j];
3649
3650 switch (map->type) {
3651 case 'g':
3652 meta[j] = &files[j]->metadata;
3653 break;
3654 case 's':
3655 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3656 meta[j] = &files[j]->streams[map->index]->metadata;
3657 break;
3658 case 'c':
3659 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3660 meta[j] = &files[j]->chapters[map->index]->metadata;
3661 break;
3662 case 'p':
3663 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3664 meta[j] = &files[j]->programs[map->index]->metadata;
3665 break;
3666 }
3667 }
3668
3669 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3670 }
3671
3672 /* copy global metadata by default */
5759cce7 3673 if (metadata_global_autocopy && nb_input_files)
e6e6060c
AK
3674 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3675 AV_DICT_DONT_OVERWRITE);
3676 if (metadata_streams_autocopy)
4288e031
AK
3677 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3678 InputStream *ist = &input_streams[output_streams[i].source_index];
3679 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
e6e6060c
AK
3680 }
3681
6291d7e4
AK
3682 frame_rate = (AVRational){0, 0};
3683 frame_width = 0;
3684 frame_height = 0;
3685 audio_sample_rate = 0;
3686 audio_channels = 0;
3687 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
b9aac90b 3688 chapters_input_file = INT_MAX;
ef44a607 3689 recording_time = INT64_MAX;
ea065176 3690 start_time = 0;
6291d7e4 3691
e6e6060c
AK
3692 av_freep(&meta_data_maps);
3693 nb_meta_data_maps = 0;
3694 metadata_global_autocopy = 1;
3695 metadata_streams_autocopy = 1;
3696 metadata_chapters_autocopy = 1;
3d4f0dab
AK
3697 av_freep(&stream_maps);
3698 nb_stream_maps = 0;
e6e6060c 3699
92f1940e
AK
3700 av_dict_free(&codec_names);
3701
6291d7e4
AK
3702 av_freep(&forced_key_frames);
3703 uninit_opts();
3704 init_opts();
3705}
3706
3707/* same option as mencoder */
3708static int opt_pass(const char *opt, const char *arg)
3709{
3710 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3711 return 0;
3712}
3713
3714static int64_t getutime(void)
3715{
3716#if HAVE_GETRUSAGE
3717 struct rusage rusage;
3718
3719 getrusage(RUSAGE_SELF, &rusage);
3720 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3721#elif HAVE_GETPROCESSTIMES
3722 HANDLE proc;
3723 FILETIME c, e, k, u;
3724 proc = GetCurrentProcess();
3725 GetProcessTimes(proc, &c, &e, &k, &u);
3726 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3727#else
3728 return av_gettime();
3729#endif
3730}
3731
3732static int64_t getmaxrss(void)
3733{
3734#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3735 struct rusage rusage;
3736 getrusage(RUSAGE_SELF, &rusage);
3737 return (int64_t)rusage.ru_maxrss * 1024;
3738#elif HAVE_GETPROCESSMEMORYINFO
3739 HANDLE proc;
3740 PROCESS_MEMORY_COUNTERS memcounters;
3741 proc = GetCurrentProcess();
3742 memcounters.cb = sizeof(memcounters);
3743 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3744 return memcounters.PeakPagefileUsage;
3745#else
3746 return 0;
3747#endif
3748}
3749
3750static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3751{
3752 int i;
3753 const char *p = str;
3754 for(i = 0;; i++) {
3755 dest[i] = atoi(p);
3756 if(i == 63)
3757 break;
3758 p = strchr(p, ',');
3759 if(!p) {
3760 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3761 exit_program(1);
3762 }
3763 p++;
3764 }
3765}
3766
3767static void opt_inter_matrix(const char *arg)
3768{
3769 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3770 parse_matrix_coeffs(inter_matrix, arg);
3771}
3772
3773static void opt_intra_matrix(const char *arg)
3774{
3775 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3776 parse_matrix_coeffs(intra_matrix, arg);
3777}
3778
3779static void show_usage(void)
3780{
3781 printf("Hyper fast Audio and Video encoder\n");
3782 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3783 printf("\n");
3784}
3785
3786static void show_help(void)
3787{
3788 AVCodec *c;
3789 AVOutputFormat *oformat = NULL;
3790 AVInputFormat *iformat = NULL;
3791
3792 av_log_set_callback(log_callback_help);
3793 show_usage();
3794 show_help_options(options, "Main options:\n",
3795 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3796 show_help_options(options, "\nAdvanced options:\n",
3797 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3798 OPT_EXPERT);
3799 show_help_options(options, "\nVideo options:\n",
3800 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3801 OPT_VIDEO);
3802 show_help_options(options, "\nAdvanced Video options:\n",
3803 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3804 OPT_VIDEO | OPT_EXPERT);
3805 show_help_options(options, "\nAudio options:\n",
3806 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3807 OPT_AUDIO);
3808 show_help_options(options, "\nAdvanced Audio options:\n",
3809 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3810 OPT_AUDIO | OPT_EXPERT);
3811 show_help_options(options, "\nSubtitle options:\n",
3812 OPT_SUBTITLE | OPT_GRAB,
3813 OPT_SUBTITLE);
3814 show_help_options(options, "\nAudio/Video grab options:\n",
3815 OPT_GRAB,
3816 OPT_GRAB);
3817 printf("\n");
3818 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3819 printf("\n");
3820
3821 /* individual codec options */
3822 c = NULL;
3823 while ((c = av_codec_next(c))) {
3824 if (c->priv_class) {
3825 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3826 printf("\n");
3827 }
3828 }
3829
3830 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3831 printf("\n");
3832
3833 /* individual muxer options */
3834 while ((oformat = av_oformat_next(oformat))) {
3835 if (oformat->priv_class) {
3836 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3837 printf("\n");
3838 }
3839 }
3840
3841 /* individual demuxer options */
3842 while ((iformat = av_iformat_next(iformat))) {
3843 if (iformat->priv_class) {
3844 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3845 printf("\n");
3846 }
3847 }
3848
3849 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3850}
3851
3852static int opt_target(const char *opt, const char *arg)
3853{
3854 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3855 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3856
3857 if(!strncmp(arg, "pal-", 4)) {
3858 norm = PAL;
3859 arg += 4;
3860 } else if(!strncmp(arg, "ntsc-", 5)) {
3861 norm = NTSC;
3862 arg += 5;
3863 } else if(!strncmp(arg, "film-", 5)) {
3864 norm = FILM;
3865 arg += 5;
3866 } else {
3867 int fr;
3868 /* Calculate FR via float to avoid int overflow */
3869 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3870 if(fr == 25000) {
3871 norm = PAL;
3872 } else if((fr == 29970) || (fr == 23976)) {
3873 norm = NTSC;
3874 } else {
3875 /* Try to determine PAL/NTSC by peeking in the input files */
3876 if(nb_input_files) {
3877 int i, j;
3878 for (j = 0; j < nb_input_files; j++) {
3879 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
3880 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3881 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3882 continue;
3883 fr = c->time_base.den * 1000 / c->time_base.num;
3884 if(fr == 25000) {
3885 norm = PAL;
3886 break;
3887 } else if((fr == 29970) || (fr == 23976)) {
3888 norm = NTSC;
3889 break;
3890 }
3891 }
3892 if(norm != UNKNOWN)
3893 break;
3894 }
3895 }
3896 }
3897 if(verbose > 0 && norm != UNKNOWN)
3898 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3899 }
3900
3901 if(norm == UNKNOWN) {
3902 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3903 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3904 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3905 exit_program(1);
3906 }
3907
3908 if(!strcmp(arg, "vcd")) {
92f1940e
AK
3909 opt_codec("c:v", "mpeg1video");
3910 opt_codec("c:a", "mp2");
6291d7e4
AK
3911 opt_format("f", "vcd");
3912
3913 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3914 opt_frame_rate("r", frame_rates[norm]);
3915 opt_default("g", norm == PAL ? "15" : "18");
3916
3917 opt_default("b", "1150000");
3918 opt_default("maxrate", "1150000");
3919 opt_default("minrate", "1150000");
3920 opt_default("bufsize", "327680"); // 40*1024*8;
3921
64db1a82 3922 opt_default("b:a", "224000");
6291d7e4
AK
3923 audio_sample_rate = 44100;
3924 audio_channels = 2;
3925
3926 opt_default("packetsize", "2324");
3927 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3928
3929 /* We have to offset the PTS, so that it is consistent with the SCR.
3930 SCR starts at 36000, but the first two packs contain only padding
3931 and the first pack from the other stream, respectively, may also have
3932 been written before.
3933 So the real data starts at SCR 36000+3*1200. */
3934 mux_preload= (36000+3*1200) / 90000.0; //0.44
3935 } else if(!strcmp(arg, "svcd")) {
3936
92f1940e
AK
3937 opt_codec("c:v", "mpeg2video");
3938 opt_codec("c:a", "mp2");
6291d7e4
AK
3939 opt_format("f", "svcd");
3940
3941 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3942 opt_frame_rate("r", frame_rates[norm]);
3943 opt_default("g", norm == PAL ? "15" : "18");
3944
3945 opt_default("b", "2040000");
3946 opt_default("maxrate", "2516000");
3947 opt_default("minrate", "0"); //1145000;
3948 opt_default("bufsize", "1835008"); //224*1024*8;
3949 opt_default("flags", "+scan_offset");
3950
3951
64db1a82 3952 opt_default("b:a", "224000");
6291d7e4
AK
3953 audio_sample_rate = 44100;
3954
3955 opt_default("packetsize", "2324");
3956
3957 } else if(!strcmp(arg, "dvd")) {
3958
92f1940e
AK
3959 opt_codec("c:v", "mpeg2video");
3960 opt_codec("c:a", "ac3");
6291d7e4
AK
3961 opt_format("f", "dvd");
3962
3963 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3964 opt_frame_rate("r", frame_rates[norm]);
3965 opt_default("g", norm == PAL ? "15" : "18");
3966
3967 opt_default("b", "6000000");
3968 opt_default("maxrate", "9000000");
3969 opt_default("minrate", "0"); //1500000;
3970 opt_default("bufsize", "1835008"); //224*1024*8;
3971
3972 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3973 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3974
64db1a82 3975 opt_default("b:a", "448000");
6291d7e4
AK
3976 audio_sample_rate = 48000;
3977
3978 } else if(!strncmp(arg, "dv", 2)) {
3979
3980 opt_format("f", "dv");
3981
3982 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
3983 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3984 norm == PAL ? "yuv420p" : "yuv411p");
3985 opt_frame_rate("r", frame_rates[norm]);
3986
3987 audio_sample_rate = 48000;
3988 audio_channels = 2;
3989
3990 } else {
3991 fprintf(stderr, "Unknown target: %s\n", arg);
3992 return AVERROR(EINVAL);
3993 }
3994 return 0;
3995}
3996
3997static int opt_vstats_file(const char *opt, const char *arg)
3998{
3999 av_free (vstats_filename);
4000 vstats_filename=av_strdup (arg);
4001 return 0;
4002}
4003
4004static int opt_vstats(const char *opt, const char *arg)