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