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