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