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