VirtualBox

source: vbox/trunk/src/libs/ffmpeg-20060710/ffmpeg.c@ 11532

Last change on this file since 11532 was 5776, checked in by vboxsync, 17 years ago

ffmpeg: exported to OSE
File size: 147.5 KB
Line 
1/*
2 * FFmpeg main
3 * Copyright (c) 2000-2003 Fabrice Bellard
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19#define HAVE_AV_CONFIG_H
20#include <limits.h>
21#include "avformat.h"
22#include "framehook.h"
23#include "dsputil.h"
24#include "opt.h"
25
26#ifndef CONFIG_WIN32
27#include <unistd.h>
28#include <fcntl.h>
29#include <sys/ioctl.h>
30#include <sys/time.h>
31#include <termios.h>
32#include <sys/resource.h>
33#include <signal.h>
34#endif
35#ifdef CONFIG_OS2
36#include <sys/types.h>
37#include <sys/select.h>
38#include <stdlib.h>
39#endif
40#undef time //needed because HAVE_AV_CONFIG_H is defined on top
41#include <time.h>
42
43#include "version.h"
44#include "cmdutils.h"
45
46#undef NDEBUG
47#include <assert.h>
48
49#if !defined(INFINITY) && defined(HUGE_VAL)
50#define INFINITY HUGE_VAL
51#endif
52
53/* select an input stream for an output stream */
54typedef struct AVStreamMap {
55 int file_index;
56 int stream_index;
57 int sync_file_index;
58 int sync_stream_index;
59} AVStreamMap;
60
61/** select an input file for an output file */
62typedef struct AVMetaDataMap {
63 int out_file;
64 int in_file;
65} AVMetaDataMap;
66
67extern const OptionDef options[];
68
69static void show_help(void);
70static void show_license(void);
71static int opt_default(const char *opt, const char *arg);
72
73#define MAX_FILES 20
74
75static AVFormatContext *input_files[MAX_FILES];
76static int64_t input_files_ts_offset[MAX_FILES];
77static int nb_input_files = 0;
78
79static AVFormatContext *output_files[MAX_FILES];
80static int nb_output_files = 0;
81
82static AVStreamMap stream_maps[MAX_FILES];
83static int nb_stream_maps;
84
85static AVMetaDataMap meta_data_maps[MAX_FILES];
86static int nb_meta_data_maps;
87
88static AVInputFormat *file_iformat;
89static AVOutputFormat *file_oformat;
90static AVImageFormat *image_format;
91static int frame_width = 0;
92static int frame_height = 0;
93static float frame_aspect_ratio = 0;
94static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
95static int frame_padtop = 0;
96static int frame_padbottom = 0;
97static int frame_padleft = 0;
98static int frame_padright = 0;
99static int padcolor[3] = {16,128,128}; /* default to black */
100static int frame_topBand = 0;
101static int frame_bottomBand = 0;
102static int frame_leftBand = 0;
103static int frame_rightBand = 0;
104static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
105static int frame_rate = 25;
106static int frame_rate_base = 1;
107static int video_bit_rate = 200*1000;
108static int video_bit_rate_tolerance = 4000*1000;
109static float video_qscale = 0;
110static int video_qmin = 2;
111static int video_qmax = 31;
112static int video_lmin = 2*FF_QP2LAMBDA;
113static int video_lmax = 31*FF_QP2LAMBDA;
114static int video_mb_lmin = 2*FF_QP2LAMBDA;
115static int video_mb_lmax = 31*FF_QP2LAMBDA;
116static int video_qdiff = 3;
117static float video_qblur = 0.5;
118static float video_qsquish = 0.0;
119static float video_qcomp = 0.5;
120static uint16_t *intra_matrix = NULL;
121static uint16_t *inter_matrix = NULL;
122#if 0 //experimental, (can be removed)
123static float video_rc_qsquish=1.0;
124static float video_rc_qmod_amp=0;
125static int video_rc_qmod_freq=0;
126#endif
127static char *video_rc_override_string=NULL;
128static char *video_rc_eq="tex^qComp";
129static int video_rc_buffer_size=0;
130static float video_rc_buffer_aggressivity=1.0;
131static int video_rc_max_rate=0;
132static int video_rc_min_rate=0;
133static float video_rc_initial_cplx=0;
134static float video_b_qfactor = 1.25;
135static float video_b_qoffset = 1.25;
136static float video_i_qfactor = -0.8;
137static float video_i_qoffset = 0.0;
138static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
139static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
140static int me_method = ME_EPZS;
141static int video_disable = 0;
142static int video_discard = 0;
143static int video_codec_id = CODEC_ID_NONE;
144static int video_codec_tag = 0;
145static int same_quality = 0;
146static int b_frames = 0;
147static int pre_me = 0;
148static int do_deinterlace = 0;
149static int workaround_bugs = FF_BUG_AUTODETECT;
150static int packet_size = 0;
151static int error_rate = 0;
152static int strict = 0;
153static int top_field_first = -1;
154static int sc_threshold = 0;
155static int me_threshold = 0;
156static int mb_threshold = 0;
157static int intra_dc_precision = 8;
158static int me_penalty_compensation= 256;
159static int frame_skip_threshold= 0;
160static int frame_skip_factor= 0;
161static int frame_skip_exp= 0;
162extern int loop_input; /* currently a hack */
163static int loop_output = AVFMT_NOOUTPUTLOOP;
164static int genpts = 0;
165static int qp_hist = 0;
166
167static int gop_size = 12;
168static int intra_only = 0;
169static int audio_sample_rate = 44100;
170static int audio_bit_rate = 64000;
171#define QSCALE_NONE -99999
172static float audio_qscale = QSCALE_NONE;
173static int audio_disable = 0;
174static int audio_channels = 1;
175static int audio_codec_id = CODEC_ID_NONE;
176static int audio_codec_tag = 0;
177static char *audio_language = NULL;
178
179static int subtitle_codec_id = CODEC_ID_NONE;
180static char *subtitle_language = NULL;
181
182static int mux_rate= 0;
183static int mux_packet_size= 0;
184static float mux_preload= 0.5;
185static float mux_max_delay= 0.7;
186
187static int64_t recording_time = 0;
188static int64_t start_time = 0;
189static int64_t rec_timestamp = 0;
190static int64_t input_ts_offset = 0;
191static int file_overwrite = 0;
192static char *str_title = NULL;
193static char *str_author = NULL;
194static char *str_copyright = NULL;
195static char *str_comment = NULL;
196static int do_benchmark = 0;
197static int do_hex_dump = 0;
198static int do_pkt_dump = 0;
199static int do_psnr = 0;
200static int do_vstats = 0;
201static int do_pass = 0;
202static char *pass_logfilename = NULL;
203static int audio_stream_copy = 0;
204static int video_stream_copy = 0;
205static int subtitle_stream_copy = 0;
206static int video_sync_method= 1;
207static int audio_sync_method= 0;
208static int copy_ts= 0;
209static int opt_shortest = 0; //
210static int video_global_header = 0;
211
212static int rate_emu = 0;
213
214#ifdef CONFIG_BKTR
215static const char *video_grab_format = "bktr";
216#else
217#ifdef CONFIG_VIDEO4LINUX2
218static const char *video_grab_format = "video4linux2";
219#else
220static const char *video_grab_format = "video4linux";
221#endif
222#endif
223static char *video_device = NULL;
224static char *grab_device = NULL;
225static int video_channel = 0;
226static char *video_standard = "ntsc";
227
228static const char *audio_grab_format = "audio_device";
229static char *audio_device = NULL;
230static int audio_volume = 256;
231
232static int using_stdin = 0;
233static int using_vhook = 0;
234static int verbose = 1;
235static int thread_count= 1;
236static int q_pressed = 0;
237static int me_range = 0;
238static int64_t video_size = 0;
239static int64_t audio_size = 0;
240static int64_t extra_size = 0;
241static int nb_frames_dup = 0;
242static int nb_frames_drop = 0;
243static int input_sync;
244static int limit_filesize = 0; //
245
246static int pgmyuv_compatibility_hack=0;
247static int dts_delta_threshold = 10;
248
249const char **opt_names=NULL;
250int opt_name_count=0;
251AVCodecContext *avctx_opts;
252
253static AVBitStreamFilterContext *video_bitstream_filters=NULL;
254static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
255static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
256
257#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
258
259struct AVInputStream;
260
261typedef struct AVOutputStream {
262 int file_index; /* file index */
263 int index; /* stream index in the output file */
264 int source_index; /* AVInputStream index */
265 AVStream *st; /* stream in the output file */
266 int encoding_needed; /* true if encoding needed for this stream */
267 int frame_number;
268 /* input pts and corresponding output pts
269 for A/V sync */
270 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
271 struct AVInputStream *sync_ist; /* input stream to sync against */
272 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
273 /* video only */
274 int video_resample;
275 AVFrame pict_tmp; /* temporary image for resampling */
276 ImgReSampleContext *img_resample_ctx; /* for image resampling */
277
278 int video_crop;
279 int topBand; /* cropping area sizes */
280 int leftBand;
281
282 int video_pad;
283 int padtop; /* padding area sizes */
284 int padbottom;
285 int padleft;
286 int padright;
287
288 /* audio only */
289 int audio_resample;
290 ReSampleContext *resample; /* for audio resampling */
291 FifoBuffer fifo; /* for compression: one audio fifo per codec */
292 FILE *logfile;
293} AVOutputStream;
294
295typedef struct AVInputStream {
296 int file_index;
297 int index;
298 AVStream *st;
299 int discard; /* true if stream data should be discarded */
300 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
301 int64_t sample_index; /* current sample */
302
303 int64_t start; /* time when read started */
304 unsigned long frame; /* current frame */
305 int64_t next_pts; /* synthetic pts for cases where pkt.pts
306 is not defined */
307 int64_t pts; /* current pts */
308 int is_start; /* is 1 at the start and after a discontinuity */
309} AVInputStream;
310
311typedef struct AVInputFile {
312 int eof_reached; /* true if eof reached */
313 int ist_index; /* index of first stream in ist_table */
314 int buffer_size; /* current total buffer size */
315 int buffer_size_max; /* buffer size at which we consider we can stop
316 buffering */
317 int nb_streams; /* nb streams we are aware of */
318} AVInputFile;
319
320#ifndef CONFIG_WIN32
321
322/* init terminal so that we can grab keys */
323static struct termios oldtty;
324
325static void term_exit(void)
326{
327 tcsetattr (0, TCSANOW, &oldtty);
328}
329
330static volatile sig_atomic_t received_sigterm = 0;
331
332static void
333sigterm_handler(int sig)
334{
335 received_sigterm = sig;
336 term_exit();
337}
338
339static void term_init(void)
340{
341 struct termios tty;
342
343 tcgetattr (0, &tty);
344 oldtty = tty;
345
346 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
347 |INLCR|IGNCR|ICRNL|IXON);
348 tty.c_oflag |= OPOST;
349 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
350 tty.c_cflag &= ~(CSIZE|PARENB);
351 tty.c_cflag |= CS8;
352 tty.c_cc[VMIN] = 1;
353 tty.c_cc[VTIME] = 0;
354
355 tcsetattr (0, TCSANOW, &tty);
356
357 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
358 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
359 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
360 /*
361 register a function to be called at normal program termination
362 */
363 atexit(term_exit);
364#ifdef CONFIG_BEOS_NETSERVER
365 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
366#endif
367}
368
369/* read a key without blocking */
370static int read_key(void)
371{
372 int n = 1;
373 unsigned char ch;
374#ifndef CONFIG_BEOS_NETSERVER
375 struct timeval tv;
376 fd_set rfds;
377
378 FD_ZERO(&rfds);
379 FD_SET(0, &rfds);
380 tv.tv_sec = 0;
381 tv.tv_usec = 0;
382 n = select(1, &rfds, NULL, NULL, &tv);
383#endif
384 if (n > 0) {
385 n = read(0, &ch, 1);
386 if (n == 1)
387 return ch;
388
389 return n;
390 }
391 return -1;
392}
393
394static int decode_interrupt_cb(void)
395{
396 return q_pressed || (q_pressed = read_key() == 'q');
397}
398
399#else
400
401static volatile int received_sigterm = 0;
402
403/* no interactive support */
404static void term_exit(void)
405{
406}
407
408static void term_init(void)
409{
410}
411
412static int read_key(void)
413{
414 return 0;
415}
416
417#endif
418
419static int read_ffserver_streams(AVFormatContext *s, const char *filename)
420{
421 int i, err;
422 AVFormatContext *ic;
423
424 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
425 if (err < 0)
426 return err;
427 /* copy stream format */
428 s->nb_streams = ic->nb_streams;
429 for(i=0;i<ic->nb_streams;i++) {
430 AVStream *st;
431
432 // FIXME: a more elegant solution is needed
433 st = av_mallocz(sizeof(AVStream));
434 memcpy(st, ic->streams[i], sizeof(AVStream));
435 st->codec = avcodec_alloc_context();
436 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
437 s->streams[i] = st;
438 }
439
440 av_close_input_file(ic);
441 return 0;
442}
443
444static double
445get_sync_ipts(const AVOutputStream *ost)
446{
447 const AVInputStream *ist = ost->sync_ist;
448 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
449}
450
451static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
452 while(bsfc){
453 AVPacket new_pkt= *pkt;
454 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
455 &new_pkt.data, &new_pkt.size,
456 pkt->data, pkt->size,
457 pkt->flags & PKT_FLAG_KEY);
458 if(a){
459 av_free_packet(pkt);
460 new_pkt.destruct= av_destruct_packet;
461 }
462 *pkt= new_pkt;
463
464 bsfc= bsfc->next;
465 }
466
467 av_interleaved_write_frame(s, pkt);
468}
469
470#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
471
472static void do_audio_out(AVFormatContext *s,
473 AVOutputStream *ost,
474 AVInputStream *ist,
475 unsigned char *buf, int size)
476{
477 uint8_t *buftmp;
478 static uint8_t *audio_buf = NULL;
479 static uint8_t *audio_out = NULL;
480 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
481
482 int size_out, frame_bytes, ret;
483 AVCodecContext *enc= ost->st->codec;
484
485 /* SC: dynamic allocation of buffers */
486 if (!audio_buf)
487 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
488 if (!audio_out)
489 audio_out = av_malloc(audio_out_size);
490 if (!audio_buf || !audio_out)
491 return; /* Should signal an error ! */
492
493 if(audio_sync_method){
494 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
495 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
496 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
497 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
498
499 //FIXME resample delay
500 if(fabs(delta) > 50){
501 if(ist->is_start){
502 if(byte_delta < 0){
503 byte_delta= FFMAX(byte_delta, -size);
504 size += byte_delta;
505 buf -= byte_delta;
506 if(verbose > 2)
507 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
508 if(!size)
509 return;
510 ist->is_start=0;
511 }else{
512 static uint8_t *input_tmp= NULL;
513 input_tmp= av_realloc(input_tmp, byte_delta + size);
514
515 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
516 ist->is_start=0;
517 else
518 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
519
520 memset(input_tmp, 0, byte_delta);
521 memcpy(input_tmp + byte_delta, buf, size);
522 buf= input_tmp;
523 size += byte_delta;
524 if(verbose > 2)
525 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
526 }
527 }else if(audio_sync_method>1){
528 int comp= clip(delta, -audio_sync_method, audio_sync_method);
529 assert(ost->audio_resample);
530 if(verbose > 2)
531 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
532// fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2));
533 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
534 }
535 }
536 }else
537 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
538 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
539
540 if (ost->audio_resample) {
541 buftmp = audio_buf;
542 size_out = audio_resample(ost->resample,
543 (short *)buftmp, (short *)buf,
544 size / (ist->st->codec->channels * 2));
545 size_out = size_out * enc->channels * 2;
546 } else {
547 buftmp = buf;
548 size_out = size;
549 }
550
551 /* now encode as many frames as possible */
552 if (enc->frame_size > 1) {
553 /* output resampled raw samples */
554 fifo_write(&ost->fifo, buftmp, size_out,
555 &ost->fifo.wptr);
556
557 frame_bytes = enc->frame_size * 2 * enc->channels;
558
559 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
560 &ost->fifo.rptr) == 0) {
561 AVPacket pkt;
562 av_init_packet(&pkt);
563
564 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
565 (short *)audio_buf);
566 audio_size += ret;
567 pkt.stream_index= ost->index;
568 pkt.data= audio_out;
569 pkt.size= ret;
570 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
571 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
572 pkt.flags |= PKT_FLAG_KEY;
573 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
574
575 ost->sync_opts += enc->frame_size;
576 }
577 } else {
578 AVPacket pkt;
579 av_init_packet(&pkt);
580
581 ost->sync_opts += size_out / (2 * enc->channels);
582
583 /* output a pcm frame */
584 /* XXX: change encoding codec API to avoid this ? */
585 switch(enc->codec->id) {
586 case CODEC_ID_PCM_S32LE:
587 case CODEC_ID_PCM_S32BE:
588 case CODEC_ID_PCM_U32LE:
589 case CODEC_ID_PCM_U32BE:
590 size_out = size_out << 1;
591 break;
592 case CODEC_ID_PCM_S24LE:
593 case CODEC_ID_PCM_S24BE:
594 case CODEC_ID_PCM_U24LE:
595 case CODEC_ID_PCM_U24BE:
596 case CODEC_ID_PCM_S24DAUD:
597 size_out = size_out / 2 * 3;
598 break;
599 case CODEC_ID_PCM_S16LE:
600 case CODEC_ID_PCM_S16BE:
601 case CODEC_ID_PCM_U16LE:
602 case CODEC_ID_PCM_U16BE:
603 break;
604 default:
605 size_out = size_out >> 1;
606 break;
607 }
608 ret = avcodec_encode_audio(enc, audio_out, size_out,
609 (short *)buftmp);
610 audio_size += ret;
611 pkt.stream_index= ost->index;
612 pkt.data= audio_out;
613 pkt.size= ret;
614 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
615 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
616 pkt.flags |= PKT_FLAG_KEY;
617 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
618 }
619}
620
621static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
622{
623 AVCodecContext *dec;
624 AVPicture *picture2;
625 AVPicture picture_tmp;
626 uint8_t *buf = 0;
627
628 dec = ist->st->codec;
629
630 /* deinterlace : must be done before any resize */
631 if (do_deinterlace || using_vhook) {
632 int size;
633
634 /* create temporary picture */
635 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
636 buf = av_malloc(size);
637 if (!buf)
638 return;
639
640 picture2 = &picture_tmp;
641 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
642
643 if (do_deinterlace){
644 if(avpicture_deinterlace(picture2, picture,
645 dec->pix_fmt, dec->width, dec->height) < 0) {
646 /* if error, do not deinterlace */
647 av_free(buf);
648 buf = NULL;
649 picture2 = picture;
650 }
651 } else {
652 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
653 }
654 } else {
655 picture2 = picture;
656 }
657
658 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
659
660 if (picture != picture2)
661 *picture = *picture2;
662 *bufp = buf;
663}
664
665/* we begin to correct av delay at this threshold */
666#define AV_DELAY_MAX 0.100
667
668static void do_subtitle_out(AVFormatContext *s,
669 AVOutputStream *ost,
670 AVInputStream *ist,
671 AVSubtitle *sub,
672 int64_t pts)
673{
674 static uint8_t *subtitle_out = NULL;
675 int subtitle_out_max_size = 65536;
676 int subtitle_out_size, nb, i;
677 AVCodecContext *enc;
678 AVPacket pkt;
679
680 if (pts == AV_NOPTS_VALUE) {
681 fprintf(stderr, "Subtitle packets must have a pts\n");
682 return;
683 }
684
685 enc = ost->st->codec;
686
687 if (!subtitle_out) {
688 subtitle_out = av_malloc(subtitle_out_max_size);
689 }
690
691 /* Note: DVB subtitle need one packet to draw them and one other
692 packet to clear them */
693 /* XXX: signal it in the codec context ? */
694 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
695 nb = 2;
696 else
697 nb = 1;
698
699 for(i = 0; i < nb; i++) {
700 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
701 subtitle_out_max_size, sub);
702
703 av_init_packet(&pkt);
704 pkt.stream_index = ost->index;
705 pkt.data = subtitle_out;
706 pkt.size = subtitle_out_size;
707 pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
708 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
709 /* XXX: the pts correction is handled here. Maybe handling
710 it in the codec would be better */
711 if (i == 0)
712 pkt.pts += 90 * sub->start_display_time;
713 else
714 pkt.pts += 90 * sub->end_display_time;
715 }
716 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
717 }
718}
719
720static int bit_buffer_size= 1024*256;
721static uint8_t *bit_buffer= NULL;
722
723static void do_video_out(AVFormatContext *s,
724 AVOutputStream *ost,
725 AVInputStream *ist,
726 AVFrame *in_picture,
727 int *frame_size)
728{
729 int nb_frames, i, ret;
730 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
731 AVFrame picture_format_temp, picture_crop_temp, picture_pad_temp;
732 uint8_t *buf = NULL, *buf1 = NULL;
733 AVCodecContext *enc, *dec;
734 enum PixelFormat target_pixfmt;
735
736 avcodec_get_frame_defaults(&picture_format_temp);
737 avcodec_get_frame_defaults(&picture_crop_temp);
738 avcodec_get_frame_defaults(&picture_pad_temp);
739
740 enc = ost->st->codec;
741 dec = ist->st->codec;
742
743 /* by default, we output a single frame */
744 nb_frames = 1;
745
746 *frame_size = 0;
747
748 if(video_sync_method){
749 double vdelta;
750 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
751 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
752 if (vdelta < -1.1)
753 nb_frames = 0;
754 else if (vdelta > 1.1)
755 nb_frames = lrintf(vdelta);
756//fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
757 if (nb_frames == 0){
758 ++nb_frames_drop;
759 if (verbose>2)
760 fprintf(stderr, "*** drop!\n");
761 }else if (nb_frames > 1) {
762 nb_frames_dup += nb_frames;
763 if (verbose>2)
764 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
765 }
766 }else
767 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
768
769 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
770 if (nb_frames <= 0)
771 return;
772
773 /* convert pixel format if needed */
774 target_pixfmt = ost->video_resample ? PIX_FMT_YUV420P : enc->pix_fmt;
775 if (dec->pix_fmt != target_pixfmt) {
776 int size;
777
778 /* create temporary picture */
779 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
780 buf = av_malloc(size);
781 if (!buf)
782 return;
783 formatted_picture = &picture_format_temp;
784 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
785
786 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
787 (AVPicture *)in_picture, dec->pix_fmt,
788 dec->width, dec->height) < 0) {
789
790 if (verbose >= 0)
791 fprintf(stderr, "pixel format conversion not handled\n");
792
793 goto the_end;
794 }
795 } else {
796 formatted_picture = in_picture;
797 }
798
799 if (ost->video_crop) {
800 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)formatted_picture, target_pixfmt, ost->topBand, ost->leftBand) < 0) {
801 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
802 goto the_end;
803 }
804 formatted_picture = &picture_crop_temp;
805 }
806
807 final_picture = formatted_picture;
808 padding_src = formatted_picture;
809 resampling_dst = &ost->pict_tmp;
810 if (ost->video_pad) {
811 final_picture = &ost->pict_tmp;
812 if (ost->video_resample) {
813 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, target_pixfmt, ost->padtop, ost->padleft) < 0) {
814 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
815 goto the_end;
816 }
817 resampling_dst = &picture_pad_temp;
818 }
819 }
820
821 /* XXX: resampling could be done before raw format conversion in
822 some cases to go faster */
823 /* XXX: only works for YUV420P */
824 if (ost->video_resample) {
825 padding_src = NULL;
826 final_picture = &ost->pict_tmp;
827 img_resample(ost->img_resample_ctx, (AVPicture *)resampling_dst, (AVPicture*)formatted_picture);
828 }
829
830 if (enc->pix_fmt != target_pixfmt) {
831 int size;
832
833 av_free(buf);
834 /* create temporary picture */
835 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
836 buf = av_malloc(size);
837 if (!buf)
838 return;
839 final_picture = &picture_format_temp;
840 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
841
842 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
843 (AVPicture*)&ost->pict_tmp, target_pixfmt,
844 enc->width, enc->height) < 0) {
845
846 if (verbose >= 0)
847 fprintf(stderr, "pixel format conversion not handled\n");
848
849 goto the_end;
850 }
851 }
852
853 if (ost->video_pad) {
854 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
855 enc->height, enc->width, enc->pix_fmt,
856 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
857 }
858
859 /* duplicates frame if needed */
860 for(i=0;i<nb_frames;i++) {
861 AVPacket pkt;
862 av_init_packet(&pkt);
863 pkt.stream_index= ost->index;
864
865 if (s->oformat->flags & AVFMT_RAWPICTURE) {
866 /* raw pictures are written as AVPicture structure to
867 avoid any copies. We support temorarily the older
868 method. */
869 AVFrame* old_frame = enc->coded_frame;
870 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
871 pkt.data= (uint8_t *)final_picture;
872 pkt.size= sizeof(AVPicture);
873 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
874 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
875 if(dec->coded_frame && dec->coded_frame->key_frame)
876 pkt.flags |= PKT_FLAG_KEY;
877
878 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
879 enc->coded_frame = old_frame;
880 } else {
881 AVFrame big_picture;
882
883 big_picture= *final_picture;
884 /* better than nothing: use input picture interlaced
885 settings */
886 big_picture.interlaced_frame = in_picture->interlaced_frame;
887 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
888 if(top_field_first == -1)
889 big_picture.top_field_first = in_picture->top_field_first;
890 else
891 big_picture.top_field_first = top_field_first;
892 }
893
894 /* handles sameq here. This is not correct because it may
895 not be a global option */
896 if (same_quality) {
897 big_picture.quality = ist->st->quality;
898 }else
899 big_picture.quality = ost->st->quality;
900 if(!me_threshold)
901 big_picture.pict_type = 0;
902// big_picture.pts = AV_NOPTS_VALUE;
903 big_picture.pts= ost->sync_opts;
904// big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
905//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
906 ret = avcodec_encode_video(enc,
907 bit_buffer, bit_buffer_size,
908 &big_picture);
909 //enc->frame_number = enc->real_pict_num;
910 if(ret>0){
911 pkt.data= bit_buffer;
912 pkt.size= ret;
913 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
914 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
915/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
916 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
917 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
918
919 if(enc->coded_frame && enc->coded_frame->key_frame)
920 pkt.flags |= PKT_FLAG_KEY;
921 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
922 *frame_size = ret;
923 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
924 // enc->frame_number-1, enc->real_pict_num, ret,
925 // enc->pict_type);
926 /* if two pass, output log */
927 if (ost->logfile && enc->stats_out) {
928 fprintf(ost->logfile, "%s", enc->stats_out);
929 }
930 }
931 }
932 ost->sync_opts++;
933 ost->frame_number++;
934 }
935 the_end:
936 av_free(buf);
937 av_free(buf1);
938}
939
940static double psnr(double d){
941 if(d==0) return INFINITY;
942 return -10.0*log(d)/log(10.0);
943}
944
945static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
946 int frame_size)
947{
948 static FILE *fvstats=NULL;
949 char filename[40];
950 time_t today2;
951 struct tm *today;
952 AVCodecContext *enc;
953 int frame_number;
954 int64_t ti;
955 double ti1, bitrate, avg_bitrate;
956
957 if (!fvstats) {
958 today2 = time(NULL);
959 today = localtime(&today2);
960 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
961 today->tm_min,
962 today->tm_sec);
963 fvstats = fopen(filename,"w");
964 if (!fvstats) {
965 perror("fopen");
966 exit(1);
967 }
968 }
969
970 ti = MAXINT64;
971 enc = ost->st->codec;
972 if (enc->codec_type == CODEC_TYPE_VIDEO) {
973 frame_number = ost->frame_number;
974 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
975 if (enc->flags&CODEC_FLAG_PSNR)
976 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
977
978 fprintf(fvstats,"f_size= %6d ", frame_size);
979 /* compute pts value */
980 ti1 = ost->sync_opts * av_q2d(enc->time_base);
981 if (ti1 < 0.01)
982 ti1 = 0.01;
983
984 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
985 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
986 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
987 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
988 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
989 }
990}
991
992static void print_report(AVFormatContext **output_files,
993 AVOutputStream **ost_table, int nb_ostreams,
994 int is_last_report)
995{
996 char buf[1024];
997 AVOutputStream *ost;
998 AVFormatContext *oc, *os;
999 int64_t total_size;
1000 AVCodecContext *enc;
1001 int frame_number, vid, i;
1002 double bitrate, ti1, pts;
1003 static int64_t last_time = -1;
1004 static int qp_histogram[52];
1005
1006 if (!is_last_report) {
1007 int64_t cur_time;
1008 /* display the report every 0.5 seconds */
1009 cur_time = av_gettime();
1010 if (last_time == -1) {
1011 last_time = cur_time;
1012 return;
1013 }
1014 if ((cur_time - last_time) < 500000)
1015 return;
1016 last_time = cur_time;
1017 }
1018
1019
1020 oc = output_files[0];
1021
1022 total_size = url_ftell(&oc->pb);
1023
1024 buf[0] = '\0';
1025 ti1 = 1e10;
1026 vid = 0;
1027 for(i=0;i<nb_ostreams;i++) {
1028 ost = ost_table[i];
1029 os = output_files[ost->file_index];
1030 enc = ost->st->codec;
1031 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1032 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1033 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1034 }
1035 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1036 frame_number = ost->frame_number;
1037 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
1038 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1039 if(is_last_report)
1040 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1041 if(qp_hist && enc->coded_frame){
1042 int j;
1043 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1044 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1045 qp_histogram[qp]++;
1046 for(j=0; j<32; j++)
1047 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1048 }
1049 if (enc->flags&CODEC_FLAG_PSNR){
1050 int j;
1051 double error, error_sum=0;
1052 double scale, scale_sum=0;
1053 char type[3]= {'Y','U','V'};
1054 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1055 for(j=0; j<3; j++){
1056 if(is_last_report){
1057 error= enc->error[j];
1058 scale= enc->width*enc->height*255.0*255.0*frame_number;
1059 }else{
1060 error= enc->coded_frame->error[j];
1061 scale= enc->width*enc->height*255.0*255.0;
1062 }
1063 if(j) scale/=4;
1064 error_sum += error;
1065 scale_sum += scale;
1066 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1067 }
1068 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1069 }
1070 vid = 1;
1071 }
1072 /* compute min output value */
1073 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1074 if ((pts < ti1) && (pts > 0))
1075 ti1 = pts;
1076 }
1077 if (ti1 < 0.01)
1078 ti1 = 0.01;
1079
1080 if (verbose || is_last_report) {
1081 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1082
1083 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1084 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1085 (double)total_size / 1024, ti1, bitrate);
1086
1087 if (verbose > 1)
1088 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1089 nb_frames_dup, nb_frames_drop);
1090
1091 if (verbose >= 0)
1092 fprintf(stderr, "%s \r", buf);
1093
1094 fflush(stderr);
1095 }
1096
1097 if (is_last_report && verbose >= 0){
1098 int64_t raw= audio_size + video_size + extra_size;
1099 fprintf(stderr, "\n");
1100 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1101 video_size/1024.0,
1102 audio_size/1024.0,
1103 extra_size/1024.0,
1104 100.0*(total_size - raw)/raw
1105 );
1106 }
1107}
1108
1109/* pkt = NULL means EOF (needed to flush decoder buffers) */
1110static int output_packet(AVInputStream *ist, int ist_index,
1111 AVOutputStream **ost_table, int nb_ostreams,
1112 const AVPacket *pkt)
1113{
1114 AVFormatContext *os;
1115 AVOutputStream *ost;
1116 uint8_t *ptr;
1117 int len, ret, i;
1118 uint8_t *data_buf;
1119 int data_size, got_picture;
1120 AVFrame picture;
1121 void *buffer_to_free;
1122 static unsigned int samples_size= 0;
1123 static short *samples= NULL;
1124 AVSubtitle subtitle, *subtitle_to_free;
1125 int got_subtitle;
1126
1127 if(!pkt){
1128 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1129 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1130 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1131 } else {
1132// assert(ist->pts == ist->next_pts);
1133 }
1134
1135 if (pkt == NULL) {
1136 /* EOF handling */
1137 ptr = NULL;
1138 len = 0;
1139 goto handle_eof;
1140 }
1141
1142 len = pkt->size;
1143 ptr = pkt->data;
1144 while (len > 0) {
1145 handle_eof:
1146 /* decode the packet if needed */
1147 data_buf = NULL; /* fail safe */
1148 data_size = 0;
1149 subtitle_to_free = NULL;
1150 if (ist->decoding_needed) {
1151 switch(ist->st->codec->codec_type) {
1152 case CODEC_TYPE_AUDIO:{
1153 if(pkt)
1154 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1155 /* XXX: could avoid copy if PCM 16 bits with same
1156 endianness as CPU */
1157 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1158 ptr, len);
1159 if (ret < 0)
1160 goto fail_decode;
1161 ptr += ret;
1162 len -= ret;
1163 /* Some bug in mpeg audio decoder gives */
1164 /* data_size < 0, it seems they are overflows */
1165 if (data_size <= 0) {
1166 /* no audio frame */
1167 continue;
1168 }
1169 data_buf = (uint8_t *)samples;
1170 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1171 (ist->st->codec->sample_rate * ist->st->codec->channels);
1172 break;}
1173 case CODEC_TYPE_VIDEO:
1174 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1175 /* XXX: allocate picture correctly */
1176 avcodec_get_frame_defaults(&picture);
1177
1178 ret = avcodec_decode_video(ist->st->codec,
1179 &picture, &got_picture, ptr, len);
1180 ist->st->quality= picture.quality;
1181 if (ret < 0)
1182 goto fail_decode;
1183 if (!got_picture) {
1184 /* no picture yet */
1185 goto discard_packet;
1186 }
1187 if (ist->st->codec->time_base.num != 0) {
1188 ist->next_pts += ((int64_t)AV_TIME_BASE *
1189 ist->st->codec->time_base.num) /
1190 ist->st->codec->time_base.den;
1191 }
1192 len = 0;
1193 break;
1194 case CODEC_TYPE_SUBTITLE:
1195 ret = avcodec_decode_subtitle(ist->st->codec,
1196 &subtitle, &got_subtitle, ptr, len);
1197 if (ret < 0)
1198 goto fail_decode;
1199 if (!got_subtitle) {
1200 goto discard_packet;
1201 }
1202 subtitle_to_free = &subtitle;
1203 len = 0;
1204 break;
1205 default:
1206 goto fail_decode;
1207 }
1208 } else {
1209 switch(ist->st->codec->codec_type) {
1210 case CODEC_TYPE_AUDIO:
1211 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1212 (ist->st->codec->sample_rate * ist->st->codec->channels);
1213 break;
1214 case CODEC_TYPE_VIDEO:
1215 if (ist->st->codec->time_base.num != 0) {
1216 ist->next_pts += ((int64_t)AV_TIME_BASE *
1217 ist->st->codec->time_base.num) /
1218 ist->st->codec->time_base.den;
1219 }
1220 break;
1221 }
1222 data_buf = ptr;
1223 data_size = len;
1224 ret = len;
1225 len = 0;
1226 }
1227
1228 buffer_to_free = NULL;
1229 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1230 pre_process_video_frame(ist, (AVPicture *)&picture,
1231 &buffer_to_free);
1232 }
1233
1234 // preprocess audio (volume)
1235 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1236 if (audio_volume != 256) {
1237 short *volp;
1238 volp = samples;
1239 for(i=0;i<(data_size / sizeof(short));i++) {
1240 int v = ((*volp) * audio_volume + 128) >> 8;
1241 if (v < -32768) v = -32768;
1242 if (v > 32767) v = 32767;
1243 *volp++ = v;
1244 }
1245 }
1246 }
1247
1248 /* frame rate emulation */
1249 if (ist->st->codec->rate_emu) {
1250 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1251 int64_t now = av_gettime() - ist->start;
1252 if (pts > now)
1253 usleep(pts - now);
1254
1255 ist->frame++;
1256 }
1257
1258#if 0
1259 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1260 is the one of the next displayed one */
1261 /* XXX: add mpeg4 too ? */
1262 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1263 if (ist->st->codec->pict_type != B_TYPE) {
1264 int64_t tmp;
1265 tmp = ist->last_ip_pts;
1266 ist->last_ip_pts = ist->frac_pts.val;
1267 ist->frac_pts.val = tmp;
1268 }
1269 }
1270#endif
1271 /* if output time reached then transcode raw format,
1272 encode packets and output them */
1273 if (start_time == 0 || ist->pts >= start_time)
1274 for(i=0;i<nb_ostreams;i++) {
1275 int frame_size;
1276
1277 ost = ost_table[i];
1278 if (ost->source_index == ist_index) {
1279 os = output_files[ost->file_index];
1280
1281#if 0
1282 printf("%d: got pts=%0.3f %0.3f\n", i,
1283 (double)pkt->pts / AV_TIME_BASE,
1284 ((double)ist->pts / AV_TIME_BASE) -
1285 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1286#endif
1287 /* set the input output pts pairs */
1288 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1289
1290 if (ost->encoding_needed) {
1291 switch(ost->st->codec->codec_type) {
1292 case CODEC_TYPE_AUDIO:
1293 do_audio_out(os, ost, ist, data_buf, data_size);
1294 break;
1295 case CODEC_TYPE_VIDEO:
1296 do_video_out(os, ost, ist, &picture, &frame_size);
1297 video_size += frame_size;
1298 if (do_vstats && frame_size)
1299 do_video_stats(os, ost, frame_size);
1300 break;
1301 case CODEC_TYPE_SUBTITLE:
1302 do_subtitle_out(os, ost, ist, &subtitle,
1303 pkt->pts);
1304 break;
1305 default:
1306 av_abort();
1307 }
1308 } else {
1309 AVFrame avframe; //FIXME/XXX remove this
1310 AVPacket opkt;
1311 av_init_packet(&opkt);
1312
1313 /* no reencoding needed : output the packet directly */
1314 /* force the input stream PTS */
1315
1316 avcodec_get_frame_defaults(&avframe);
1317 ost->st->codec->coded_frame= &avframe;
1318 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1319
1320 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1321 audio_size += data_size;
1322 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1323 video_size += data_size;
1324 ost->sync_opts++;
1325 }
1326
1327 opkt.stream_index= ost->index;
1328 if(pkt->pts != AV_NOPTS_VALUE)
1329 opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1330 else
1331 opkt.pts= AV_NOPTS_VALUE;
1332
1333 {
1334 int64_t dts;
1335 if (pkt->dts == AV_NOPTS_VALUE)
1336 dts = ist->next_pts;
1337 else
1338 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1339 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1340 }
1341 opkt.flags= pkt->flags;
1342
1343 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1344 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1345 opkt.destruct= av_destruct_packet;
1346
1347 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1348 ost->st->codec->frame_number++;
1349 ost->frame_number++;
1350 av_free_packet(&opkt);
1351 }
1352 }
1353 }
1354 av_free(buffer_to_free);
1355 /* XXX: allocate the subtitles in the codec ? */
1356 if (subtitle_to_free) {
1357 if (subtitle_to_free->rects != NULL) {
1358 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1359 av_free(subtitle_to_free->rects[i].bitmap);
1360 av_free(subtitle_to_free->rects[i].rgba_palette);
1361 }
1362 av_freep(&subtitle_to_free->rects);
1363 }
1364 subtitle_to_free->num_rects = 0;
1365 subtitle_to_free = NULL;
1366 }
1367 }
1368 discard_packet:
1369 if (pkt == NULL) {
1370 /* EOF handling */
1371
1372 for(i=0;i<nb_ostreams;i++) {
1373 ost = ost_table[i];
1374 if (ost->source_index == ist_index) {
1375 AVCodecContext *enc= ost->st->codec;
1376 os = output_files[ost->file_index];
1377
1378 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1379 continue;
1380 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1381 continue;
1382
1383 if (ost->encoding_needed) {
1384 for(;;) {
1385 AVPacket pkt;
1386 int fifo_bytes;
1387 av_init_packet(&pkt);
1388 pkt.stream_index= ost->index;
1389
1390 switch(ost->st->codec->codec_type) {
1391 case CODEC_TYPE_AUDIO:
1392 fifo_bytes = fifo_size(&ost->fifo, NULL);
1393 ret = 0;
1394 /* encode any samples remaining in fifo */
1395 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1396 int fs_tmp = enc->frame_size;
1397 enc->frame_size = fifo_bytes / (2 * enc->channels);
1398 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1399 &ost->fifo.rptr) == 0) {
1400 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1401 }
1402 enc->frame_size = fs_tmp;
1403 }
1404 if(ret <= 0) {
1405 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1406 }
1407 audio_size += ret;
1408 pkt.flags |= PKT_FLAG_KEY;
1409 break;
1410 case CODEC_TYPE_VIDEO:
1411 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1412 video_size += ret;
1413 if(enc->coded_frame && enc->coded_frame->key_frame)
1414 pkt.flags |= PKT_FLAG_KEY;
1415 if (ost->logfile && enc->stats_out) {
1416 fprintf(ost->logfile, "%s", enc->stats_out);
1417 }
1418 break;
1419 default:
1420 ret=-1;
1421 }
1422
1423 if(ret<=0)
1424 break;
1425 pkt.data= bit_buffer;
1426 pkt.size= ret;
1427 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1428 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1429 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1430 }
1431 }
1432 }
1433 }
1434 }
1435
1436 return 0;
1437 fail_decode:
1438 return -1;
1439}
1440
1441
1442/*
1443 * The following code is the main loop of the file converter
1444 */
1445static int av_encode(AVFormatContext **output_files,
1446 int nb_output_files,
1447 AVFormatContext **input_files,
1448 int nb_input_files,
1449 AVStreamMap *stream_maps, int nb_stream_maps)
1450{
1451 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1452 AVFormatContext *is, *os;
1453 AVCodecContext *codec, *icodec;
1454 AVOutputStream *ost, **ost_table = NULL;
1455 AVInputStream *ist, **ist_table = NULL;
1456 AVInputFile *file_table;
1457 AVFormatContext *stream_no_data;
1458 int key;
1459
1460 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1461 if (!file_table)
1462 goto fail;
1463
1464 /* input stream init */
1465 j = 0;
1466 for(i=0;i<nb_input_files;i++) {
1467 is = input_files[i];
1468 file_table[i].ist_index = j;
1469 file_table[i].nb_streams = is->nb_streams;
1470 j += is->nb_streams;
1471 }
1472 nb_istreams = j;
1473
1474 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1475 if (!ist_table)
1476 goto fail;
1477
1478 for(i=0;i<nb_istreams;i++) {
1479 ist = av_mallocz(sizeof(AVInputStream));
1480 if (!ist)
1481 goto fail;
1482 ist_table[i] = ist;
1483 }
1484 j = 0;
1485 for(i=0;i<nb_input_files;i++) {
1486 is = input_files[i];
1487 for(k=0;k<is->nb_streams;k++) {
1488 ist = ist_table[j++];
1489 ist->st = is->streams[k];
1490 ist->file_index = i;
1491 ist->index = k;
1492 ist->discard = 1; /* the stream is discarded by default
1493 (changed later) */
1494
1495 if (ist->st->codec->rate_emu) {
1496 ist->start = av_gettime();
1497 ist->frame = 0;
1498 }
1499 }
1500 }
1501
1502 /* output stream init */
1503 nb_ostreams = 0;
1504 for(i=0;i<nb_output_files;i++) {
1505 os = output_files[i];
1506 nb_ostreams += os->nb_streams;
1507 }
1508 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1509 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1510 exit(1);
1511 }
1512
1513 /* Sanity check the mapping args -- do the input files & streams exist? */
1514 for(i=0;i<nb_stream_maps;i++) {
1515 int fi = stream_maps[i].file_index;
1516 int si = stream_maps[i].stream_index;
1517
1518 if (fi < 0 || fi > nb_input_files - 1 ||
1519 si < 0 || si > file_table[fi].nb_streams - 1) {
1520 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1521 exit(1);
1522 }
1523 fi = stream_maps[i].sync_file_index;
1524 si = stream_maps[i].sync_stream_index;
1525 if (fi < 0 || fi > nb_input_files - 1 ||
1526 si < 0 || si > file_table[fi].nb_streams - 1) {
1527 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1528 exit(1);
1529 }
1530 }
1531
1532 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1533 if (!ost_table)
1534 goto fail;
1535 for(i=0;i<nb_ostreams;i++) {
1536 ost = av_mallocz(sizeof(AVOutputStream));
1537 if (!ost)
1538 goto fail;
1539 ost_table[i] = ost;
1540 }
1541
1542 n = 0;
1543 for(k=0;k<nb_output_files;k++) {
1544 os = output_files[k];
1545 for(i=0;i<os->nb_streams;i++) {
1546 int found;
1547 ost = ost_table[n++];
1548 ost->file_index = k;
1549 ost->index = i;
1550 ost->st = os->streams[i];
1551 if (nb_stream_maps > 0) {
1552 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1553 stream_maps[n-1].stream_index;
1554
1555 /* Sanity check that the stream types match */
1556 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1557 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1558 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1559 ost->file_index, ost->index);
1560 exit(1);
1561 }
1562
1563 } else {
1564 /* get corresponding input stream index : we select the first one with the right type */
1565 found = 0;
1566 for(j=0;j<nb_istreams;j++) {
1567 ist = ist_table[j];
1568 if (ist->discard &&
1569 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1570 ost->source_index = j;
1571 found = 1;
1572 break;
1573 }
1574 }
1575
1576 if (!found) {
1577 /* try again and reuse existing stream */
1578 for(j=0;j<nb_istreams;j++) {
1579 ist = ist_table[j];
1580 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1581 ost->source_index = j;
1582 found = 1;
1583 }
1584 }
1585 if (!found) {
1586 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1587 ost->file_index, ost->index);
1588 exit(1);
1589 }
1590 }
1591 }
1592 ist = ist_table[ost->source_index];
1593 ist->discard = 0;
1594 ost->sync_ist = (nb_stream_maps > 0) ?
1595 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1596 stream_maps[n-1].sync_stream_index] : ist;
1597 }
1598 }
1599
1600 /* for each output stream, we compute the right encoding parameters */
1601 for(i=0;i<nb_ostreams;i++) {
1602 ost = ost_table[i];
1603 ist = ist_table[ost->source_index];
1604
1605 codec = ost->st->codec;
1606 icodec = ist->st->codec;
1607
1608 if (ost->st->stream_copy) {
1609 /* if stream_copy is selected, no need to decode or encode */
1610 codec->codec_id = icodec->codec_id;
1611 codec->codec_type = icodec->codec_type;
1612 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1613 codec->bit_rate = icodec->bit_rate;
1614 codec->extradata= icodec->extradata;
1615 codec->extradata_size= icodec->extradata_size;
1616 codec->time_base = icodec->time_base;
1617 switch(codec->codec_type) {
1618 case CODEC_TYPE_AUDIO:
1619 codec->sample_rate = icodec->sample_rate;
1620 codec->channels = icodec->channels;
1621 codec->frame_size = icodec->frame_size;
1622 codec->block_align= icodec->block_align;
1623 break;
1624 case CODEC_TYPE_VIDEO:
1625 codec->pix_fmt = icodec->pix_fmt;
1626 codec->width = icodec->width;
1627 codec->height = icodec->height;
1628 codec->has_b_frames = icodec->has_b_frames;
1629 break;
1630 case CODEC_TYPE_SUBTITLE:
1631 break;
1632 default:
1633 av_abort();
1634 }
1635 } else {
1636 switch(codec->codec_type) {
1637 case CODEC_TYPE_AUDIO:
1638 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1639 goto fail;
1640
1641 if (codec->channels == icodec->channels &&
1642 codec->sample_rate == icodec->sample_rate) {
1643 ost->audio_resample = 0;
1644 } else {
1645 if (codec->channels != icodec->channels &&
1646 (icodec->codec_id == CODEC_ID_AC3 ||
1647 icodec->codec_id == CODEC_ID_DTS)) {
1648 /* Special case for 5:1 AC3 and DTS input */
1649 /* and mono or stereo output */
1650 /* Request specific number of channels */
1651 icodec->channels = codec->channels;
1652 if (codec->sample_rate == icodec->sample_rate)
1653 ost->audio_resample = 0;
1654 else {
1655 ost->audio_resample = 1;
1656 }
1657 } else {
1658 ost->audio_resample = 1;
1659 }
1660 }
1661 if(audio_sync_method>1)
1662 ost->audio_resample = 1;
1663
1664 if(ost->audio_resample){
1665 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1666 codec->sample_rate, icodec->sample_rate);
1667 if(!ost->resample){
1668 printf("Can't resample. Aborting.\n");
1669 av_abort();
1670 }
1671 }
1672 ist->decoding_needed = 1;
1673 ost->encoding_needed = 1;
1674 break;
1675 case CODEC_TYPE_VIDEO:
1676 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1677 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1678 ost->video_resample = ((codec->width != icodec->width -
1679 (frame_leftBand + frame_rightBand) +
1680 (frame_padleft + frame_padright)) ||
1681 (codec->height != icodec->height -
1682 (frame_topBand + frame_bottomBand) +
1683 (frame_padtop + frame_padbottom)));
1684 if (ost->video_crop) {
1685 ost->topBand = frame_topBand;
1686 ost->leftBand = frame_leftBand;
1687 }
1688 if (ost->video_pad) {
1689 ost->padtop = frame_padtop;
1690 ost->padleft = frame_padleft;
1691 ost->padbottom = frame_padbottom;
1692 ost->padright = frame_padright;
1693 if (!ost->video_resample) {
1694 avcodec_get_frame_defaults(&ost->pict_tmp);
1695 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1696 codec->width, codec->height ) )
1697 goto fail;
1698 }
1699 }
1700 if (ost->video_resample) {
1701 avcodec_get_frame_defaults(&ost->pict_tmp);
1702 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1703 codec->width, codec->height ) )
1704 goto fail;
1705
1706 ost->img_resample_ctx = img_resample_init(
1707 codec->width - (frame_padleft + frame_padright),
1708 codec->height - (frame_padtop + frame_padbottom),
1709 icodec->width - (frame_leftBand + frame_rightBand),
1710 icodec->height - (frame_topBand + frame_bottomBand));
1711
1712 }
1713 ost->encoding_needed = 1;
1714 ist->decoding_needed = 1;
1715 break;
1716 case CODEC_TYPE_SUBTITLE:
1717 ost->encoding_needed = 1;
1718 ist->decoding_needed = 1;
1719 break;
1720 default:
1721 av_abort();
1722 break;
1723 }
1724 /* two pass mode */
1725 if (ost->encoding_needed &&
1726 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1727 char logfilename[1024];
1728 FILE *f;
1729 int size;
1730 char *logbuffer;
1731
1732 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1733 pass_logfilename ?
1734 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1735 if (codec->flags & CODEC_FLAG_PASS1) {
1736 f = fopen(logfilename, "w");
1737 if (!f) {
1738 perror(logfilename);
1739 exit(1);
1740 }
1741 ost->logfile = f;
1742 } else {
1743 /* read the log file */
1744 f = fopen(logfilename, "r");
1745 if (!f) {
1746 perror(logfilename);
1747 exit(1);
1748 }
1749 fseek(f, 0, SEEK_END);
1750 size = ftell(f);
1751 fseek(f, 0, SEEK_SET);
1752 logbuffer = av_malloc(size + 1);
1753 if (!logbuffer) {
1754 fprintf(stderr, "Could not allocate log buffer\n");
1755 exit(1);
1756 }
1757 size = fread(logbuffer, 1, size, f);
1758 fclose(f);
1759 logbuffer[size] = '\0';
1760 codec->stats_in = logbuffer;
1761 }
1762 }
1763 }
1764 if(codec->codec_type == CODEC_TYPE_VIDEO){
1765 int size= codec->width * codec->height;
1766 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1767 }
1768 }
1769
1770 if (!bit_buffer)
1771 bit_buffer = av_malloc(bit_buffer_size);
1772 if (!bit_buffer)
1773 goto fail;
1774
1775 /* dump the file output parameters - cannot be done before in case
1776 of stream copy */
1777 for(i=0;i<nb_output_files;i++) {
1778 dump_format(output_files[i], i, output_files[i]->filename, 1);
1779 }
1780
1781 /* dump the stream mapping */
1782 if (verbose >= 0) {
1783 fprintf(stderr, "Stream mapping:\n");
1784 for(i=0;i<nb_ostreams;i++) {
1785 ost = ost_table[i];
1786 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1787 ist_table[ost->source_index]->file_index,
1788 ist_table[ost->source_index]->index,
1789 ost->file_index,
1790 ost->index);
1791 if (ost->sync_ist != ist_table[ost->source_index])
1792 fprintf(stderr, " [sync #%d.%d]",
1793 ost->sync_ist->file_index,
1794 ost->sync_ist->index);
1795 fprintf(stderr, "\n");
1796 }
1797 }
1798
1799 /* open each encoder */
1800 for(i=0;i<nb_ostreams;i++) {
1801 ost = ost_table[i];
1802 if (ost->encoding_needed) {
1803 AVCodec *codec;
1804 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1805 if (!codec) {
1806 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1807 ost->file_index, ost->index);
1808 exit(1);
1809 }
1810 if (avcodec_open(ost->st->codec, codec) < 0) {
1811 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1812 ost->file_index, ost->index);
1813 exit(1);
1814 }
1815 extra_size += ost->st->codec->extradata_size;
1816 }
1817 }
1818
1819 /* open each decoder */
1820 for(i=0;i<nb_istreams;i++) {
1821 ist = ist_table[i];
1822 if (ist->decoding_needed) {
1823 AVCodec *codec;
1824 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1825 if (!codec) {
1826 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1827 ist->st->codec->codec_id, ist->file_index, ist->index);
1828 exit(1);
1829 }
1830 if (avcodec_open(ist->st->codec, codec) < 0) {
1831 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1832 ist->file_index, ist->index);
1833 exit(1);
1834 }
1835 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1836 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1837 }
1838 }
1839
1840 /* init pts */
1841 for(i=0;i<nb_istreams;i++) {
1842 ist = ist_table[i];
1843 is = input_files[ist->file_index];
1844 ist->pts = 0;
1845 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1846 if(ist->st->start_time == AV_NOPTS_VALUE)
1847 ist->next_pts=0;
1848 if(input_files_ts_offset[ist->file_index])
1849 ist->next_pts= AV_NOPTS_VALUE;
1850 ist->is_start = 1;
1851 }
1852
1853 /* compute buffer size max (should use a complete heuristic) */
1854 for(i=0;i<nb_input_files;i++) {
1855 file_table[i].buffer_size_max = 2048;
1856 }
1857
1858 /* set meta data information from input file if required */
1859 for (i=0;i<nb_meta_data_maps;i++) {
1860 AVFormatContext *out_file;
1861 AVFormatContext *in_file;
1862
1863 int out_file_index = meta_data_maps[i].out_file;
1864 int in_file_index = meta_data_maps[i].in_file;
1865 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1866 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1867 ret = -EINVAL;
1868 goto fail;
1869 }
1870 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1871 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1872 ret = -EINVAL;
1873 goto fail;
1874 }
1875
1876 out_file = output_files[out_file_index];
1877 in_file = input_files[in_file_index];
1878
1879 strcpy(out_file->title, in_file->title);
1880 strcpy(out_file->author, in_file->author);
1881 strcpy(out_file->copyright, in_file->copyright);
1882 strcpy(out_file->comment, in_file->comment);
1883 strcpy(out_file->album, in_file->album);
1884 out_file->year = in_file->year;
1885 out_file->track = in_file->track;
1886 strcpy(out_file->genre, in_file->genre);
1887 }
1888
1889 /* open files and write file headers */
1890 for(i=0;i<nb_output_files;i++) {
1891 os = output_files[i];
1892 if (av_write_header(os) < 0) {
1893 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1894 ret = -EINVAL;
1895 goto fail;
1896 }
1897 }
1898
1899#ifndef CONFIG_WIN32
1900 if ( !using_stdin && verbose >= 0) {
1901 fprintf(stderr, "Press [q] to stop encoding\n");
1902 url_set_interrupt_cb(decode_interrupt_cb);
1903 }
1904#endif
1905 term_init();
1906
1907 stream_no_data = 0;
1908 key = -1;
1909
1910 for(; received_sigterm == 0;) {
1911 int file_index, ist_index;
1912 AVPacket pkt;
1913 double ipts_min;
1914 double opts_min;
1915
1916 redo:
1917 ipts_min= 1e100;
1918 opts_min= 1e100;
1919 /* if 'q' pressed, exits */
1920 if (!using_stdin) {
1921 if (q_pressed)
1922 break;
1923 /* read_key() returns 0 on EOF */
1924 key = read_key();
1925 if (key == 'q')
1926 break;
1927 }
1928
1929 /* select the stream that we must read now by looking at the
1930 smallest output pts */
1931 file_index = -1;
1932 for(i=0;i<nb_ostreams;i++) {
1933 double ipts, opts;
1934 ost = ost_table[i];
1935 os = output_files[ost->file_index];
1936 ist = ist_table[ost->source_index];
1937 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1938 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1939 else
1940 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1941 ipts = (double)ist->pts;
1942 if (!file_table[ist->file_index].eof_reached){
1943 if(ipts < ipts_min) {
1944 ipts_min = ipts;
1945 if(input_sync ) file_index = ist->file_index;
1946 }
1947 if(opts < opts_min) {
1948 opts_min = opts;
1949 if(!input_sync) file_index = ist->file_index;
1950 }
1951 }
1952 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1953 file_index= -1;
1954 break;
1955 }
1956 }
1957 /* if none, if is finished */
1958 if (file_index < 0) {
1959 break;
1960 }
1961
1962 /* finish if recording time exhausted */
1963 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1964 break;
1965
1966 /* finish if limit size exhausted */
1967 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1968 break;
1969
1970 /* read a frame from it and output it in the fifo */
1971 is = input_files[file_index];
1972 if (av_read_frame(is, &pkt) < 0) {
1973 file_table[file_index].eof_reached = 1;
1974 if (opt_shortest) break; else continue; //
1975 }
1976
1977 if (!pkt.size) {
1978 stream_no_data = is;
1979 } else {
1980 stream_no_data = 0;
1981 }
1982 if (do_pkt_dump) {
1983 av_pkt_dump(stdout, &pkt, do_hex_dump);
1984 }
1985 /* the following test is needed in case new streams appear
1986 dynamically in stream : we ignore them */
1987 if (pkt.stream_index >= file_table[file_index].nb_streams)
1988 goto discard_packet;
1989 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1990 ist = ist_table[ist_index];
1991 if (ist->discard)
1992 goto discard_packet;
1993
1994// fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1995 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1996 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1997 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1998 input_files_ts_offset[ist->file_index]-= delta;
1999 if (verbose > 2)
2000 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2001 for(i=0; i<file_table[file_index].nb_streams; i++){
2002 int index= file_table[file_index].ist_index + i;
2003 ist_table[index]->next_pts += delta;
2004 ist_table[index]->is_start=1;
2005 }
2006 }
2007 }
2008
2009 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2010 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2011
2012 if (verbose >= 0)
2013 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2014 ist->file_index, ist->index);
2015
2016 av_free_packet(&pkt);
2017 goto redo;
2018 }
2019
2020 discard_packet:
2021 av_free_packet(&pkt);
2022
2023 /* dump report by using the output first video and audio streams */
2024 print_report(output_files, ost_table, nb_ostreams, 0);
2025 }
2026
2027 /* at the end of stream, we must flush the decoder buffers */
2028 for(i=0;i<nb_istreams;i++) {
2029 ist = ist_table[i];
2030 if (ist->decoding_needed) {
2031 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2032 }
2033 }
2034
2035 term_exit();
2036
2037 /* write the trailer if needed and close file */
2038 for(i=0;i<nb_output_files;i++) {
2039 os = output_files[i];
2040 av_write_trailer(os);
2041 }
2042
2043 /* dump report by using the first video and audio streams */
2044 print_report(output_files, ost_table, nb_ostreams, 1);
2045
2046 /* close each encoder */
2047 for(i=0;i<nb_ostreams;i++) {
2048 ost = ost_table[i];
2049 if (ost->encoding_needed) {
2050 av_freep(&ost->st->codec->stats_in);
2051 avcodec_close(ost->st->codec);
2052 }
2053 }
2054
2055 /* close each decoder */
2056 for(i=0;i<nb_istreams;i++) {
2057 ist = ist_table[i];
2058 if (ist->decoding_needed) {
2059 avcodec_close(ist->st->codec);
2060 }
2061 }
2062
2063 /* finished ! */
2064
2065 ret = 0;
2066 fail1:
2067 av_freep(&bit_buffer);
2068 av_free(file_table);
2069
2070 if (ist_table) {
2071 for(i=0;i<nb_istreams;i++) {
2072 ist = ist_table[i];
2073 av_free(ist);
2074 }
2075 av_free(ist_table);
2076 }
2077 if (ost_table) {
2078 for(i=0;i<nb_ostreams;i++) {
2079 ost = ost_table[i];
2080 if (ost) {
2081 if (ost->logfile) {
2082 fclose(ost->logfile);
2083 ost->logfile = NULL;
2084 }
2085 fifo_free(&ost->fifo); /* works even if fifo is not
2086 initialized but set to zero */
2087 av_free(ost->pict_tmp.data[0]);
2088 if (ost->video_resample)
2089 img_resample_close(ost->img_resample_ctx);
2090 if (ost->audio_resample)
2091 audio_resample_close(ost->resample);
2092 av_free(ost);
2093 }
2094 }
2095 av_free(ost_table);
2096 }
2097 return ret;
2098 fail:
2099 ret = -ENOMEM;
2100 goto fail1;
2101}
2102
2103#if 0
2104int file_read(const char *filename)
2105{
2106 URLContext *h;
2107 unsigned char buffer[1024];
2108 int len, i;
2109
2110 if (url_open(&h, filename, O_RDONLY) < 0) {
2111 printf("could not open '%s'\n", filename);
2112 return -1;
2113 }
2114 for(;;) {
2115 len = url_read(h, buffer, sizeof(buffer));
2116 if (len <= 0)
2117 break;
2118 for(i=0;i<len;i++) putchar(buffer[i]);
2119 }
2120 url_close(h);
2121 return 0;
2122}
2123#endif
2124
2125static void opt_image_format(const char *arg)
2126{
2127 AVImageFormat *f;
2128
2129 for(f = first_image_format; f != NULL; f = f->next) {
2130 if (!strcmp(arg, f->name))
2131 break;
2132 }
2133 if (!f) {
2134 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2135 exit(1);
2136 }
2137 image_format = f;
2138}
2139
2140static void opt_format(const char *arg)
2141{
2142 /* compatibility stuff for pgmyuv */
2143 if (!strcmp(arg, "pgmyuv")) {
2144 pgmyuv_compatibility_hack=1;
2145// opt_image_format(arg);
2146 arg = "image2";
2147 }
2148
2149 file_iformat = av_find_input_format(arg);
2150 file_oformat = guess_format(arg, NULL, NULL);
2151 if (!file_iformat && !file_oformat) {
2152 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2153 exit(1);
2154 }
2155}
2156
2157static void opt_video_bitrate(const char *arg)
2158{
2159 video_bit_rate = atoi(arg) * 1000;
2160}
2161
2162static void opt_video_bitrate_tolerance(const char *arg)
2163{
2164 video_bit_rate_tolerance = atoi(arg) * 1000;
2165}
2166
2167static void opt_video_bitrate_max(const char *arg)
2168{
2169 video_rc_max_rate = atoi(arg) * 1000;
2170}
2171
2172static void opt_video_bitrate_min(const char *arg)
2173{
2174 video_rc_min_rate = atoi(arg) * 1000;
2175}
2176
2177static void opt_video_buffer_size(const char *arg)
2178{
2179 video_rc_buffer_size = atoi(arg) * 8*1024;
2180}
2181
2182static void opt_video_rc_eq(char *arg)
2183{
2184 video_rc_eq = arg;
2185}
2186
2187static void opt_video_rc_override_string(char *arg)
2188{
2189 video_rc_override_string = arg;
2190}
2191
2192
2193static void opt_workaround_bugs(const char *arg)
2194{
2195 workaround_bugs = atoi(arg);
2196}
2197
2198static void opt_me_threshold(const char *arg)
2199{
2200 me_threshold = atoi(arg);
2201}
2202
2203static void opt_mb_threshold(const char *arg)
2204{
2205 mb_threshold = atoi(arg);
2206}
2207
2208static void opt_verbose(const char *arg)
2209{
2210 verbose = atoi(arg);
2211 av_log_set_level(atoi(arg));
2212}
2213
2214static void opt_frame_rate(const char *arg)
2215{
2216 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2217 fprintf(stderr, "Incorrect frame rate\n");
2218 exit(1);
2219 }
2220}
2221
2222static void opt_frame_crop_top(const char *arg)
2223{
2224 frame_topBand = atoi(arg);
2225 if (frame_topBand < 0) {
2226 fprintf(stderr, "Incorrect top crop size\n");
2227 exit(1);
2228 }
2229 if ((frame_topBand % 2) != 0) {
2230 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2231 exit(1);
2232 }
2233 if ((frame_topBand) >= frame_height){
2234 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2235 exit(1);
2236 }
2237 frame_height -= frame_topBand;
2238}
2239
2240static void opt_frame_crop_bottom(const char *arg)
2241{
2242 frame_bottomBand = atoi(arg);
2243 if (frame_bottomBand < 0) {
2244 fprintf(stderr, "Incorrect bottom crop size\n");
2245 exit(1);
2246 }
2247 if ((frame_bottomBand % 2) != 0) {
2248 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2249 exit(1);
2250 }
2251 if ((frame_bottomBand) >= frame_height){
2252 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2253 exit(1);
2254 }
2255 frame_height -= frame_bottomBand;
2256}
2257
2258static void opt_frame_crop_left(const char *arg)
2259{
2260 frame_leftBand = atoi(arg);
2261 if (frame_leftBand < 0) {
2262 fprintf(stderr, "Incorrect left crop size\n");
2263 exit(1);
2264 }
2265 if ((frame_leftBand % 2) != 0) {
2266 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2267 exit(1);
2268 }
2269 if ((frame_leftBand) >= frame_width){
2270 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2271 exit(1);
2272 }
2273 frame_width -= frame_leftBand;
2274}
2275
2276static void opt_frame_crop_right(const char *arg)
2277{
2278 frame_rightBand = atoi(arg);
2279 if (frame_rightBand < 0) {
2280 fprintf(stderr, "Incorrect right crop size\n");
2281 exit(1);
2282 }
2283 if ((frame_rightBand % 2) != 0) {
2284 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2285 exit(1);
2286 }
2287 if ((frame_rightBand) >= frame_width){
2288 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2289 exit(1);
2290 }
2291 frame_width -= frame_rightBand;
2292}
2293
2294static void opt_frame_size(const char *arg)
2295{
2296 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2297 fprintf(stderr, "Incorrect frame size\n");
2298 exit(1);
2299 }
2300 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2301 fprintf(stderr, "Frame size must be a multiple of 2\n");
2302 exit(1);
2303 }
2304}
2305
2306
2307#define SCALEBITS 10
2308#define ONE_HALF (1 << (SCALEBITS - 1))
2309#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2310
2311#define RGB_TO_Y(r, g, b) \
2312((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2313 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2314
2315#define RGB_TO_U(r1, g1, b1, shift)\
2316(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2317 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2318
2319#define RGB_TO_V(r1, g1, b1, shift)\
2320(((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2321 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2322
2323static void opt_pad_color(const char *arg) {
2324 /* Input is expected to be six hex digits similar to
2325 how colors are expressed in html tags (but without the #) */
2326 int rgb = strtol(arg, NULL, 16);
2327 int r,g,b;
2328
2329 r = (rgb >> 16);
2330 g = ((rgb >> 8) & 255);
2331 b = (rgb & 255);
2332
2333 padcolor[0] = RGB_TO_Y(r,g,b);
2334 padcolor[1] = RGB_TO_U(r,g,b,0);
2335 padcolor[2] = RGB_TO_V(r,g,b,0);
2336}
2337
2338static void opt_frame_pad_top(const char *arg)
2339{
2340 frame_padtop = atoi(arg);
2341 if (frame_padtop < 0) {
2342 fprintf(stderr, "Incorrect top pad size\n");
2343 exit(1);
2344 }
2345 if ((frame_padtop % 2) != 0) {
2346 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2347 exit(1);
2348 }
2349}
2350
2351static void opt_frame_pad_bottom(const char *arg)
2352{
2353 frame_padbottom = atoi(arg);
2354 if (frame_padbottom < 0) {
2355 fprintf(stderr, "Incorrect bottom pad size\n");
2356 exit(1);
2357 }
2358 if ((frame_padbottom % 2) != 0) {
2359 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2360 exit(1);
2361 }
2362}
2363
2364
2365static void opt_frame_pad_left(const char *arg)
2366{
2367 frame_padleft = atoi(arg);
2368 if (frame_padleft < 0) {
2369 fprintf(stderr, "Incorrect left pad size\n");
2370 exit(1);
2371 }
2372 if ((frame_padleft % 2) != 0) {
2373 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2374 exit(1);
2375 }
2376}
2377
2378
2379static void opt_frame_pad_right(const char *arg)
2380{
2381 frame_padright = atoi(arg);
2382 if (frame_padright < 0) {
2383 fprintf(stderr, "Incorrect right pad size\n");
2384 exit(1);
2385 }
2386 if ((frame_padright % 2) != 0) {
2387 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2388 exit(1);
2389 }
2390}
2391
2392
2393static void opt_frame_pix_fmt(const char *arg)
2394{
2395 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2396}
2397
2398static void opt_frame_aspect_ratio(const char *arg)
2399{
2400 int x = 0, y = 0;
2401 double ar = 0;
2402 const char *p;
2403
2404 p = strchr(arg, ':');
2405 if (p) {
2406 x = strtol(arg, (char **)&arg, 10);
2407 if (arg == p)
2408 y = strtol(arg+1, (char **)&arg, 10);
2409 if (x > 0 && y > 0)
2410 ar = (double)x / (double)y;
2411 } else
2412 ar = strtod(arg, (char **)&arg);
2413
2414 if (!ar) {
2415 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2416 exit(1);
2417 }
2418 frame_aspect_ratio = ar;
2419}
2420
2421static void opt_gop_size(const char *arg)
2422{
2423 gop_size = atoi(arg);
2424}
2425
2426static void opt_b_frames(const char *arg)
2427{
2428 b_frames = atoi(arg);
2429 if (b_frames > FF_MAX_B_FRAMES) {
2430 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2431 exit(1);
2432 } else if (b_frames < 1) {
2433 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2434 exit(1);
2435 }
2436}
2437
2438static void opt_pre_me(const char *arg)
2439{
2440 pre_me = atoi(arg);
2441}
2442
2443static void opt_qscale(const char *arg)
2444{
2445 video_qscale = atof(arg);
2446 if (video_qscale <= 0 ||
2447 video_qscale > 255) {
2448 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2449 exit(1);
2450 }
2451}
2452
2453static void opt_qsquish(const char *arg)
2454{
2455 video_qsquish = atof(arg);
2456 if (video_qsquish < 0.0 ||
2457 video_qsquish > 99.0) {
2458 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2459 exit(1);
2460 }
2461}
2462
2463static void opt_lmax(const char *arg)
2464{
2465 video_lmax = atof(arg)*FF_QP2LAMBDA;
2466}
2467
2468static void opt_lmin(const char *arg)
2469{
2470 video_lmin = atof(arg)*FF_QP2LAMBDA;
2471}
2472
2473static void opt_qmin(const char *arg)
2474{
2475 video_qmin = atoi(arg);
2476 if (video_qmin < 1 ||
2477 video_qmin > 51) {
2478 fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2479 exit(1);
2480 }
2481}
2482
2483static void opt_qmax(const char *arg)
2484{
2485 video_qmax = atoi(arg);
2486 if (video_qmax < 1 ||
2487 video_qmax > 51) {
2488 fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2489 exit(1);
2490 }
2491}
2492
2493static void opt_mb_lmin(const char *arg)
2494{
2495 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2496 if (video_mb_lmin < 1 ||
2497 video_mb_lmin > FF_LAMBDA_MAX) {
2498 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2499 exit(1);
2500 }
2501}
2502
2503static void opt_mb_lmax(const char *arg)
2504{
2505 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2506 if (video_mb_lmax < 1 ||
2507 video_mb_lmax > FF_LAMBDA_MAX) {
2508 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2509 exit(1);
2510 }
2511}
2512
2513static void opt_qdiff(const char *arg)
2514{
2515 video_qdiff = atoi(arg);
2516 if (video_qdiff < 0 ||
2517 video_qdiff > 31) {
2518 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2519 exit(1);
2520 }
2521}
2522
2523static void opt_qblur(const char *arg)
2524{
2525 video_qblur = atof(arg);
2526}
2527
2528static void opt_qcomp(const char *arg)
2529{
2530 video_qcomp = atof(arg);
2531}
2532
2533static void opt_rc_initial_cplx(const char *arg)
2534{
2535 video_rc_initial_cplx = atof(arg);
2536}
2537static void opt_b_qfactor(const char *arg)
2538{
2539 video_b_qfactor = atof(arg);
2540}
2541static void opt_i_qfactor(const char *arg)
2542{
2543 video_i_qfactor = atof(arg);
2544}
2545static void opt_b_qoffset(const char *arg)
2546{
2547 video_b_qoffset = atof(arg);
2548}
2549static void opt_i_qoffset(const char *arg)
2550{
2551 video_i_qoffset = atof(arg);
2552}
2553
2554static void opt_ibias(const char *arg)
2555{
2556 video_intra_quant_bias = atoi(arg);
2557}
2558static void opt_pbias(const char *arg)
2559{
2560 video_inter_quant_bias = atoi(arg);
2561}
2562
2563static void opt_packet_size(const char *arg)
2564{
2565 packet_size= atoi(arg);
2566}
2567
2568static void opt_error_rate(const char *arg)
2569{
2570 error_rate= atoi(arg);
2571}
2572
2573static void opt_strict(const char *arg)
2574{
2575 strict= atoi(arg);
2576}
2577
2578static void opt_top_field_first(const char *arg)
2579{
2580 top_field_first= atoi(arg);
2581}
2582
2583static void opt_sc_threshold(const char *arg)
2584{
2585 sc_threshold= atoi(arg);
2586}
2587
2588static void opt_me_range(const char *arg)
2589{
2590 me_range = atoi(arg);
2591}
2592
2593static void opt_thread_count(const char *arg)
2594{
2595 thread_count= atoi(arg);
2596#if !defined(HAVE_THREADS)
2597 if (verbose >= 0)
2598 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2599#endif
2600}
2601
2602static void opt_audio_bitrate(const char *arg)
2603{
2604 audio_bit_rate = atoi(arg) * 1000;
2605}
2606
2607static void opt_audio_rate(const char *arg)
2608{
2609 audio_sample_rate = atoi(arg);
2610}
2611
2612static void opt_audio_channels(const char *arg)
2613{
2614 audio_channels = atoi(arg);
2615}
2616
2617static void opt_video_device(const char *arg)
2618{
2619 video_device = av_strdup(arg);
2620}
2621
2622static void opt_grab_device(const char *arg)
2623{
2624 grab_device = av_strdup(arg);
2625}
2626
2627static void opt_video_channel(const char *arg)
2628{
2629 video_channel = strtol(arg, NULL, 0);
2630}
2631
2632static void opt_video_standard(const char *arg)
2633{
2634 video_standard = av_strdup(arg);
2635}
2636
2637static void opt_audio_device(const char *arg)
2638{
2639 audio_device = av_strdup(arg);
2640}
2641
2642static void opt_codec(int *pstream_copy, int *pcodec_id,
2643 int codec_type, const char *arg)
2644{
2645 AVCodec *p;
2646
2647 if (!strcmp(arg, "copy")) {
2648 *pstream_copy = 1;
2649 } else {
2650 p = first_avcodec;
2651 while (p) {
2652 if (!strcmp(p->name, arg) && p->type == codec_type)
2653 break;
2654 p = p->next;
2655 }
2656 if (p == NULL) {
2657 fprintf(stderr, "Unknown codec '%s'\n", arg);
2658 exit(1);
2659 } else {
2660 *pcodec_id = p->id;
2661 }
2662 }
2663}
2664
2665static void opt_audio_codec(const char *arg)
2666{
2667 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2668}
2669
2670static void opt_audio_tag(const char *arg)
2671{
2672 char *tail;
2673 audio_codec_tag= strtol(arg, &tail, 0);
2674
2675 if(!tail || *tail)
2676 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2677}
2678
2679static void opt_video_tag(const char *arg)
2680{
2681 char *tail;
2682 video_codec_tag= strtol(arg, &tail, 0);
2683
2684 if(!tail || *tail)
2685 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2686}
2687
2688static void add_frame_hooker(const char *arg)
2689{
2690 int argc = 0;
2691 char *argv[64];
2692 int i;
2693 char *args = av_strdup(arg);
2694
2695 using_vhook = 1;
2696
2697 argv[0] = strtok(args, " ");
2698 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2699 }
2700
2701 i = frame_hook_add(argc, argv);
2702
2703 if (i != 0) {
2704 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2705 exit(1);
2706 }
2707}
2708
2709const char *motion_str[] = {
2710 "zero",
2711 "full",
2712 "log",
2713 "phods",
2714 "epzs",
2715 "x1",
2716 "hex",
2717 "umh",
2718 "iter",
2719 NULL,
2720};
2721
2722static void opt_motion_estimation(const char *arg)
2723{
2724 const char **p;
2725 p = motion_str;
2726 for(;;) {
2727 if (!*p) {
2728 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2729 exit(1);
2730 }
2731 if (!strcmp(*p, arg))
2732 break;
2733 p++;
2734 }
2735 me_method = (p - motion_str) + 1;
2736}
2737
2738static void opt_video_codec(const char *arg)
2739{
2740 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2741}
2742
2743static void opt_subtitle_codec(const char *arg)
2744{
2745 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2746}
2747
2748static void opt_map(const char *arg)
2749{
2750 AVStreamMap *m;
2751 const char *p;
2752
2753 p = arg;
2754 m = &stream_maps[nb_stream_maps++];
2755
2756 m->file_index = strtol(arg, (char **)&p, 0);
2757 if (*p)
2758 p++;
2759
2760 m->stream_index = strtol(p, (char **)&p, 0);
2761 if (*p) {
2762 p++;
2763 m->sync_file_index = strtol(p, (char **)&p, 0);
2764 if (*p)
2765 p++;
2766 m->sync_stream_index = strtol(p, (char **)&p, 0);
2767 } else {
2768 m->sync_file_index = m->file_index;
2769 m->sync_stream_index = m->stream_index;
2770 }
2771}
2772
2773static void opt_map_meta_data(const char *arg)
2774{
2775 AVMetaDataMap *m;
2776 const char *p;
2777
2778 p = arg;
2779 m = &meta_data_maps[nb_meta_data_maps++];
2780
2781 m->out_file = strtol(arg, (char **)&p, 0);
2782 if (*p)
2783 p++;
2784
2785 m->in_file = strtol(p, (char **)&p, 0);
2786}
2787
2788static void opt_recording_time(const char *arg)
2789{
2790 recording_time = parse_date(arg, 1);
2791}
2792
2793static void opt_start_time(const char *arg)
2794{
2795 start_time = parse_date(arg, 1);
2796}
2797
2798static void opt_rec_timestamp(const char *arg)
2799{
2800 rec_timestamp = parse_date(arg, 0) / 1000000;
2801}
2802
2803static void opt_input_ts_offset(const char *arg)
2804{
2805 input_ts_offset = parse_date(arg, 1);
2806}
2807
2808static void opt_input_file(const char *filename)
2809{
2810 AVFormatContext *ic;
2811 AVFormatParameters params, *ap = &params;
2812 int err, i, ret, rfps, rfps_base;
2813 int64_t timestamp;
2814
2815 if (!strcmp(filename, "-"))
2816 filename = "pipe:";
2817
2818 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2819 !strcmp( filename, "/dev/stdin" );
2820
2821 /* get default parameters from command line */
2822 memset(ap, 0, sizeof(*ap));
2823 ap->sample_rate = audio_sample_rate;
2824 ap->channels = audio_channels;
2825 ap->time_base.den = frame_rate;
2826 ap->time_base.num = frame_rate_base;
2827 ap->width = frame_width + frame_padleft + frame_padright;
2828 ap->height = frame_height + frame_padtop + frame_padbottom;
2829 ap->image_format = image_format;
2830 ap->pix_fmt = frame_pix_fmt;
2831 ap->device = grab_device;
2832 ap->channel = video_channel;
2833 ap->standard = video_standard;
2834 ap->video_codec_id = video_codec_id;
2835 ap->audio_codec_id = audio_codec_id;
2836 if(pgmyuv_compatibility_hack)
2837 ap->video_codec_id= CODEC_ID_PGMYUV;
2838
2839 /* open the input file with generic libav function */
2840 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2841 if (err < 0) {
2842 print_error(filename, err);
2843 exit(1);
2844 }
2845
2846 if(genpts)
2847 ic->flags|= AVFMT_FLAG_GENPTS;
2848
2849 /* If not enough info to get the stream parameters, we decode the
2850 first frames to get it. (used in mpeg case for example) */
2851 ret = av_find_stream_info(ic);
2852 if (ret < 0 && verbose >= 0) {
2853 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2854 exit(1);
2855 }
2856
2857 timestamp = start_time;
2858 /* add the stream start time */
2859 if (ic->start_time != AV_NOPTS_VALUE)
2860 timestamp += ic->start_time;
2861
2862 /* if seeking requested, we execute it */
2863 if (start_time != 0) {
2864 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2865 if (ret < 0) {
2866 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2867 filename, (double)timestamp / AV_TIME_BASE);
2868 }
2869 /* reset seek info */
2870 start_time = 0;
2871 }
2872
2873 /* update the current parameters so that they match the one of the input stream */
2874 for(i=0;i<ic->nb_streams;i++) {
2875 int j;
2876 AVCodecContext *enc = ic->streams[i]->codec;
2877#if defined(HAVE_THREADS)
2878 if(thread_count>1)
2879 avcodec_thread_init(enc, thread_count);
2880#endif
2881 enc->thread_count= thread_count;
2882 switch(enc->codec_type) {
2883 case CODEC_TYPE_AUDIO:
2884 for(j=0; j<opt_name_count; j++){
2885 AVOption *opt;
2886 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2887 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2888 av_set_double(enc, opt_names[j], d);
2889 }
2890 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2891 audio_channels = enc->channels;
2892 audio_sample_rate = enc->sample_rate;
2893 if(audio_disable)
2894 ic->streams[i]->discard= AVDISCARD_ALL;
2895 break;
2896 case CODEC_TYPE_VIDEO:
2897 for(j=0; j<opt_name_count; j++){
2898 AVOption *opt;
2899 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2900 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2901 av_set_double(enc, opt_names[j], d);
2902 }
2903 frame_height = enc->height;
2904 frame_width = enc->width;
2905 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2906 frame_pix_fmt = enc->pix_fmt;
2907 rfps = ic->streams[i]->r_frame_rate.num;
2908 rfps_base = ic->streams[i]->r_frame_rate.den;
2909 enc->workaround_bugs = workaround_bugs;
2910 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2911 if(me_threshold)
2912 enc->debug |= FF_DEBUG_MV;
2913
2914 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2915
2916 if (verbose >= 0)
2917 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2918 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2919
2920 (float)rfps / rfps_base, rfps, rfps_base);
2921 }
2922 /* update the current frame rate to match the stream frame rate */
2923 frame_rate = rfps;
2924 frame_rate_base = rfps_base;
2925
2926 enc->rate_emu = rate_emu;
2927 if(video_disable)
2928 ic->streams[i]->discard= AVDISCARD_ALL;
2929 else if(video_discard)
2930 ic->streams[i]->discard= video_discard;
2931 break;
2932 case CODEC_TYPE_DATA:
2933 break;
2934 case CODEC_TYPE_SUBTITLE:
2935 break;
2936 case CODEC_TYPE_UNKNOWN:
2937 break;
2938 default:
2939 av_abort();
2940 }
2941 }
2942
2943 input_files[nb_input_files] = ic;
2944 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2945 /* dump the file content */
2946 if (verbose >= 0)
2947 dump_format(ic, nb_input_files, filename, 0);
2948
2949 nb_input_files++;
2950 file_iformat = NULL;
2951 file_oformat = NULL;
2952 image_format = NULL;
2953
2954 grab_device = NULL;
2955 video_channel = 0;
2956
2957 rate_emu = 0;
2958}
2959
2960static void opt_grab(const char *arg)
2961{
2962 file_iformat = av_find_input_format(arg);
2963 opt_input_file("");
2964}
2965
2966static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2967{
2968 int has_video, has_audio, i, j;
2969 AVFormatContext *ic;
2970
2971 has_video = 0;
2972 has_audio = 0;
2973 for(j=0;j<nb_input_files;j++) {
2974 ic = input_files[j];
2975 for(i=0;i<ic->nb_streams;i++) {
2976 AVCodecContext *enc = ic->streams[i]->codec;
2977 switch(enc->codec_type) {
2978 case CODEC_TYPE_AUDIO:
2979 has_audio = 1;
2980 break;
2981 case CODEC_TYPE_VIDEO:
2982 has_video = 1;
2983 break;
2984 case CODEC_TYPE_DATA:
2985 case CODEC_TYPE_UNKNOWN:
2986 case CODEC_TYPE_SUBTITLE:
2987 break;
2988 default:
2989 av_abort();
2990 }
2991 }
2992 }
2993 *has_video_ptr = has_video;
2994 *has_audio_ptr = has_audio;
2995}
2996
2997static void new_video_stream(AVFormatContext *oc)
2998{
2999 AVStream *st;
3000 AVCodecContext *video_enc;
3001 int codec_id;
3002
3003 st = av_new_stream(oc, oc->nb_streams);
3004 if (!st) {
3005 fprintf(stderr, "Could not alloc stream\n");
3006 exit(1);
3007 }
3008 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3009 video_bitstream_filters= NULL;
3010
3011#if defined(HAVE_THREADS)
3012 if(thread_count>1)
3013 avcodec_thread_init(st->codec, thread_count);
3014#endif
3015
3016 video_enc = st->codec;
3017
3018 if(video_codec_tag)
3019 video_enc->codec_tag= video_codec_tag;
3020
3021 if( (video_global_header&1)
3022 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3023 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3024 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3025 }
3026 if(video_global_header&2){
3027 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3028 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3029 }
3030
3031 if (video_stream_copy) {
3032 st->stream_copy = 1;
3033 video_enc->codec_type = CODEC_TYPE_VIDEO;
3034 } else {
3035 char *p;
3036 int i;
3037 AVCodec *codec;
3038
3039 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3040 if (video_codec_id != CODEC_ID_NONE)
3041 codec_id = video_codec_id;
3042
3043 video_enc->codec_id = codec_id;
3044 codec = avcodec_find_encoder(codec_id);
3045
3046 for(i=0; i<opt_name_count; i++){
3047 AVOption *opt;
3048 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3049 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3050 av_set_double(video_enc, opt_names[i], d);
3051 }
3052
3053 video_enc->bit_rate = video_bit_rate;
3054 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3055 video_enc->time_base.den = frame_rate;
3056 video_enc->time_base.num = frame_rate_base;
3057 if(codec && codec->supported_framerates){
3058 const AVRational *p= codec->supported_framerates;
3059 AVRational req= (AVRational){frame_rate, frame_rate_base};
3060 const AVRational *best=NULL;
3061 AVRational best_error= (AVRational){INT_MAX, 1};
3062 for(; p->den!=0; p++){
3063 AVRational error= av_sub_q(req, *p);
3064 if(error.num <0) error.num *= -1;
3065 if(av_cmp_q(error, best_error) < 0){
3066 best_error= error;
3067 best= p;
3068 }
3069 }
3070 video_enc->time_base.den= best->num;
3071 video_enc->time_base.num= best->den;
3072 }
3073
3074 video_enc->width = frame_width + frame_padright + frame_padleft;
3075 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3076 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3077 video_enc->pix_fmt = frame_pix_fmt;
3078
3079 if(codec && codec->pix_fmts){
3080 const enum PixelFormat *p= codec->pix_fmts;
3081 for(; *p!=-1; p++){
3082 if(*p == video_enc->pix_fmt)
3083 break;
3084 }
3085 if(*p == -1)
3086 video_enc->pix_fmt = codec->pix_fmts[0];
3087 }
3088
3089 if (!intra_only)
3090 video_enc->gop_size = gop_size;
3091 else
3092 video_enc->gop_size = 0;
3093 if (video_qscale || same_quality) {
3094 video_enc->flags |= CODEC_FLAG_QSCALE;
3095 video_enc->global_quality=
3096 st->quality = FF_QP2LAMBDA * video_qscale;
3097 }
3098
3099 if(intra_matrix)
3100 video_enc->intra_matrix = intra_matrix;
3101 if(inter_matrix)
3102 video_enc->inter_matrix = inter_matrix;
3103
3104 video_enc->pre_me = pre_me;
3105
3106 if (b_frames) {
3107 video_enc->max_b_frames = b_frames;
3108 video_enc->b_quant_factor = 2.0;
3109 }
3110 video_enc->qmin = video_qmin;
3111 video_enc->qmax = video_qmax;
3112 video_enc->lmin = video_lmin;
3113 video_enc->lmax = video_lmax;
3114 video_enc->rc_qsquish = video_qsquish;
3115 video_enc->mb_lmin = video_mb_lmin;
3116 video_enc->mb_lmax = video_mb_lmax;
3117 video_enc->max_qdiff = video_qdiff;
3118 video_enc->qblur = video_qblur;
3119 video_enc->qcompress = video_qcomp;
3120 video_enc->rc_eq = video_rc_eq;
3121 video_enc->workaround_bugs = workaround_bugs;
3122 video_enc->thread_count = thread_count;
3123 p= video_rc_override_string;
3124 for(i=0; p; i++){
3125 int start, end, q;
3126 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3127 if(e!=3){
3128 fprintf(stderr, "error parsing rc_override\n");
3129 exit(1);
3130 }
3131 video_enc->rc_override=
3132 av_realloc(video_enc->rc_override,
3133 sizeof(RcOverride)*(i+1));
3134 video_enc->rc_override[i].start_frame= start;
3135 video_enc->rc_override[i].end_frame = end;
3136 if(q>0){
3137 video_enc->rc_override[i].qscale= q;
3138 video_enc->rc_override[i].quality_factor= 1.0;
3139 }
3140 else{
3141 video_enc->rc_override[i].qscale= 0;
3142 video_enc->rc_override[i].quality_factor= -q/100.0;
3143 }
3144 p= strchr(p, '/');
3145 if(p) p++;
3146 }
3147 video_enc->rc_override_count=i;
3148
3149 video_enc->rc_max_rate = video_rc_max_rate;
3150 video_enc->rc_min_rate = video_rc_min_rate;
3151 video_enc->rc_buffer_size = video_rc_buffer_size;
3152 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3153 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3154 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3155 video_enc->i_quant_factor = video_i_qfactor;
3156 video_enc->b_quant_factor = video_b_qfactor;
3157 video_enc->i_quant_offset = video_i_qoffset;
3158 video_enc->b_quant_offset = video_b_qoffset;
3159 video_enc->intra_quant_bias = video_intra_quant_bias;
3160 video_enc->inter_quant_bias = video_inter_quant_bias;
3161 video_enc->me_threshold= me_threshold;
3162 video_enc->mb_threshold= mb_threshold;
3163 video_enc->intra_dc_precision= intra_dc_precision - 8;
3164 video_enc->strict_std_compliance = strict;
3165 video_enc->error_rate = error_rate;
3166 video_enc->scenechange_threshold= sc_threshold;
3167 video_enc->me_range = me_range;
3168 video_enc->me_penalty_compensation= me_penalty_compensation;
3169 video_enc->frame_skip_threshold= frame_skip_threshold;
3170 video_enc->frame_skip_factor= frame_skip_factor;
3171 video_enc->frame_skip_exp= frame_skip_exp;
3172
3173 if(packet_size){
3174 video_enc->rtp_mode= 1;
3175 video_enc->rtp_payload_size= packet_size;
3176 }
3177
3178 if (do_psnr)
3179 video_enc->flags|= CODEC_FLAG_PSNR;
3180
3181 video_enc->me_method = me_method;
3182
3183 /* two pass mode */
3184 if (do_pass) {
3185 if (do_pass == 1) {
3186 video_enc->flags |= CODEC_FLAG_PASS1;
3187 } else {
3188 video_enc->flags |= CODEC_FLAG_PASS2;
3189 }
3190 }
3191 }
3192
3193 /* reset some key parameters */
3194 video_disable = 0;
3195 video_codec_id = CODEC_ID_NONE;
3196 video_stream_copy = 0;
3197}
3198
3199static void new_audio_stream(AVFormatContext *oc)
3200{
3201 AVStream *st;
3202 AVCodecContext *audio_enc;
3203 int codec_id, i;
3204
3205 st = av_new_stream(oc, oc->nb_streams);
3206 if (!st) {
3207 fprintf(stderr, "Could not alloc stream\n");
3208 exit(1);
3209 }
3210
3211 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3212 audio_bitstream_filters= NULL;
3213
3214#if defined(HAVE_THREADS)
3215 if(thread_count>1)
3216 avcodec_thread_init(st->codec, thread_count);
3217#endif
3218
3219 audio_enc = st->codec;
3220 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3221
3222 if(audio_codec_tag)
3223 audio_enc->codec_tag= audio_codec_tag;
3224
3225 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3226 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3227 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3228 }
3229 if (audio_stream_copy) {
3230 st->stream_copy = 1;
3231 audio_enc->channels = audio_channels;
3232 } else {
3233 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3234
3235 for(i=0; i<opt_name_count; i++){
3236 AVOption *opt;
3237 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3238 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3239 av_set_double(audio_enc, opt_names[i], d);
3240 }
3241
3242 if (audio_codec_id != CODEC_ID_NONE)
3243 codec_id = audio_codec_id;
3244 audio_enc->codec_id = codec_id;
3245
3246 audio_enc->bit_rate = audio_bit_rate;
3247 if (audio_qscale > QSCALE_NONE) {
3248 audio_enc->flags |= CODEC_FLAG_QSCALE;
3249 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3250 }
3251 audio_enc->strict_std_compliance = strict;
3252 audio_enc->thread_count = thread_count;
3253 /* For audio codecs other than AC3 or DTS we limit */
3254 /* the number of coded channels to stereo */
3255 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3256 && codec_id != CODEC_ID_DTS) {
3257 audio_enc->channels = 2;
3258 } else
3259 audio_enc->channels = audio_channels;
3260 }
3261 audio_enc->sample_rate = audio_sample_rate;
3262 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3263 if (audio_language) {
3264 pstrcpy(st->language, sizeof(st->language), audio_language);
3265 av_free(audio_language);
3266 audio_language = NULL;
3267 }
3268
3269 /* reset some key parameters */
3270 audio_disable = 0;
3271 audio_codec_id = CODEC_ID_NONE;
3272 audio_stream_copy = 0;
3273}
3274
3275static void opt_new_subtitle_stream(void)
3276{
3277 AVFormatContext *oc;
3278 AVStream *st;
3279 AVCodecContext *subtitle_enc;
3280 int i;
3281
3282 if (nb_output_files <= 0) {
3283 fprintf(stderr, "At least one output file must be specified\n");
3284 exit(1);
3285 }
3286 oc = output_files[nb_output_files - 1];
3287
3288 st = av_new_stream(oc, oc->nb_streams);
3289 if (!st) {
3290 fprintf(stderr, "Could not alloc stream\n");
3291 exit(1);
3292 }
3293
3294 subtitle_enc = st->codec;
3295 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3296 if (subtitle_stream_copy) {
3297 st->stream_copy = 1;
3298 } else {
3299 for(i=0; i<opt_name_count; i++){
3300 AVOption *opt;
3301 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3302 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3303 av_set_double(subtitle_enc, opt_names[i], d);
3304 }
3305 subtitle_enc->codec_id = subtitle_codec_id;
3306 }
3307
3308 if (subtitle_language) {
3309 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3310 av_free(subtitle_language);
3311 subtitle_language = NULL;
3312 }
3313
3314 subtitle_codec_id = CODEC_ID_NONE;
3315 subtitle_stream_copy = 0;
3316}
3317
3318static void opt_new_audio_stream(void)
3319{
3320 AVFormatContext *oc;
3321 if (nb_output_files <= 0) {
3322 fprintf(stderr, "At least one output file must be specified\n");
3323 exit(1);
3324 }
3325 oc = output_files[nb_output_files - 1];
3326 new_audio_stream(oc);
3327}
3328
3329static void opt_new_video_stream(void)
3330{
3331 AVFormatContext *oc;
3332 if (nb_output_files <= 0) {
3333 fprintf(stderr, "At least one output file must be specified\n");
3334 exit(1);
3335 }
3336 oc = output_files[nb_output_files - 1];
3337 new_video_stream(oc);
3338}
3339
3340static void opt_output_file(const char *filename)
3341{
3342 AVFormatContext *oc;
3343 int use_video, use_audio, input_has_video, input_has_audio;
3344 AVFormatParameters params, *ap = &params;
3345
3346 if (!strcmp(filename, "-"))
3347 filename = "pipe:";
3348
3349 oc = av_alloc_format_context();
3350
3351 if (!file_oformat) {
3352 file_oformat = guess_format(NULL, filename, NULL);
3353 if (!file_oformat) {
3354 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3355 filename);
3356 exit(1);
3357 }
3358 }
3359
3360 oc->oformat = file_oformat;
3361 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3362
3363 if (!strcmp(file_oformat->name, "ffm") &&
3364 strstart(filename, "http:", NULL)) {
3365 /* special case for files sent to ffserver: we get the stream
3366 parameters from ffserver */
3367 if (read_ffserver_streams(oc, filename) < 0) {
3368 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3369 exit(1);
3370 }
3371 } else {
3372 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3373 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3374
3375 /* disable if no corresponding type found and at least one
3376 input file */
3377 if (nb_input_files > 0) {
3378 check_audio_video_inputs(&input_has_video, &input_has_audio);
3379 if (!input_has_video)
3380 use_video = 0;
3381 if (!input_has_audio)
3382 use_audio = 0;
3383 }
3384
3385 /* manual disable */
3386 if (audio_disable) {
3387 use_audio = 0;
3388 }
3389 if (video_disable) {
3390 use_video = 0;
3391 }
3392
3393 if (use_video) {
3394 new_video_stream(oc);
3395 }
3396
3397 if (use_audio) {
3398 new_audio_stream(oc);
3399 }
3400
3401 if (!oc->nb_streams) {
3402 fprintf(stderr, "No audio or video streams available\n");
3403 exit(1);
3404 }
3405
3406 oc->timestamp = rec_timestamp;
3407
3408 if (str_title)
3409 pstrcpy(oc->title, sizeof(oc->title), str_title);
3410 if (str_author)
3411 pstrcpy(oc->author, sizeof(oc->author), str_author);
3412 if (str_copyright)
3413 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3414 if (str_comment)
3415 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3416 }
3417
3418 output_files[nb_output_files++] = oc;
3419
3420 /* check filename in case of an image number is expected */
3421 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3422 if (filename_number_test(oc->filename) < 0) {
3423 print_error(oc->filename, AVERROR_NUMEXPECTED);
3424 exit(1);
3425 }
3426 }
3427
3428 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3429 /* test if it already exists to avoid loosing precious files */
3430 if (!file_overwrite &&
3431 (strchr(filename, ':') == NULL ||
3432 strstart(filename, "file:", NULL))) {
3433 if (url_exist(filename)) {
3434 int c;
3435
3436 if ( !using_stdin ) {
3437 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3438 fflush(stderr);
3439 c = getchar();
3440 if (toupper(c) != 'Y') {
3441 fprintf(stderr, "Not overwriting - exiting\n");
3442 exit(1);
3443 }
3444 }
3445 else {
3446 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3447 exit(1);
3448 }
3449 }
3450 }
3451
3452 /* open the file */
3453 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3454 fprintf(stderr, "Could not open '%s'\n", filename);
3455 exit(1);
3456 }
3457 }
3458
3459 memset(ap, 0, sizeof(*ap));
3460 ap->image_format = image_format;
3461 if (av_set_parameters(oc, ap) < 0) {
3462 fprintf(stderr, "%s: Invalid encoding parameters\n",
3463 oc->filename);
3464 exit(1);
3465 }
3466
3467 oc->packet_size= mux_packet_size;
3468 oc->mux_rate= mux_rate;
3469 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3470 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3471 oc->loop_output = loop_output;
3472
3473 /* reset some options */
3474 file_oformat = NULL;
3475 file_iformat = NULL;
3476 image_format = NULL;
3477}
3478
3479/* prepare dummy protocols for grab */
3480static void prepare_grab(void)
3481{
3482 int has_video, has_audio, i, j;
3483 AVFormatContext *oc;
3484 AVFormatContext *ic;
3485 AVFormatParameters vp1, *vp = &vp1;
3486 AVFormatParameters ap1, *ap = &ap1;
3487
3488 /* see if audio/video inputs are needed */
3489 has_video = 0;
3490 has_audio = 0;
3491 memset(ap, 0, sizeof(*ap));
3492 memset(vp, 0, sizeof(*vp));
3493 vp->time_base.num= 1;
3494 for(j=0;j<nb_output_files;j++) {
3495 oc = output_files[j];
3496 for(i=0;i<oc->nb_streams;i++) {
3497 AVCodecContext *enc = oc->streams[i]->codec;
3498 switch(enc->codec_type) {
3499 case CODEC_TYPE_AUDIO:
3500 if (enc->sample_rate > ap->sample_rate)
3501 ap->sample_rate = enc->sample_rate;
3502 if (enc->channels > ap->channels)
3503 ap->channels = enc->channels;
3504 has_audio = 1;
3505 break;
3506 case CODEC_TYPE_VIDEO:
3507 if (enc->width > vp->width)
3508 vp->width = enc->width;
3509 if (enc->height > vp->height)
3510 vp->height = enc->height;
3511
3512 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3513 vp->time_base = enc->time_base;
3514 vp->width += frame_leftBand + frame_rightBand;
3515 vp->width -= (frame_padleft + frame_padright);
3516 vp->height += frame_topBand + frame_bottomBand;
3517 vp->height -= (frame_padtop + frame_padbottom);
3518 }
3519 has_video = 1;
3520 break;
3521 default:
3522 av_abort();
3523 }
3524 }
3525 }
3526
3527 if (has_video == 0 && has_audio == 0) {
3528 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3529 exit(1);
3530 }
3531
3532 if (has_video) {
3533 AVInputFormat *fmt1;
3534 fmt1 = av_find_input_format(video_grab_format);
3535 vp->device = video_device;
3536 vp->channel = video_channel;
3537 vp->standard = video_standard;
3538 vp->pix_fmt = frame_pix_fmt;
3539 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3540 fprintf(stderr, "Could not find video grab device\n");
3541 exit(1);
3542 }
3543 /* If not enough info to get the stream parameters, we decode the
3544 first frames to get it. */
3545 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3546 fprintf(stderr, "Could not find video grab parameters\n");
3547 exit(1);
3548 }
3549 /* by now video grab has one stream */
3550 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3551 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3552 input_files[nb_input_files] = ic;
3553
3554 if (verbose >= 0)
3555 dump_format(ic, nb_input_files, "", 0);
3556
3557 nb_input_files++;
3558 }
3559 if (has_audio && audio_grab_format) {
3560 AVInputFormat *fmt1;
3561 fmt1 = av_find_input_format(audio_grab_format);
3562 ap->device = audio_device;
3563 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3564 fprintf(stderr, "Could not find audio grab device\n");
3565 exit(1);
3566 }
3567 input_files[nb_input_files] = ic;
3568
3569 if (verbose >= 0)
3570 dump_format(ic, nb_input_files, "", 0);
3571
3572 nb_input_files++;
3573 }
3574}
3575
3576/* same option as mencoder */
3577static void opt_pass(const char *pass_str)
3578{
3579 int pass;
3580 pass = atoi(pass_str);
3581 if (pass != 1 && pass != 2) {
3582 fprintf(stderr, "pass number can be only 1 or 2\n");
3583 exit(1);
3584 }
3585 do_pass = pass;
3586}
3587
3588#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3589static int64_t getutime(void)
3590{
3591 return av_gettime();
3592}
3593#else
3594static int64_t getutime(void)
3595{
3596 struct rusage rusage;
3597
3598 getrusage(RUSAGE_SELF, &rusage);
3599 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3600}
3601#endif
3602
3603extern int ffm_nopts;
3604
3605static void show_formats(void)
3606{
3607 AVInputFormat *ifmt;
3608 AVOutputFormat *ofmt;
3609 AVImageFormat *image_fmt;
3610 URLProtocol *up;
3611 AVCodec *p, *p2;
3612 const char **pp, *last_name;
3613
3614 printf("File formats:\n");
3615 last_name= "000";
3616 for(;;){
3617 int decode=0;
3618 int encode=0;
3619 const char *name=NULL;
3620 const char *long_name=NULL;
3621
3622 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3623 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3624 strcmp(ofmt->name, last_name)>0){
3625 name= ofmt->name;
3626 long_name= ofmt->long_name;
3627 encode=1;
3628 }
3629 }
3630 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3631 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3632 strcmp(ifmt->name, last_name)>0){
3633 name= ifmt->name;
3634 long_name= ifmt->long_name;
3635 encode=0;
3636 }
3637 if(name && strcmp(ifmt->name, name)==0)
3638 decode=1;
3639 }
3640 if(name==NULL)
3641 break;
3642 last_name= name;
3643
3644 printf(
3645 " %s%s %-15s %s\n",
3646 decode ? "D":" ",
3647 encode ? "E":" ",
3648 name,
3649 long_name ? long_name:" ");
3650 }
3651 printf("\n");
3652
3653 printf("Image formats (filename extensions, if any, follow):\n");
3654 for(image_fmt = first_image_format; image_fmt != NULL;
3655 image_fmt = image_fmt->next) {
3656 printf(
3657 " %s%s %-6s %s\n",
3658 image_fmt->img_read ? "D":" ",
3659 image_fmt->img_write ? "E":" ",
3660 image_fmt->name,
3661 image_fmt->extensions ? image_fmt->extensions:" ");
3662 }
3663 printf("\n");
3664
3665 printf("Codecs:\n");
3666 last_name= "000";
3667 for(;;){
3668 int decode=0;
3669 int encode=0;
3670 int cap=0;
3671 const char *type_str;
3672
3673 p2=NULL;
3674 for(p = first_avcodec; p != NULL; p = p->next) {
3675 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3676 strcmp(p->name, last_name)>0){
3677 p2= p;
3678 decode= encode= cap=0;
3679 }
3680 if(p2 && strcmp(p->name, p2->name)==0){
3681 if(p->decode) decode=1;
3682 if(p->encode) encode=1;
3683 cap |= p->capabilities;
3684 }
3685 }
3686 if(p2==NULL)
3687 break;
3688 last_name= p2->name;
3689
3690 switch(p2->type) {
3691 case CODEC_TYPE_VIDEO:
3692 type_str = "V";
3693 break;
3694 case CODEC_TYPE_AUDIO:
3695 type_str = "A";
3696 break;
3697 case CODEC_TYPE_SUBTITLE:
3698 type_str = "S";
3699 break;
3700 default:
3701 type_str = "?";
3702 break;
3703 }
3704 printf(
3705 " %s%s%s%s%s%s %s",
3706 decode ? "D": (/*p2->decoder ? "d":*/" "),
3707 encode ? "E":" ",
3708 type_str,
3709 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3710 cap & CODEC_CAP_DR1 ? "D":" ",
3711 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3712 p2->name);
3713 /* if(p2->decoder && decode==0)
3714 printf(" use %s for decoding", p2->decoder->name);*/
3715 printf("\n");
3716 }
3717 printf("\n");
3718
3719 printf("Supported file protocols:\n");
3720 for(up = first_protocol; up != NULL; up = up->next)
3721 printf(" %s:", up->name);
3722 printf("\n");
3723
3724 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3725 printf("Motion estimation methods:\n");
3726 pp = motion_str;
3727 while (*pp) {
3728 printf(" %s", *pp);
3729 if ((pp - motion_str + 1) == ME_ZERO)
3730 printf("(fastest)");
3731 else if ((pp - motion_str + 1) == ME_FULL)
3732 printf("(slowest)");
3733 else if ((pp - motion_str + 1) == ME_EPZS)
3734 printf("(default)");
3735 pp++;
3736 }
3737 printf("\n\n");
3738 printf(
3739"Note, the names of encoders and decoders dont always match, so there are\n"
3740"several cases where the above table shows encoder only or decoder only entries\n"
3741"even though both encoding and decoding are supported for example, the h263\n"
3742"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3743"worse\n");
3744 exit(1);
3745}
3746
3747static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3748{
3749 int i;
3750 const char *p = str;
3751 for(i = 0;; i++) {
3752 dest[i] = atoi(p);
3753 if(i == 63)
3754 break;
3755 p = strchr(p, ',');
3756 if(!p) {
3757 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3758 exit(1);
3759 }
3760 p++;
3761 }
3762}
3763
3764static void opt_inter_matrix(const char *arg)
3765{
3766 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3767 parse_matrix_coeffs(inter_matrix, arg);
3768}
3769
3770static void opt_intra_matrix(const char *arg)
3771{
3772 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3773 parse_matrix_coeffs(intra_matrix, arg);
3774}
3775
3776static void opt_target(const char *arg)
3777{
3778 int norm = -1;
3779 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3780
3781 if(!strncmp(arg, "pal-", 4)) {
3782 norm = 0;
3783 arg += 4;
3784 } else if(!strncmp(arg, "ntsc-", 5)) {
3785 norm = 1;
3786 arg += 5;
3787 } else if(!strncmp(arg, "film-", 5)) {
3788 norm = 2;
3789 arg += 5;
3790 } else {
3791 int fr;
3792 /* Calculate FR via float to avoid int overflow */
3793 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3794 if(fr == 25000) {
3795 norm = 0;
3796 } else if((fr == 29970) || (fr == 23976)) {
3797 norm = 1;
3798 } else {
3799 /* Try to determine PAL/NTSC by peeking in the input files */
3800 if(nb_input_files) {
3801 int i, j;
3802 for(j = 0; j < nb_input_files; j++) {
3803 for(i = 0; i < input_files[j]->nb_streams; i++) {
3804 AVCodecContext *c = input_files[j]->streams[i]->codec;
3805 if(c->codec_type != CODEC_TYPE_VIDEO)
3806 continue;
3807 fr = c->time_base.den * 1000 / c->time_base.num;
3808 if(fr == 25000) {
3809 norm = 0;
3810 break;
3811 } else if((fr == 29970) || (fr == 23976)) {
3812 norm = 1;
3813 break;
3814 }
3815 }
3816 if(norm >= 0)
3817 break;
3818 }
3819 }
3820 }
3821 if(verbose && norm >= 0)
3822 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3823 }
3824
3825 if(norm < 0) {
3826 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3827 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3828 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3829 exit(1);
3830 }
3831
3832 if(!strcmp(arg, "vcd")) {
3833
3834 opt_video_codec("mpeg1video");
3835 opt_audio_codec("mp2");
3836 opt_format("vcd");
3837
3838 opt_frame_size(norm ? "352x240" : "352x288");
3839 opt_frame_rate(frame_rates[norm]);
3840 opt_gop_size(norm ? "18" : "15");
3841
3842 video_bit_rate = 1150000;
3843 video_rc_max_rate = 1150000;
3844 video_rc_min_rate = 1150000;
3845 video_rc_buffer_size = 40*1024*8;
3846
3847 audio_bit_rate = 224000;
3848 audio_sample_rate = 44100;
3849
3850 mux_packet_size= 2324;
3851 mux_rate= 2352 * 75 * 8;
3852
3853 /* We have to offset the PTS, so that it is consistent with the SCR.
3854 SCR starts at 36000, but the first two packs contain only padding
3855 and the first pack from the other stream, respectively, may also have
3856 been written before.
3857 So the real data starts at SCR 36000+3*1200. */
3858 mux_preload= (36000+3*1200) / 90000.0; //0.44
3859 } else if(!strcmp(arg, "svcd")) {
3860
3861 opt_video_codec("mpeg2video");
3862 opt_audio_codec("mp2");
3863 opt_format("svcd");
3864
3865 opt_frame_size(norm ? "480x480" : "480x576");
3866 opt_frame_rate(frame_rates[norm]);
3867 opt_gop_size(norm ? "18" : "15");
3868
3869 video_bit_rate = 2040000;
3870 video_rc_max_rate = 2516000;
3871 video_rc_min_rate = 0; //1145000;
3872 video_rc_buffer_size = 224*1024*8;
3873 opt_default("flags", "+SCAN_OFFSET");
3874
3875
3876 audio_bit_rate = 224000;
3877 audio_sample_rate = 44100;
3878
3879 mux_packet_size= 2324;
3880
3881 } else if(!strcmp(arg, "dvd")) {
3882
3883 opt_video_codec("mpeg2video");
3884 opt_audio_codec("ac3");
3885 opt_format("dvd");
3886
3887 opt_frame_size(norm ? "720x480" : "720x576");
3888 opt_frame_rate(frame_rates[norm]);
3889 opt_gop_size(norm ? "18" : "15");
3890
3891 video_bit_rate = 6000000;
3892 video_rc_max_rate = 9000000;
3893 video_rc_min_rate = 0; //1500000;
3894 video_rc_buffer_size = 224*1024*8;
3895
3896 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3897 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3898
3899 audio_bit_rate = 448000;
3900 audio_sample_rate = 48000;
3901
3902 } else if(!strncmp(arg, "dv", 2)) {
3903
3904 opt_format("dv");
3905
3906 opt_frame_size(norm ? "720x480" : "720x576");
3907 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3908 (norm ? "yuv411p" : "yuv420p"));
3909 opt_frame_rate(frame_rates[norm]);
3910
3911 audio_sample_rate = 48000;
3912 audio_channels = 2;
3913
3914 } else {
3915 fprintf(stderr, "Unknown target: %s\n", arg);
3916 exit(1);
3917 }
3918}
3919
3920static void opt_video_bsf(const char *arg)
3921{
3922 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3923 AVBitStreamFilterContext **bsfp;
3924
3925 if(!bsfc){
3926 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3927 exit(1);
3928 }
3929
3930 bsfp= &video_bitstream_filters;
3931 while(*bsfp)
3932 bsfp= &(*bsfp)->next;
3933
3934 *bsfp= bsfc;
3935}
3936
3937//FIXME avoid audio - video code duplication
3938static void opt_audio_bsf(const char *arg)
3939{
3940 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3941 AVBitStreamFilterContext **bsfp;
3942
3943 if(!bsfc){
3944 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3945 exit(1);
3946 }
3947
3948 bsfp= &audio_bitstream_filters;
3949 while(*bsfp)
3950 bsfp= &(*bsfp)->next;
3951
3952 *bsfp= bsfc;
3953}
3954
3955static void show_version(void)
3956{
3957 /* TODO: add function interface to avutil and avformat */
3958 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3959 "libavutil %d\n"
3960 "libavcodec %d\n"
3961 "libavformat %d\n",
3962 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3963 exit(1);
3964}
3965
3966static int opt_default(const char *opt, const char *arg){
3967 AVOption *o= av_set_string(avctx_opts, opt, arg);
3968 if(!o)
3969 return -1;
3970
3971// av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
3972
3973 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3974 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3975 opt_names[opt_name_count++]= o->name;
3976
3977 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3978 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3979 ffm_nopts = 1;
3980
3981 if(avctx_opts->debug)
3982 av_log_set_level(AV_LOG_DEBUG);
3983 return 0;
3984}
3985
3986const OptionDef options[] = {
3987 /* main options */
3988 { "L", 0, {(void*)show_license}, "show license" },
3989 { "h", 0, {(void*)show_help}, "show help" },
3990 { "version", 0, {(void*)show_version}, "show version" },
3991 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3992 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3993 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3994 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3995 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3996 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3997 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3998 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3999 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4000 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4001 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4002 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4003 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4004 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4005 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4006 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4007 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4008 "add timings for benchmarking" },
4009 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4010 "dump each input packet" },
4011 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4012 "when dumping packets, also dump the payload" },
4013 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4014 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4015 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4016 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4017 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4018 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4019 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4020 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4021 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4022 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4023 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4024 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
4025
4026 /* video options */
4027 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4028 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4029 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4030 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4031 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4032 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4033 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4034 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4035 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4036 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4037 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4038 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4039 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4040 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4041 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4042 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4043 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4044 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4045 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4046 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4047 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4048 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4049 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4050 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4051 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4052 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4053 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4054 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4055 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4056 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4057 { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
4058 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4059 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4060 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4061 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4062 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4063 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4064 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4065 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4066 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4067 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4068 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4069 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4070 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4071 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4072 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4073 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4074 "method" },
4075 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
4076 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
4077 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4078 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4079 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4080 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4081 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4082 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4083 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4084 "use same video quality as source (implies VBR)" },
4085 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4086 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4087 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4088 "deinterlace pictures" },
4089 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4090 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4091 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4092 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4093 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4094 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4095 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4096 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4097 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4098 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4099 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4100 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4101 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4102 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4103 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4104 { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
4105 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4106
4107 /* audio options */
4108 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4109 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4110 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4111 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4112 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4113 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4114 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4115 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4116 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4117 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4118
4119 /* subtitle options */
4120 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4121 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4122 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4123
4124 /* grab options */
4125 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4126 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4127 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4128 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4129
4130 /* G.2 grab options */
4131 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4132 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4133
4134 /* muxer options */
4135 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4136 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4137 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4138 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4139
4140 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
4141 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
4142
4143 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4144 { NULL, },
4145};
4146
4147static void show_banner(void)
4148{
4149 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4150 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
4151 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4152 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4153 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4154 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4155#ifdef __GNUC__
4156 fprintf(stderr, ", gcc: " __VERSION__ "\n");
4157#else
4158 fprintf(stderr, ", using a non-gcc compiler\n");
4159#endif
4160}
4161
4162static void show_license(void)
4163{
4164 show_banner();
4165 printf(
4166 "This library is free software; you can redistribute it and/or\n"
4167 "modify it under the terms of the GNU Lesser General Public\n"
4168 "License as published by the Free Software Foundation; either\n"
4169 "version 2 of the License, or (at your option) any later version.\n"
4170 "\n"
4171 "This library is distributed in the hope that it will be useful,\n"
4172 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4173 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4174 "Lesser General Public License for more details.\n"
4175 "\n"
4176 "You should have received a copy of the GNU Lesser General Public\n"
4177 "License along with this library; if not, write to the Free Software\n"
4178 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4179 );
4180 exit(1);
4181}
4182
4183static void show_help(void)
4184{
4185 show_banner();
4186 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4187 "Hyper fast Audio and Video encoder\n");
4188 printf("\n");
4189 show_help_options(options, "Main options:\n",
4190 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4191 show_help_options(options, "\nVideo options:\n",
4192 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4193 OPT_VIDEO);
4194 show_help_options(options, "\nAdvanced Video options:\n",
4195 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4196 OPT_VIDEO | OPT_EXPERT);
4197 show_help_options(options, "\nAudio options:\n",
4198 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4199 OPT_AUDIO);
4200 show_help_options(options, "\nAdvanced Audio options:\n",
4201 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4202 OPT_AUDIO | OPT_EXPERT);
4203 show_help_options(options, "\nSubtitle options:\n",
4204 OPT_SUBTITLE | OPT_GRAB,
4205 OPT_SUBTITLE);
4206 show_help_options(options, "\nAudio/Video grab options:\n",
4207 OPT_GRAB,
4208 OPT_GRAB);
4209 show_help_options(options, "\nAdvanced options:\n",
4210 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4211 OPT_EXPERT);
4212 av_opt_show(avctx_opts, NULL);
4213
4214 exit(1);
4215}
4216
4217void parse_arg_file(const char *filename)
4218{
4219 opt_output_file(filename);
4220}
4221
4222int main(int argc, char **argv)
4223{
4224 int i;
4225 int64_t ti;
4226
4227 av_register_all();
4228
4229 avctx_opts= avcodec_alloc_context();
4230
4231 if (argc <= 1)
4232 show_help();
4233 else
4234 show_banner();
4235
4236 /* parse options */
4237 parse_options(argc, argv, options);
4238
4239 /* file converter / grab */
4240 if (nb_output_files <= 0) {
4241 fprintf(stderr, "Must supply at least one output file\n");
4242 exit(1);
4243 }
4244
4245 if (nb_input_files == 0) {
4246 input_sync = 1;
4247 prepare_grab();
4248 }
4249
4250 ti = getutime();
4251 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4252 stream_maps, nb_stream_maps);
4253 ti = getutime() - ti;
4254 if (do_benchmark) {
4255 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4256 }
4257
4258 /* close files */
4259 for(i=0;i<nb_output_files;i++) {
4260 /* maybe av_close_output_file ??? */
4261 AVFormatContext *s = output_files[i];
4262 int j;
4263 if (!(s->oformat->flags & AVFMT_NOFILE))
4264 url_fclose(&s->pb);
4265 for(j=0;j<s->nb_streams;j++)
4266 av_free(s->streams[j]);
4267 av_free(s);
4268 }
4269 for(i=0;i<nb_input_files;i++)
4270 av_close_input_file(input_files[i]);
4271
4272 av_free_static();
4273
4274 if(intra_matrix)
4275 av_free(intra_matrix);
4276 if(inter_matrix)
4277 av_free(inter_matrix);
4278
4279#ifdef POWERPC_PERFORMANCE_REPORT
4280 extern void powerpc_display_perf_report(void);
4281 powerpc_display_perf_report();
4282#endif /* POWERPC_PERFORMANCE_REPORT */
4283
4284#ifndef CONFIG_WIN32
4285 if (received_sigterm) {
4286 fprintf(stderr,
4287 "Received signal %d: terminating.\n",
4288 (int) received_sigterm);
4289 exit (255);
4290 }
4291#endif
4292 exit(0); /* not all OS-es handle main() return value */
4293 return 0;
4294}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette