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