?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dvdsubdec: allow compilation with -DDEBUG
[FFMpeg-mirror/ffmpeg-vdpau.git] / ffmpeg.c
blob48ce906ad411a93c0bc8ef0a204383c373e7e091
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 int nb_input_files = 0;
89
90 static AVFormatContext *output_files[MAX_FILES];
91 static int nb_output_files = 0;
92
93 static AVStreamMap stream_maps[MAX_FILES];
94 static int nb_stream_maps;
95
96 static AVMetaDataMap meta_data_maps[MAX_FILES];
97 static int nb_meta_data_maps;
98
99 static AVInputFormat *file_iformat;
100 static AVOutputFormat *file_oformat;
101 static int frame_width = 0;
102 static int frame_height = 0;
103 static float frame_aspect_ratio = 0;
104 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
105 static int frame_padtop = 0;
106 static int frame_padbottom = 0;
107 static int frame_padleft = 0;
108 static int frame_padright = 0;
109 static int padcolor[3] = {16,128,128}; /* default to black */
110 static int frame_topBand = 0;
111 static int frame_bottomBand = 0;
112 static int frame_leftBand = 0;
113 static int frame_rightBand = 0;
114 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
115 static AVRational frame_rate = (AVRational) {0,0};
116 static float video_qscale = 0;
117 static uint16_t *intra_matrix = NULL;
118 static uint16_t *inter_matrix = NULL;
119 #if 0 //experimental, (can be removed)
120 static float video_rc_qsquish=1.0;
121 static float video_rc_qmod_amp=0;
122 static int video_rc_qmod_freq=0;
123 #endif
124 static const char *video_rc_override_string=NULL;
125 static int video_disable = 0;
126 static int video_discard = 0;
127 static char *video_codec_name = NULL;
128 static int video_codec_tag = 0;
129 static int same_quality = 0;
130 static int do_deinterlace = 0;
131 static int strict = 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 = 0;
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 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
931 // enc->frame_number-1, enc->real_pict_num, ret,
932 // enc->pict_type);
933 /* if two pass, output log */
934 if (ost->logfile && enc->stats_out) {
935 fprintf(ost->logfile, "%s", enc->stats_out);
936 }
937 }
938 }
939 ost->sync_opts++;
940 ost->frame_number++;
941 }
942 }
943
944 static double psnr(double d){
945 return -10.0*log(d)/log(10.0);
946 }
947
948 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
949 int frame_size)
950 {
951 AVCodecContext *enc;
952 int frame_number;
953 double ti1, bitrate, avg_bitrate;
954
955 /* this is executed just the first time do_video_stats is called */
956 if (!vstats_file) {
957 vstats_file = fopen(vstats_filename, "w");
958 if (!vstats_file) {
959 perror("fopen");
960 av_exit(1);
961 }
962 }
963
964 enc = ost->st->codec;
965 if (enc->codec_type == CODEC_TYPE_VIDEO) {
966 frame_number = ost->frame_number;
967 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
968 if (enc->flags&CODEC_FLAG_PSNR)
969 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
970
971 fprintf(vstats_file,"f_size= %6d ", frame_size);
972 /* compute pts value */
973 ti1 = ost->sync_opts * av_q2d(enc->time_base);
974 if (ti1 < 0.01)
975 ti1 = 0.01;
976
977 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
978 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
979 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
980 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
981 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
982 }
983 }
984
985 static void print_report(AVFormatContext **output_files,
986 AVOutputStream **ost_table, int nb_ostreams,
987 int is_last_report)
988 {
989 char buf[1024];
990 AVOutputStream *ost;
991 AVFormatContext *oc, *os;
992 int64_t total_size;
993 AVCodecContext *enc;
994 int frame_number, vid, i;
995 double bitrate, ti1, pts;
996 static int64_t last_time = -1;
997 static int qp_histogram[52];
998
999 if (!is_last_report) {
1000 int64_t cur_time;
1001 /* display the report every 0.5 seconds */
1002 cur_time = av_gettime();
1003 if (last_time == -1) {
1004 last_time = cur_time;
1005 return;
1006 }
1007 if ((cur_time - last_time) < 500000)
1008 return;
1009 last_time = cur_time;
1010 }
1011
1012
1013 oc = output_files[0];
1014
1015 total_size = url_fsize(oc->pb);
1016 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1017 total_size= url_ftell(oc->pb);
1018
1019 buf[0] = '\0';
1020 ti1 = 1e10;
1021 vid = 0;
1022 for(i=0;i<nb_ostreams;i++) {
1023 ost = ost_table[i];
1024 os = output_files[ost->file_index];
1025 enc = ost->st->codec;
1026 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1027 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1028 !ost->st->stream_copy ?
1029 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1030 }
1031 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1032 float t = (av_gettime()-timer_start) / 1000000.0;
1033
1034 frame_number = ost->frame_number;
1035 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1036 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1037 !ost->st->stream_copy ?
1038 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1039 if(is_last_report)
1040 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1041 if(qp_hist){
1042 int j;
1043 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1044 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1045 qp_histogram[qp]++;
1046 for(j=0; j<32; j++)
1047 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1048 }
1049 if (enc->flags&CODEC_FLAG_PSNR){
1050 int j;
1051 double error, error_sum=0;
1052 double scale, scale_sum=0;
1053 char type[3]= {'Y','U','V'};
1054 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1055 for(j=0; j<3; j++){
1056 if(is_last_report){
1057 error= enc->error[j];
1058 scale= enc->width*enc->height*255.0*255.0*frame_number;
1059 }else{
1060 error= enc->coded_frame->error[j];
1061 scale= enc->width*enc->height*255.0*255.0;
1062 }
1063 if(j) scale/=4;
1064 error_sum += error;
1065 scale_sum += scale;
1066 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1067 }
1068 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1069 }
1070 vid = 1;
1071 }
1072 /* compute min output value */
1073 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1074 if ((pts < ti1) && (pts > 0))
1075 ti1 = pts;
1076 }
1077 if (ti1 < 0.01)
1078 ti1 = 0.01;
1079
1080 if (verbose || is_last_report) {
1081 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1082
1083 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1084 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1085 (double)total_size / 1024, ti1, bitrate);
1086
1087 if (verbose > 1)
1088 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1089 nb_frames_dup, nb_frames_drop);
1090
1091 if (verbose >= 0)
1092 fprintf(stderr, "%s \r", buf);
1093
1094 fflush(stderr);
1095 }
1096
1097 if (is_last_report && verbose >= 0){
1098 int64_t raw= audio_size + video_size + extra_size;
1099 fprintf(stderr, "\n");
1100 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1101 video_size/1024.0,
1102 audio_size/1024.0,
1103 extra_size/1024.0,
1104 100.0*(total_size - raw)/raw
1105 );
1106 }
1107 }
1108
1109 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1110 static int output_packet(AVInputStream *ist, int ist_index,
1111 AVOutputStream **ost_table, int nb_ostreams,
1112 const AVPacket *pkt)
1113 {
1114 AVFormatContext *os;
1115 AVOutputStream *ost;
1116 uint8_t *ptr;
1117 int len, ret, i;
1118 uint8_t *data_buf;
1119 int data_size, got_picture;
1120 AVFrame picture;
1121 void *buffer_to_free;
1122 static unsigned int samples_size= 0;
1123 static short *samples= NULL;
1124 AVSubtitle subtitle, *subtitle_to_free;
1125 int got_subtitle;
1126
1127 if(ist->next_pts == AV_NOPTS_VALUE)
1128 ist->next_pts= ist->pts;
1129
1130 if (pkt == NULL) {
1131 /* EOF handling */
1132 ptr = NULL;
1133 len = 0;
1134 goto handle_eof;
1135 }
1136
1137 if(pkt->dts != AV_NOPTS_VALUE)
1138 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1139
1140 len = pkt->size;
1141 ptr = pkt->data;
1142 while (len > 0) {
1143 handle_eof:
1144 ist->pts= ist->next_pts;
1145
1146 if(len && len != pkt->size && verbose>0)
1147 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1148
1149 /* decode the packet if needed */
1150 data_buf = NULL; /* fail safe */
1151 data_size = 0;
1152 subtitle_to_free = NULL;
1153 if (ist->decoding_needed) {
1154 switch(ist->st->codec->codec_type) {
1155 case CODEC_TYPE_AUDIO:{
1156 if(pkt)
1157 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1158 data_size= samples_size;
1159 /* XXX: could avoid copy if PCM 16 bits with same
1160 endianness as CPU */
1161 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1162 ptr, len);
1163 if (ret < 0)
1164 goto fail_decode;
1165 ptr += ret;
1166 len -= ret;
1167 /* Some bug in mpeg audio decoder gives */
1168 /* data_size < 0, it seems they are overflows */
1169 if (data_size <= 0) {
1170 /* no audio frame */
1171 continue;
1172 }
1173 data_buf = (uint8_t *)samples;
1174 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1175 (ist->st->codec->sample_rate * ist->st->codec->channels);
1176 break;}
1177 case CODEC_TYPE_VIDEO:
1178 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1179 /* XXX: allocate picture correctly */
1180 avcodec_get_frame_defaults(&picture);
1181
1182 ret = avcodec_decode_video(ist->st->codec,
1183 &picture, &got_picture, ptr, len);
1184 ist->st->quality= picture.quality;
1185 if (ret < 0)
1186 goto fail_decode;
1187 if (!got_picture) {
1188 /* no picture yet */
1189 goto discard_packet;
1190 }
1191 if (ist->st->codec->time_base.num != 0) {
1192 ist->next_pts += ((int64_t)AV_TIME_BASE *
1193 ist->st->codec->time_base.num) /
1194 ist->st->codec->time_base.den;
1195 }
1196 len = 0;
1197 break;
1198 case CODEC_TYPE_SUBTITLE:
1199 ret = avcodec_decode_subtitle(ist->st->codec,
1200 &subtitle, &got_subtitle, ptr, len);
1201 if (ret < 0)
1202 goto fail_decode;
1203 if (!got_subtitle) {
1204 goto discard_packet;
1205 }
1206 subtitle_to_free = &subtitle;
1207 len = 0;
1208 break;
1209 default:
1210 goto fail_decode;
1211 }
1212 } else {
1213 switch(ist->st->codec->codec_type) {
1214 case CODEC_TYPE_AUDIO:
1215 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1216 ist->st->codec->sample_rate;
1217 break;
1218 case CODEC_TYPE_VIDEO:
1219 if (ist->st->codec->time_base.num != 0) {
1220 ist->next_pts += ((int64_t)AV_TIME_BASE *
1221 ist->st->codec->time_base.num) /
1222 ist->st->codec->time_base.den;
1223 }
1224 break;
1225 }
1226 data_buf = ptr;
1227 data_size = len;
1228 ret = len;
1229 len = 0;
1230 }
1231
1232 buffer_to_free = NULL;
1233 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1234 pre_process_video_frame(ist, (AVPicture *)&picture,
1235 &buffer_to_free);
1236 }
1237
1238 // preprocess audio (volume)
1239 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1240 if (audio_volume != 256) {
1241 short *volp;
1242 volp = samples;
1243 for(i=0;i<(data_size / sizeof(short));i++) {
1244 int v = ((*volp) * audio_volume + 128) >> 8;
1245 if (v < -32768) v = -32768;
1246 if (v > 32767) v = 32767;
1247 *volp++ = v;
1248 }
1249 }
1250 }
1251
1252 /* frame rate emulation */
1253 if (ist->st->codec->rate_emu) {
1254 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1255 int64_t now = av_gettime() - ist->start;
1256 if (pts > now)
1257 usleep(pts - now);
1258
1259 ist->frame++;
1260 }
1261
1262 #if 0
1263 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1264 is the one of the next displayed one */
1265 /* XXX: add mpeg4 too ? */
1266 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1267 if (ist->st->codec->pict_type != B_TYPE) {
1268 int64_t tmp;
1269 tmp = ist->last_ip_pts;
1270 ist->last_ip_pts = ist->frac_pts.val;
1271 ist->frac_pts.val = tmp;
1272 }
1273 }
1274 #endif
1275 /* if output time reached then transcode raw format,
1276 encode packets and output them */
1277 if (start_time == 0 || ist->pts >= start_time)
1278 for(i=0;i<nb_ostreams;i++) {
1279 int frame_size;
1280
1281 ost = ost_table[i];
1282 if (ost->source_index == ist_index) {
1283 os = output_files[ost->file_index];
1284
1285 #if 0
1286 printf("%d: got pts=%0.3f %0.3f\n", i,
1287 (double)pkt->pts / AV_TIME_BASE,
1288 ((double)ist->pts / AV_TIME_BASE) -
1289 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1290 #endif
1291 /* set the input output pts pairs */
1292 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1293
1294 if (ost->encoding_needed) {
1295 switch(ost->st->codec->codec_type) {
1296 case CODEC_TYPE_AUDIO:
1297 do_audio_out(os, ost, ist, data_buf, data_size);
1298 break;
1299 case CODEC_TYPE_VIDEO:
1300 do_video_out(os, ost, ist, &picture, &frame_size);
1301 video_size += frame_size;
1302 if (vstats_filename && frame_size)
1303 do_video_stats(os, ost, frame_size);
1304 break;
1305 case CODEC_TYPE_SUBTITLE:
1306 do_subtitle_out(os, ost, ist, &subtitle,
1307 pkt->pts);
1308 break;
1309 default:
1310 abort();
1311 }
1312 } else {
1313 AVFrame avframe; //FIXME/XXX remove this
1314 AVPacket opkt;
1315 av_init_packet(&opkt);
1316
1317 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1318 continue;
1319
1320 /* no reencoding needed : output the packet directly */
1321 /* force the input stream PTS */
1322
1323 avcodec_get_frame_defaults(&avframe);
1324 ost->st->codec->coded_frame= &avframe;
1325 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1326
1327 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1328 audio_size += data_size;
1329 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1330 video_size += data_size;
1331 ost->sync_opts++;
1332 }
1333
1334 opkt.stream_index= ost->index;
1335 if(pkt->pts != AV_NOPTS_VALUE)
1336 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1337 else
1338 opkt.pts= AV_NOPTS_VALUE;
1339
1340 if (pkt->dts == AV_NOPTS_VALUE)
1341 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1342 else
1343 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1344
1345 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1346 opkt.flags= pkt->flags;
1347
1348 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1349 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1350 opkt.destruct= av_destruct_packet;
1351
1352 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1353 ost->st->codec->frame_number++;
1354 ost->frame_number++;
1355 av_free_packet(&opkt);
1356 }
1357 }
1358 }
1359 av_free(buffer_to_free);
1360 /* XXX: allocate the subtitles in the codec ? */
1361 if (subtitle_to_free) {
1362 if (subtitle_to_free->rects != NULL) {
1363 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1364 av_free(subtitle_to_free->rects[i].bitmap);
1365 av_free(subtitle_to_free->rects[i].rgba_palette);
1366 }
1367 av_freep(&subtitle_to_free->rects);
1368 }
1369 subtitle_to_free->num_rects = 0;
1370 subtitle_to_free = NULL;
1371 }
1372 }
1373 discard_packet:
1374 if (pkt == NULL) {
1375 /* EOF handling */
1376
1377 for(i=0;i<nb_ostreams;i++) {
1378 ost = ost_table[i];
1379 if (ost->source_index == ist_index) {
1380 AVCodecContext *enc= ost->st->codec;
1381 os = output_files[ost->file_index];
1382
1383 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1384 continue;
1385 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1386 continue;
1387
1388 if (ost->encoding_needed) {
1389 for(;;) {
1390 AVPacket pkt;
1391 int fifo_bytes;
1392 av_init_packet(&pkt);
1393 pkt.stream_index= ost->index;
1394
1395 switch(ost->st->codec->codec_type) {
1396 case CODEC_TYPE_AUDIO:
1397 fifo_bytes = av_fifo_size(&ost->fifo);
1398 ret = 0;
1399 /* encode any samples remaining in fifo */
1400 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1401 int fs_tmp = enc->frame_size;
1402 enc->frame_size = fifo_bytes / (2 * enc->channels);
1403 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1404 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1405 enc->frame_size = fs_tmp;
1406 }
1407 if(ret <= 0) {
1408 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1409 }
1410 audio_size += ret;
1411 pkt.flags |= PKT_FLAG_KEY;
1412 break;
1413 case CODEC_TYPE_VIDEO:
1414 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1415 video_size += ret;
1416 if(enc->coded_frame && enc->coded_frame->key_frame)
1417 pkt.flags |= PKT_FLAG_KEY;
1418 if (ost->logfile && enc->stats_out) {
1419 fprintf(ost->logfile, "%s", enc->stats_out);
1420 }
1421 break;
1422 default:
1423 ret=-1;
1424 }
1425
1426 if(ret<=0)
1427 break;
1428 pkt.data= bit_buffer;
1429 pkt.size= ret;
1430 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1431 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1432 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1433 }
1434 }
1435 }
1436 }
1437 }
1438
1439 return 0;
1440 fail_decode:
1441 return -1;
1442 }
1443
1444 static void print_sdp(AVFormatContext **avc, int n)
1445 {
1446 char sdp[2048];
1447
1448 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1449 printf("SDP:\n%s\n", sdp);
1450 }
1451
1452 static int stream_index_from_inputs(AVFormatContext **input_files,
1453 int nb_input_files,
1454 AVInputFile *file_table,
1455 AVInputStream **ist_table,
1456 enum CodecType type,
1457 int programid)
1458 {
1459 int p, q, z;
1460 for(z=0; z<nb_input_files; z++) {
1461 AVFormatContext *ic = input_files[z];
1462 for(p=0; p<ic->nb_programs; p++) {
1463 AVProgram *program = ic->programs[p];
1464 if(program->id != programid)
1465 continue;
1466 for(q=0; q<program->nb_stream_indexes; q++) {
1467 int sidx = program->stream_index[q];
1468 int ris = file_table[z].ist_index + sidx;
1469 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1470 return ris;
1471 }
1472 }
1473 }
1474
1475 return -1;
1476 }
1477
1478 /*
1479 * The following code is the main loop of the file converter
1480 */
1481 static int av_encode(AVFormatContext **output_files,
1482 int nb_output_files,
1483 AVFormatContext **input_files,
1484 int nb_input_files,
1485 AVStreamMap *stream_maps, int nb_stream_maps)
1486 {
1487 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1488 AVFormatContext *is, *os;
1489 AVCodecContext *codec, *icodec;
1490 AVOutputStream *ost, **ost_table = NULL;
1491 AVInputStream *ist, **ist_table = NULL;
1492 AVInputFile *file_table;
1493 int key;
1494 int want_sdp = 1;
1495
1496 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1497 if (!file_table)
1498 goto fail;
1499
1500 /* input stream init */
1501 j = 0;
1502 for(i=0;i<nb_input_files;i++) {
1503 is = input_files[i];
1504 file_table[i].ist_index = j;
1505 file_table[i].nb_streams = is->nb_streams;
1506 j += is->nb_streams;
1507 }
1508 nb_istreams = j;
1509
1510 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1511 if (!ist_table)
1512 goto fail;
1513
1514 for(i=0;i<nb_istreams;i++) {
1515 ist = av_mallocz(sizeof(AVInputStream));
1516 if (!ist)
1517 goto fail;
1518 ist_table[i] = ist;
1519 }
1520 j = 0;
1521 for(i=0;i<nb_input_files;i++) {
1522 is = input_files[i];
1523 for(k=0;k<is->nb_streams;k++) {
1524 ist = ist_table[j++];
1525 ist->st = is->streams[k];
1526 ist->file_index = i;
1527 ist->index = k;
1528 ist->discard = 1; /* the stream is discarded by default
1529 (changed later) */
1530
1531 if (ist->st->codec->rate_emu) {
1532 ist->start = av_gettime();
1533 ist->frame = 0;
1534 }
1535 }
1536 }
1537
1538 /* output stream init */
1539 nb_ostreams = 0;
1540 for(i=0;i<nb_output_files;i++) {
1541 os = output_files[i];
1542 if (!os->nb_streams) {
1543 fprintf(stderr, "Output file does not contain any stream\n");
1544 av_exit(1);
1545 }
1546 nb_ostreams += os->nb_streams;
1547 }
1548 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1549 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1550 av_exit(1);
1551 }
1552
1553 /* Sanity check the mapping args -- do the input files & streams exist? */
1554 for(i=0;i<nb_stream_maps;i++) {
1555 int fi = stream_maps[i].file_index;
1556 int si = stream_maps[i].stream_index;
1557
1558 if (fi < 0 || fi > nb_input_files - 1 ||
1559 si < 0 || si > file_table[fi].nb_streams - 1) {
1560 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1561 av_exit(1);
1562 }
1563 fi = stream_maps[i].sync_file_index;
1564 si = stream_maps[i].sync_stream_index;
1565 if (fi < 0 || fi > nb_input_files - 1 ||
1566 si < 0 || si > file_table[fi].nb_streams - 1) {
1567 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1568 av_exit(1);
1569 }
1570 }
1571
1572 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1573 if (!ost_table)
1574 goto fail;
1575 for(i=0;i<nb_ostreams;i++) {
1576 ost = av_mallocz(sizeof(AVOutputStream));
1577 if (!ost)
1578 goto fail;
1579 ost_table[i] = ost;
1580 }
1581
1582 n = 0;
1583 for(k=0;k<nb_output_files;k++) {
1584 os = output_files[k];
1585 for(i=0;i<os->nb_streams;i++) {
1586 int found;
1587 ost = ost_table[n++];
1588 ost->file_index = k;
1589 ost->index = i;
1590 ost->st = os->streams[i];
1591 if (nb_stream_maps > 0) {
1592 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1593 stream_maps[n-1].stream_index;
1594
1595 /* Sanity check that the stream types match */
1596 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1597 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1598 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1599 ost->file_index, ost->index);
1600 av_exit(1);
1601 }
1602
1603 } else {
1604 if(opt_programid) {
1605 found = 0;
1606 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1607 if(j != -1) {
1608 ost->source_index = j;
1609 found = 1;
1610 }
1611 } else {
1612 /* get corresponding input stream index : we select the first one with the right type */
1613 found = 0;
1614 for(j=0;j<nb_istreams;j++) {
1615 ist = ist_table[j];
1616 if (ist->discard &&
1617 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1618 ost->source_index = j;
1619 found = 1;
1620 break;
1621 }
1622 }
1623 }
1624
1625 if (!found) {
1626 if(! opt_programid) {
1627 /* try again and reuse existing stream */
1628 for(j=0;j<nb_istreams;j++) {
1629 ist = ist_table[j];
1630 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1631 ost->source_index = j;
1632 found = 1;
1633 }
1634 }
1635 }
1636 if (!found) {
1637 int i= ost->file_index;
1638 dump_format(output_files[i], i, output_files[i]->filename, 1);
1639 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1640 ost->file_index, ost->index);
1641 av_exit(1);
1642 }
1643 }
1644 }
1645 ist = ist_table[ost->source_index];
1646 ist->discard = 0;
1647 ost->sync_ist = (nb_stream_maps > 0) ?
1648 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1649 stream_maps[n-1].sync_stream_index] : ist;
1650 }
1651 }
1652
1653 /* for each output stream, we compute the right encoding parameters */
1654 for(i=0;i<nb_ostreams;i++) {
1655 ost = ost_table[i];
1656 os = output_files[ost->file_index];
1657 ist = ist_table[ost->source_index];
1658
1659 codec = ost->st->codec;
1660 icodec = ist->st->codec;
1661
1662 if (!ost->st->language[0])
1663 av_strlcpy(ost->st->language, ist->st->language,
1664 sizeof(ost->st->language));
1665
1666 ost->st->disposition = ist->st->disposition;
1667
1668 if (ost->st->stream_copy) {
1669 /* if stream_copy is selected, no need to decode or encode */
1670 codec->codec_id = icodec->codec_id;
1671 codec->codec_type = icodec->codec_type;
1672
1673 if(!codec->codec_tag){
1674 if( !os->oformat->codec_tag
1675 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1676 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1677 codec->codec_tag = icodec->codec_tag;
1678 }
1679
1680 codec->bit_rate = icodec->bit_rate;
1681 codec->extradata= icodec->extradata;
1682 codec->extradata_size= icodec->extradata_size;
1683 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1684 codec->time_base = icodec->time_base;
1685 else
1686 codec->time_base = ist->st->time_base;
1687 switch(codec->codec_type) {
1688 case CODEC_TYPE_AUDIO:
1689 if(audio_volume != 256) {
1690 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1691 av_exit(1);
1692 }
1693 codec->sample_rate = icodec->sample_rate;
1694 codec->channels = icodec->channels;
1695 codec->frame_size = icodec->frame_size;
1696 codec->block_align= icodec->block_align;
1697 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1698 codec->block_align= 0;
1699 if(codec->codec_id == CODEC_ID_AC3)
1700 codec->block_align= 0;
1701 break;
1702 case CODEC_TYPE_VIDEO:
1703 if(using_vhook) {
1704 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1705 av_exit(1);
1706 }
1707 codec->pix_fmt = icodec->pix_fmt;
1708 codec->width = icodec->width;
1709 codec->height = icodec->height;
1710 codec->has_b_frames = icodec->has_b_frames;
1711 break;
1712 case CODEC_TYPE_SUBTITLE:
1713 break;
1714 default:
1715 abort();
1716 }
1717 } else {
1718 switch(codec->codec_type) {
1719 case CODEC_TYPE_AUDIO:
1720 if (av_fifo_init(&ost->fifo, 1024))
1721 goto fail;
1722 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1723 icodec->request_channels = codec->channels;
1724 ist->decoding_needed = 1;
1725 ost->encoding_needed = 1;
1726 break;
1727 case CODEC_TYPE_VIDEO:
1728 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1729 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1730 ost->video_resample = ((codec->width != icodec->width -
1731 (frame_leftBand + frame_rightBand) +
1732 (frame_padleft + frame_padright)) ||
1733 (codec->height != icodec->height -
1734 (frame_topBand + frame_bottomBand) +
1735 (frame_padtop + frame_padbottom)) ||
1736 (codec->pix_fmt != icodec->pix_fmt));
1737 if (ost->video_crop) {
1738 ost->topBand = frame_topBand;
1739 ost->leftBand = frame_leftBand;
1740 }
1741 if (ost->video_pad) {
1742 ost->padtop = frame_padtop;
1743 ost->padleft = frame_padleft;
1744 ost->padbottom = frame_padbottom;
1745 ost->padright = frame_padright;
1746 if (!ost->video_resample) {
1747 avcodec_get_frame_defaults(&ost->pict_tmp);
1748 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1749 codec->width, codec->height))
1750 goto fail;
1751 }
1752 }
1753 if (ost->video_resample) {
1754 avcodec_get_frame_defaults(&ost->pict_tmp);
1755 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1756 codec->width, codec->height)) {
1757 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1758 av_exit(1);
1759 }
1760 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1761 ost->img_resample_ctx = sws_getContext(
1762 icodec->width - (frame_leftBand + frame_rightBand),
1763 icodec->height - (frame_topBand + frame_bottomBand),
1764 icodec->pix_fmt,
1765 codec->width - (frame_padleft + frame_padright),
1766 codec->height - (frame_padtop + frame_padbottom),
1767 codec->pix_fmt,
1768 sws_flags, NULL, NULL, NULL);
1769 if (ost->img_resample_ctx == NULL) {
1770 fprintf(stderr, "Cannot get resampling context\n");
1771 av_exit(1);
1772 }
1773 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1774 }
1775 ost->encoding_needed = 1;
1776 ist->decoding_needed = 1;
1777 break;
1778 case CODEC_TYPE_SUBTITLE:
1779 ost->encoding_needed = 1;
1780 ist->decoding_needed = 1;
1781 break;
1782 default:
1783 abort();
1784 break;
1785 }
1786 /* two pass mode */
1787 if (ost->encoding_needed &&
1788 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1789 char logfilename[1024];
1790 FILE *f;
1791 int size;
1792 char *logbuffer;
1793
1794 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1795 pass_logfilename ?
1796 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1797 if (codec->flags & CODEC_FLAG_PASS1) {
1798 f = fopen(logfilename, "w");
1799 if (!f) {
1800 perror(logfilename);
1801 av_exit(1);
1802 }
1803 ost->logfile = f;
1804 } else {
1805 /* read the log file */
1806 f = fopen(logfilename, "r");
1807 if (!f) {
1808 perror(logfilename);
1809 av_exit(1);
1810 }
1811 fseek(f, 0, SEEK_END);
1812 size = ftell(f);
1813 fseek(f, 0, SEEK_SET);
1814 logbuffer = av_malloc(size + 1);
1815 if (!logbuffer) {
1816 fprintf(stderr, "Could not allocate log buffer\n");
1817 av_exit(1);
1818 }
1819 size = fread(logbuffer, 1, size, f);
1820 fclose(f);
1821 logbuffer[size] = '\0';
1822 codec->stats_in = logbuffer;
1823 }
1824 }
1825 }
1826 if(codec->codec_type == CODEC_TYPE_VIDEO){
1827 int size= codec->width * codec->height;
1828 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1829 }
1830 }
1831
1832 if (!bit_buffer)
1833 bit_buffer = av_malloc(bit_buffer_size);
1834 if (!bit_buffer)
1835 goto fail;
1836
1837 /* dump the file output parameters - cannot be done before in case
1838 of stream copy */
1839 for(i=0;i<nb_output_files;i++) {
1840 dump_format(output_files[i], i, output_files[i]->filename, 1);
1841 }
1842
1843 /* dump the stream mapping */
1844 if (verbose >= 0) {
1845 fprintf(stderr, "Stream mapping:\n");
1846 for(i=0;i<nb_ostreams;i++) {
1847 ost = ost_table[i];
1848 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1849 ist_table[ost->source_index]->file_index,
1850 ist_table[ost->source_index]->index,
1851 ost->file_index,
1852 ost->index);
1853 if (ost->sync_ist != ist_table[ost->source_index])
1854 fprintf(stderr, " [sync #%d.%d]",
1855 ost->sync_ist->file_index,
1856 ost->sync_ist->index);
1857 fprintf(stderr, "\n");
1858 }
1859 }
1860
1861 /* open each encoder */
1862 for(i=0;i<nb_ostreams;i++) {
1863 ost = ost_table[i];
1864 if (ost->encoding_needed) {
1865 AVCodec *codec;
1866 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1867 if (!codec) {
1868 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1869 ost->file_index, ost->index);
1870 av_exit(1);
1871 }
1872 if (avcodec_open(ost->st->codec, codec) < 0) {
1873 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1874 ost->file_index, ost->index);
1875 av_exit(1);
1876 }
1877 extra_size += ost->st->codec->extradata_size;
1878 }
1879 }
1880
1881 /* open each decoder */
1882 for(i=0;i<nb_istreams;i++) {
1883 ist = ist_table[i];
1884 if (ist->decoding_needed) {
1885 AVCodec *codec;
1886 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1887 if (!codec) {
1888 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1889 ist->st->codec->codec_id, ist->file_index, ist->index);
1890 av_exit(1);
1891 }
1892 if (avcodec_open(ist->st->codec, codec) < 0) {
1893 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1894 ist->file_index, ist->index);
1895 av_exit(1);
1896 }
1897 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1898 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1899 }
1900 }
1901
1902 /* init pts */
1903 for(i=0;i<nb_istreams;i++) {
1904 ist = ist_table[i];
1905 is = input_files[ist->file_index];
1906 ist->pts = 0;
1907 ist->next_pts = AV_NOPTS_VALUE;
1908 ist->is_start = 1;
1909 }
1910
1911 /* set meta data information from input file if required */
1912 for (i=0;i<nb_meta_data_maps;i++) {
1913 AVFormatContext *out_file;
1914 AVFormatContext *in_file;
1915
1916 int out_file_index = meta_data_maps[i].out_file;
1917 int in_file_index = meta_data_maps[i].in_file;
1918 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1919 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1920 ret = AVERROR(EINVAL);
1921 goto fail;
1922 }
1923 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1924 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1925 ret = AVERROR(EINVAL);
1926 goto fail;
1927 }
1928
1929 out_file = output_files[out_file_index];
1930 in_file = input_files[in_file_index];
1931
1932 strcpy(out_file->title, in_file->title);
1933 strcpy(out_file->author, in_file->author);
1934 strcpy(out_file->copyright, in_file->copyright);
1935 strcpy(out_file->comment, in_file->comment);
1936 strcpy(out_file->album, in_file->album);
1937 out_file->year = in_file->year;
1938 out_file->track = in_file->track;
1939 strcpy(out_file->genre, in_file->genre);
1940 }
1941
1942 /* open files and write file headers */
1943 for(i=0;i<nb_output_files;i++) {
1944 os = output_files[i];
1945 if (av_write_header(os) < 0) {
1946 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1947 ret = AVERROR(EINVAL);
1948 goto fail;
1949 }
1950 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1951 want_sdp = 0;
1952 }
1953 }
1954 if (want_sdp) {
1955 print_sdp(output_files, nb_output_files);
1956 }
1957
1958 if (!using_stdin && verbose >= 0) {
1959 fprintf(stderr, "Press [q] to stop encoding\n");
1960 url_set_interrupt_cb(decode_interrupt_cb);
1961 }
1962 term_init();
1963
1964 key = -1;
1965 timer_start = av_gettime();
1966
1967 for(; received_sigterm == 0;) {
1968 int file_index, ist_index;
1969 AVPacket pkt;
1970 double ipts_min;
1971 double opts_min;
1972
1973 redo:
1974 ipts_min= 1e100;
1975 opts_min= 1e100;
1976 /* if 'q' pressed, exits */
1977 if (!using_stdin) {
1978 if (q_pressed)
1979 break;
1980 /* read_key() returns 0 on EOF */
1981 key = read_key();
1982 if (key == 'q')
1983 break;
1984 }
1985
1986 /* select the stream that we must read now by looking at the
1987 smallest output pts */
1988 file_index = -1;
1989 for(i=0;i<nb_ostreams;i++) {
1990 double ipts, opts;
1991 ost = ost_table[i];
1992 os = output_files[ost->file_index];
1993 ist = ist_table[ost->source_index];
1994 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1995 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1996 else
1997 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1998 ipts = (double)ist->pts;
1999 if (!file_table[ist->file_index].eof_reached){
2000 if(ipts < ipts_min) {
2001 ipts_min = ipts;
2002 if(input_sync ) file_index = ist->file_index;
2003 }
2004 if(opts < opts_min) {
2005 opts_min = opts;
2006 if(!input_sync) file_index = ist->file_index;
2007 }
2008 }
2009 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2010 file_index= -1;
2011 break;
2012 }
2013 }
2014 /* if none, if is finished */
2015 if (file_index < 0) {
2016 break;
2017 }
2018
2019 /* finish if recording time exhausted */
2020 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2021 break;
2022
2023 /* finish if limit size exhausted */
2024 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2025 break;
2026
2027 /* read a frame from it and output it in the fifo */
2028 is = input_files[file_index];
2029 if (av_read_frame(is, &pkt) < 0) {
2030 file_table[file_index].eof_reached = 1;
2031 if (opt_shortest)
2032 break;
2033 else
2034 continue;
2035 }
2036
2037 if (do_pkt_dump) {
2038 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2039 }
2040 /* the following test is needed in case new streams appear
2041 dynamically in stream : we ignore them */
2042 if (pkt.stream_index >= file_table[file_index].nb_streams)
2043 goto discard_packet;
2044 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2045 ist = ist_table[ist_index];
2046 if (ist->discard)
2047 goto discard_packet;
2048
2049 if (pkt.dts != AV_NOPTS_VALUE)
2050 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2051 if (pkt.pts != AV_NOPTS_VALUE)
2052 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2053
2054 // 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);
2055 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2056 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2057 int64_t delta= pkt_dts - ist->next_pts;
2058 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2059 input_files_ts_offset[ist->file_index]-= delta;
2060 if (verbose > 2)
2061 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2062 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2063 if(pkt.pts != AV_NOPTS_VALUE)
2064 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2065 }
2066 }
2067
2068 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2069 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2070
2071 if (verbose >= 0)
2072 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2073 ist->file_index, ist->index);
2074
2075 av_free_packet(&pkt);
2076 goto redo;
2077 }
2078
2079 discard_packet:
2080 av_free_packet(&pkt);
2081
2082 /* dump report by using the output first video and audio streams */
2083 print_report(output_files, ost_table, nb_ostreams, 0);
2084 }
2085
2086 /* at the end of stream, we must flush the decoder buffers */
2087 for(i=0;i<nb_istreams;i++) {
2088 ist = ist_table[i];
2089 if (ist->decoding_needed) {
2090 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2091 }
2092 }
2093
2094 term_exit();
2095
2096 /* write the trailer if needed and close file */
2097 for(i=0;i<nb_output_files;i++) {
2098 os = output_files[i];
2099 av_write_trailer(os);
2100 }
2101
2102 /* dump report by using the first video and audio streams */
2103 print_report(output_files, ost_table, nb_ostreams, 1);
2104
2105 /* close each encoder */
2106 for(i=0;i<nb_ostreams;i++) {
2107 ost = ost_table[i];
2108 if (ost->encoding_needed) {
2109 av_freep(&ost->st->codec->stats_in);
2110 avcodec_close(ost->st->codec);
2111 }
2112 }
2113
2114 /* close each decoder */
2115 for(i=0;i<nb_istreams;i++) {
2116 ist = ist_table[i];
2117 if (ist->decoding_needed) {
2118 avcodec_close(ist->st->codec);
2119 }
2120 }
2121
2122 /* finished ! */
2123
2124 ret = 0;
2125 fail1:
2126 av_freep(&bit_buffer);
2127 av_free(file_table);
2128
2129 if (ist_table) {
2130 for(i=0;i<nb_istreams;i++) {
2131 ist = ist_table[i];
2132 av_free(ist);
2133 }
2134 av_free(ist_table);
2135 }
2136 if (ost_table) {
2137 for(i=0;i<nb_ostreams;i++) {
2138 ost = ost_table[i];
2139 if (ost) {
2140 if (ost->logfile) {
2141 fclose(ost->logfile);
2142 ost->logfile = NULL;
2143 }
2144 av_fifo_free(&ost->fifo); /* works even if fifo is not
2145 initialized but set to zero */
2146 av_free(ost->pict_tmp.data[0]);
2147 if (ost->video_resample)
2148 sws_freeContext(ost->img_resample_ctx);
2149 if (ost->resample)
2150 audio_resample_close(ost->resample);
2151 av_free(ost);
2152 }
2153 }
2154 av_free(ost_table);
2155 }
2156 return ret;
2157 fail:
2158 ret = AVERROR(ENOMEM);
2159 goto fail1;
2160 }
2161
2162 #if 0
2163 int file_read(const char *filename)
2164 {
2165 URLContext *h;
2166 unsigned char buffer[1024];
2167 int len, i;
2168
2169 if (url_open(&h, filename, O_RDONLY) < 0) {
2170 printf("could not open '%s'\n", filename);
2171 return -1;
2172 }
2173 for(;;) {
2174 len = url_read(h, buffer, sizeof(buffer));
2175 if (len <= 0)
2176 break;
2177 for(i=0;i<len;i++) putchar(buffer[i]);
2178 }
2179 url_close(h);
2180 return 0;
2181 }
2182 #endif
2183
2184 static void opt_format(const char *arg)
2185 {
2186 /* compatibility stuff for pgmyuv */
2187 if (!strcmp(arg, "pgmyuv")) {
2188 pgmyuv_compatibility_hack=1;
2189 // opt_image_format(arg);
2190 arg = "image2";
2191 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2192 }
2193
2194 file_iformat = av_find_input_format(arg);
2195 file_oformat = guess_format(arg, NULL, NULL);
2196 if (!file_iformat && !file_oformat) {
2197 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2198 av_exit(1);
2199 }
2200 }
2201
2202 static int opt_default(const char *opt, const char *arg){
2203 int type;
2204 const AVOption *o= NULL;
2205 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2206
2207 for(type=0; type<CODEC_TYPE_NB; type++){
2208 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2209 if(o2)
2210 o = av_set_string2(avctx_opts[type], opt, arg, 1);
2211 }
2212 if(!o)
2213 o = av_set_string2(avformat_opts, opt, arg, 1);
2214 if(!o)
2215 o = av_set_string2(sws_opts, opt, arg, 1);
2216 if(!o){
2217 if(opt[0] == 'a')
2218 o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2219 else if(opt[0] == 'v')
2220 o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2221 else if(opt[0] == 's')
2222 o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2223 }
2224 if(!o)
2225 return -1;
2226
2227 // 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));
2228
2229 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2230 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2231 opt_names[opt_name_count++]= o->name;
2232
2233 if(avctx_opts[0]->debug || avformat_opts->debug)
2234 av_log_set_level(AV_LOG_DEBUG);
2235 return 0;
2236 }
2237
2238 static void opt_video_rc_override_string(const char *arg)
2239 {
2240 video_rc_override_string = arg;
2241 }
2242
2243 static int opt_me_threshold(const char *opt, const char *arg)
2244 {
2245 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2246 return 0;
2247 }
2248
2249 static int opt_verbose(const char *opt, const char *arg)
2250 {
2251 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2252 av_log_set_level(verbose);
2253 return 0;
2254 }
2255
2256 static void opt_frame_rate(const char *arg)
2257 {
2258 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2259 fprintf(stderr, "Incorrect frame rate\n");
2260 av_exit(1);
2261 }
2262 }
2263
2264 static int opt_bitrate(const char *opt, const char *arg)
2265 {
2266 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2267
2268 opt_default(opt, arg);
2269
2270 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2271 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2272
2273 return 0;
2274 }
2275
2276 static void opt_frame_crop_top(const char *arg)
2277 {
2278 frame_topBand = atoi(arg);
2279 if (frame_topBand < 0) {
2280 fprintf(stderr, "Incorrect top crop size\n");
2281 av_exit(1);
2282 }
2283 if ((frame_topBand % 2) != 0) {
2284 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2285 av_exit(1);
2286 }
2287 if ((frame_topBand) >= frame_height){
2288 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2289 av_exit(1);
2290 }
2291 frame_height -= frame_topBand;
2292 }
2293
2294 static void opt_frame_crop_bottom(const char *arg)
2295 {
2296 frame_bottomBand = atoi(arg);
2297 if (frame_bottomBand < 0) {
2298 fprintf(stderr, "Incorrect bottom crop size\n");
2299 av_exit(1);
2300 }
2301 if ((frame_bottomBand % 2) != 0) {
2302 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2303 av_exit(1);
2304 }
2305 if ((frame_bottomBand) >= frame_height){
2306 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2307 av_exit(1);
2308 }
2309 frame_height -= frame_bottomBand;
2310 }
2311
2312 static void opt_frame_crop_left(const char *arg)
2313 {
2314 frame_leftBand = atoi(arg);
2315 if (frame_leftBand < 0) {
2316 fprintf(stderr, "Incorrect left crop size\n");
2317 av_exit(1);
2318 }
2319 if ((frame_leftBand % 2) != 0) {
2320 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2321 av_exit(1);
2322 }
2323 if ((frame_leftBand) >= frame_width){
2324 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2325 av_exit(1);
2326 }
2327 frame_width -= frame_leftBand;
2328 }
2329
2330 static void opt_frame_crop_right(const char *arg)
2331 {
2332 frame_rightBand = atoi(arg);
2333 if (frame_rightBand < 0) {
2334 fprintf(stderr, "Incorrect right crop size\n");
2335 av_exit(1);
2336 }
2337 if ((frame_rightBand % 2) != 0) {
2338 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2339 av_exit(1);
2340 }
2341 if ((frame_rightBand) >= frame_width){
2342 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2343 av_exit(1);
2344 }
2345 frame_width -= frame_rightBand;
2346 }
2347
2348 static void opt_frame_size(const char *arg)
2349 {
2350 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2351 fprintf(stderr, "Incorrect frame size\n");
2352 av_exit(1);
2353 }
2354 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2355 fprintf(stderr, "Frame size must be a multiple of 2\n");
2356 av_exit(1);
2357 }
2358 }
2359
2360
2361 #define SCALEBITS 10
2362 #define ONE_HALF (1 << (SCALEBITS - 1))
2363 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2364
2365 #define RGB_TO_Y(r, g, b) \
2366 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2367 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2368
2369 #define RGB_TO_U(r1, g1, b1, shift)\
2370 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2371 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2372
2373 #define RGB_TO_V(r1, g1, b1, shift)\
2374 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2375 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2376
2377 static void opt_pad_color(const char *arg) {
2378 /* Input is expected to be six hex digits similar to
2379 how colors are expressed in html tags (but without the #) */
2380 int rgb = strtol(arg, NULL, 16);
2381 int r,g,b;
2382
2383 r = (rgb >> 16);
2384 g = ((rgb >> 8) & 255);
2385 b = (rgb & 255);
2386
2387 padcolor[0] = RGB_TO_Y(r,g,b);
2388 padcolor[1] = RGB_TO_U(r,g,b,0);
2389 padcolor[2] = RGB_TO_V(r,g,b,0);
2390 }
2391
2392 static void opt_frame_pad_top(const char *arg)
2393 {
2394 frame_padtop = atoi(arg);
2395 if (frame_padtop < 0) {
2396 fprintf(stderr, "Incorrect top pad size\n");
2397 av_exit(1);
2398 }
2399 if ((frame_padtop % 2) != 0) {
2400 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2401 av_exit(1);
2402 }
2403 }
2404
2405 static void opt_frame_pad_bottom(const char *arg)
2406 {
2407 frame_padbottom = atoi(arg);
2408 if (frame_padbottom < 0) {
2409 fprintf(stderr, "Incorrect bottom pad size\n");
2410 av_exit(1);
2411 }
2412 if ((frame_padbottom % 2) != 0) {
2413 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2414 av_exit(1);
2415 }
2416 }
2417
2418
2419 static void opt_frame_pad_left(const char *arg)
2420 {
2421 frame_padleft = atoi(arg);
2422 if (frame_padleft < 0) {
2423 fprintf(stderr, "Incorrect left pad size\n");
2424 av_exit(1);
2425 }
2426 if ((frame_padleft % 2) != 0) {
2427 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2428 av_exit(1);
2429 }
2430 }
2431
2432
2433 static void opt_frame_pad_right(const char *arg)
2434 {
2435 frame_padright = atoi(arg);
2436 if (frame_padright < 0) {
2437 fprintf(stderr, "Incorrect right pad size\n");
2438 av_exit(1);
2439 }
2440 if ((frame_padright % 2) != 0) {
2441 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2442 av_exit(1);
2443 }
2444 }
2445
2446 static void list_pix_fmts(void)
2447 {
2448 int i;
2449 char pix_fmt_str[128];
2450 for (i=-1; i < PIX_FMT_NB; i++) {
2451 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2452 fprintf(stdout, "%s\n", pix_fmt_str);
2453 }
2454 }
2455
2456 static void opt_frame_pix_fmt(const char *arg)
2457 {
2458 if (strcmp(arg, "list"))
2459 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2460 else {
2461 list_pix_fmts();
2462 av_exit(0);
2463 }
2464 }
2465
2466 static void opt_frame_aspect_ratio(const char *arg)
2467 {
2468 int x = 0, y = 0;
2469 double ar = 0;
2470 const char *p;
2471 char *end;
2472
2473 p = strchr(arg, ':');
2474 if (p) {
2475 x = strtol(arg, &end, 10);
2476 if (end == p)
2477 y = strtol(end+1, &end, 10);
2478 if (x > 0 && y > 0)
2479 ar = (double)x / (double)y;
2480 } else
2481 ar = strtod(arg, NULL);
2482
2483 if (!ar) {
2484 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2485 av_exit(1);
2486 }
2487 frame_aspect_ratio = ar;
2488 }
2489
2490 static void opt_qscale(const char *arg)
2491 {
2492 video_qscale = atof(arg);
2493 if (video_qscale <= 0 ||
2494 video_qscale > 255) {
2495 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2496 av_exit(1);
2497 }
2498 }
2499
2500 static void opt_strict(const char *arg)
2501 {
2502 strict= atoi(arg);
2503 }
2504
2505 static void opt_top_field_first(const char *arg)
2506 {
2507 top_field_first= atoi(arg);
2508 }
2509
2510 static int opt_thread_count(const char *opt, const char *arg)
2511 {
2512 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2513 #if !defined(HAVE_THREADS)
2514 if (verbose >= 0)
2515 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2516 #endif
2517 return 0;
2518 }
2519
2520 static int opt_audio_rate(const char *opt, const char *arg)
2521 {
2522 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2523 return 0;
2524 }
2525
2526 static int opt_audio_channels(const char *opt, const char *arg)
2527 {
2528 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2529 return 0;
2530 }
2531
2532 static void opt_video_channel(const char *arg)
2533 {
2534 video_channel = strtol(arg, NULL, 0);
2535 }
2536
2537 static void opt_video_standard(const char *arg)
2538 {
2539 video_standard = av_strdup(arg);
2540 }
2541
2542 static void opt_codec(int *pstream_copy, char **pcodec_name,
2543 int codec_type, const char *arg)
2544 {
2545 av_freep(pcodec_name);
2546 if (!strcmp(arg, "copy")) {
2547 *pstream_copy = 1;
2548 } else {
2549 *pcodec_name = av_strdup(arg);
2550 }
2551 }
2552
2553 static void opt_audio_codec(const char *arg)
2554 {
2555 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2556 }
2557
2558 static void opt_audio_tag(const char *arg)
2559 {
2560 char *tail;
2561 audio_codec_tag= strtol(arg, &tail, 0);
2562
2563 if(!tail || *tail)
2564 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2565 }
2566
2567 static void opt_video_tag(const char *arg)
2568 {
2569 char *tail;
2570 video_codec_tag= strtol(arg, &tail, 0);
2571
2572 if(!tail || *tail)
2573 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2574 }
2575
2576 #ifdef CONFIG_VHOOK
2577 static void add_frame_hooker(const char *arg)
2578 {
2579 int argc = 0;
2580 char *argv[64];
2581 int i;
2582 char *args = av_strdup(arg);
2583
2584 using_vhook = 1;
2585
2586 argv[0] = strtok(args, " ");
2587 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2588 }
2589
2590 i = frame_hook_add(argc, argv);
2591
2592 if (i != 0) {
2593 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2594 av_exit(1);
2595 }
2596 }
2597 #endif
2598
2599 static void opt_video_codec(const char *arg)
2600 {
2601 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2602 }
2603
2604 static void opt_subtitle_codec(const char *arg)
2605 {
2606 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2607 }
2608
2609 static void opt_map(const char *arg)
2610 {
2611 AVStreamMap *m;
2612 char *p;
2613
2614 m = &stream_maps[nb_stream_maps++];
2615
2616 m->file_index = strtol(arg, &p, 0);
2617 if (*p)
2618 p++;
2619
2620 m->stream_index = strtol(p, &p, 0);
2621 if (*p) {
2622 p++;
2623 m->sync_file_index = strtol(p, &p, 0);
2624 if (*p)
2625 p++;
2626 m->sync_stream_index = strtol(p, &p, 0);
2627 } else {
2628 m->sync_file_index = m->file_index;
2629 m->sync_stream_index = m->stream_index;
2630 }
2631 }
2632
2633 static void opt_map_meta_data(const char *arg)
2634 {
2635 AVMetaDataMap *m;
2636 char *p;
2637
2638 m = &meta_data_maps[nb_meta_data_maps++];
2639
2640 m->out_file = strtol(arg, &p, 0);
2641 if (*p)
2642 p++;
2643
2644 m->in_file = strtol(p, &p, 0);
2645 }
2646
2647 static int opt_recording_time(const char *opt, const char *arg)
2648 {
2649 recording_time = parse_time_or_die(opt, arg, 1);
2650 return 0;
2651 }
2652
2653 static int opt_start_time(const char *opt, const char *arg)
2654 {
2655 start_time = parse_time_or_die(opt, arg, 1);
2656 return 0;
2657 }
2658
2659 static int opt_rec_timestamp(const char *opt, const char *arg)
2660 {
2661 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2662 return 0;
2663 }
2664
2665 static int opt_input_ts_offset(const char *opt, const char *arg)
2666 {
2667 input_ts_offset = parse_time_or_die(opt, arg, 1);
2668 return 0;
2669 }
2670
2671 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2672 {
2673 const char *codec_string = encoder ? "encoder" : "decoder";
2674 AVCodec *codec;
2675
2676 if(!name)
2677 return CODEC_ID_NONE;
2678 codec = encoder ?
2679 avcodec_find_encoder_by_name(name) :
2680 avcodec_find_decoder_by_name(name);
2681 if(!codec) {
2682 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2683 av_exit(1);
2684 }
2685 if(codec->type != type) {
2686 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2687 av_exit(1);
2688 }
2689 return codec->id;
2690 }
2691
2692 static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2693 {
2694 int i;
2695 for(i=0; i<opt_name_count; i++){
2696 char buf[256];
2697 const AVOption *opt;
2698 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2699 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2700 if(str && ((opt->flags & flags) == flags))
2701 av_set_string2(ctx, opt_names[i], str, 1);
2702 }
2703 }
2704
2705 static void opt_input_file(const char *filename)
2706 {
2707 AVFormatContext *ic;
2708 AVFormatParameters params, *ap = &params;
2709 int err, i, ret, rfps, rfps_base;
2710 int64_t timestamp;
2711
2712 if (!strcmp(filename, "-"))
2713 filename = "pipe:";
2714
2715 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2716 !strcmp(filename, "/dev/stdin");
2717
2718 /* get default parameters from command line */
2719 ic = av_alloc_format_context();
2720
2721 memset(ap, 0, sizeof(*ap));
2722 ap->prealloced_context = 1;
2723 ap->sample_rate = audio_sample_rate;
2724 ap->channels = audio_channels;
2725 ap->time_base.den = frame_rate.num;
2726 ap->time_base.num = frame_rate.den;
2727 ap->width = frame_width + frame_padleft + frame_padright;
2728 ap->height = frame_height + frame_padtop + frame_padbottom;
2729 ap->pix_fmt = frame_pix_fmt;
2730 ap->channel = video_channel;
2731 ap->standard = video_standard;
2732 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2733 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2734 if(pgmyuv_compatibility_hack)
2735 ap->video_codec_id= CODEC_ID_PGMYUV;
2736
2737 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2738
2739 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2740 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2741 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2742
2743 /* open the input file with generic libav function */
2744 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2745 if (err < 0) {
2746 print_error(filename, err);
2747 av_exit(1);
2748 }
2749 if(opt_programid) {
2750 int i;
2751 for(i=0; i<ic->nb_programs; i++)
2752 if(ic->programs[i]->id != opt_programid)
2753 ic->programs[i]->discard = AVDISCARD_ALL;
2754 }
2755
2756 ic->loop_input = loop_input;
2757
2758 /* If not enough info to get the stream parameters, we decode the
2759 first frames to get it. (used in mpeg case for example) */
2760 ret = av_find_stream_info(ic);
2761 if (ret < 0 && verbose >= 0) {
2762 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2763 av_exit(1);
2764 }
2765
2766 timestamp = start_time;
2767 /* add the stream start time */
2768 if (ic->start_time != AV_NOPTS_VALUE)
2769 timestamp += ic->start_time;
2770
2771 /* if seeking requested, we execute it */
2772 if (start_time != 0) {
2773 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2774 if (ret < 0) {
2775 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2776 filename, (double)timestamp / AV_TIME_BASE);
2777 }
2778 /* reset seek info */
2779 start_time = 0;
2780 }
2781
2782 /* update the current parameters so that they match the one of the input stream */
2783 for(i=0;i<ic->nb_streams;i++) {
2784 AVCodecContext *enc = ic->streams[i]->codec;
2785 if(thread_count>1)
2786 avcodec_thread_init(enc, thread_count);
2787 enc->thread_count= thread_count;
2788 switch(enc->codec_type) {
2789 case CODEC_TYPE_AUDIO:
2790 set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2791 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2792 audio_channels = enc->channels;
2793 audio_sample_rate = enc->sample_rate;
2794 if(audio_disable)
2795 ic->streams[i]->discard= AVDISCARD_ALL;
2796 break;
2797 case CODEC_TYPE_VIDEO:
2798 set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2799 frame_height = enc->height;
2800 frame_width = enc->width;
2801 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2802 frame_pix_fmt = enc->pix_fmt;
2803 rfps = ic->streams[i]->r_frame_rate.num;
2804 rfps_base = ic->streams[i]->r_frame_rate.den;
2805 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2806 if(me_threshold)
2807 enc->debug |= FF_DEBUG_MV;
2808
2809 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2810
2811 if (verbose >= 0)
2812 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2813 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2814
2815 (float)rfps / rfps_base, rfps, rfps_base);
2816 }
2817 /* update the current frame rate to match the stream frame rate */
2818 frame_rate.num = rfps;
2819 frame_rate.den = rfps_base;
2820
2821 enc->rate_emu = rate_emu;
2822 if(video_disable)
2823 ic->streams[i]->discard= AVDISCARD_ALL;
2824 else if(video_discard)
2825 ic->streams[i]->discard= video_discard;
2826 break;
2827 case CODEC_TYPE_DATA:
2828 break;
2829 case CODEC_TYPE_SUBTITLE:
2830 if(subtitle_disable)
2831 ic->streams[i]->discard = AVDISCARD_ALL;
2832 break;
2833 case CODEC_TYPE_ATTACHMENT:
2834 case CODEC_TYPE_UNKNOWN:
2835 break;
2836 default:
2837 abort();
2838 }
2839 }
2840
2841 input_files[nb_input_files] = ic;
2842 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2843 /* dump the file content */
2844 if (verbose >= 0)
2845 dump_format(ic, nb_input_files, filename, 0);
2846
2847 nb_input_files++;
2848 file_iformat = NULL;
2849 file_oformat = NULL;
2850
2851 video_channel = 0;
2852
2853 rate_emu = 0;
2854 av_freep(&video_codec_name);
2855 av_freep(&audio_codec_name);
2856 av_freep(&subtitle_codec_name);
2857 }
2858
2859 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2860 int *has_subtitle_ptr)
2861 {
2862 int has_video, has_audio, has_subtitle, i, j;
2863 AVFormatContext *ic;
2864
2865 has_video = 0;
2866 has_audio = 0;
2867 has_subtitle = 0;
2868 for(j=0;j<nb_input_files;j++) {
2869 ic = input_files[j];
2870 for(i=0;i<ic->nb_streams;i++) {
2871 AVCodecContext *enc = ic->streams[i]->codec;
2872 switch(enc->codec_type) {
2873 case CODEC_TYPE_AUDIO:
2874 has_audio = 1;
2875 break;
2876 case CODEC_TYPE_VIDEO:
2877 has_video = 1;
2878 break;
2879 case CODEC_TYPE_SUBTITLE:
2880 has_subtitle = 1;
2881 break;
2882 case CODEC_TYPE_DATA:
2883 case CODEC_TYPE_ATTACHMENT:
2884 case CODEC_TYPE_UNKNOWN:
2885 break;
2886 default:
2887 abort();
2888 }
2889 }
2890 }
2891 *has_video_ptr = has_video;
2892 *has_audio_ptr = has_audio;
2893 *has_subtitle_ptr = has_subtitle;
2894 }
2895
2896 static void new_video_stream(AVFormatContext *oc)
2897 {
2898 AVStream *st;
2899 AVCodecContext *video_enc;
2900 int codec_id;
2901
2902 st = av_new_stream(oc, oc->nb_streams);
2903 if (!st) {
2904 fprintf(stderr, "Could not alloc stream\n");
2905 av_exit(1);
2906 }
2907 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2908 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2909 video_bitstream_filters= NULL;
2910
2911 if(thread_count>1)
2912 avcodec_thread_init(st->codec, thread_count);
2913
2914 video_enc = st->codec;
2915
2916 if(video_codec_tag)
2917 video_enc->codec_tag= video_codec_tag;
2918
2919 if( (video_global_header&1)
2920 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2921 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2922 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2923 }
2924 if(video_global_header&2){
2925 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2926 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2927 }
2928
2929 if (video_stream_copy) {
2930 st->stream_copy = 1;
2931 video_enc->codec_type = CODEC_TYPE_VIDEO;
2932 } else {
2933 const char *p;
2934 int i;
2935 AVCodec *codec;
2936 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2937
2938 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2939 if (video_codec_name)
2940 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2941
2942 video_enc->codec_id = codec_id;
2943 codec = avcodec_find_encoder(codec_id);
2944
2945 set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2946
2947 video_enc->time_base.den = fps.num;
2948 video_enc->time_base.num = fps.den;
2949 if(codec && codec->supported_framerates){
2950 const AVRational *p= codec->supported_framerates;
2951 const AVRational *best=NULL;
2952 AVRational best_error= (AVRational){INT_MAX, 1};
2953 for(; p->den!=0; p++){
2954 AVRational error= av_sub_q(fps, *p);
2955 if(error.num <0) error.num *= -1;
2956 if(av_cmp_q(error, best_error) < 0){
2957 best_error= error;
2958 best= p;
2959 }
2960 }
2961 video_enc->time_base.den= best->num;
2962 video_enc->time_base.num= best->den;
2963 }
2964
2965 video_enc->width = frame_width + frame_padright + frame_padleft;
2966 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2967 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2968 video_enc->pix_fmt = frame_pix_fmt;
2969
2970 if(codec && codec->pix_fmts){
2971 const enum PixelFormat *p= codec->pix_fmts;
2972 for(; *p!=-1; p++){
2973 if(*p == video_enc->pix_fmt)
2974 break;
2975 }
2976 if(*p == -1)
2977 video_enc->pix_fmt = codec->pix_fmts[0];
2978 }
2979
2980 if (intra_only)
2981 video_enc->gop_size = 0;
2982 if (video_qscale || same_quality) {
2983 video_enc->flags |= CODEC_FLAG_QSCALE;
2984 video_enc->global_quality=
2985 st->quality = FF_QP2LAMBDA * video_qscale;
2986 }
2987
2988 if(intra_matrix)
2989 video_enc->intra_matrix = intra_matrix;
2990 if(inter_matrix)
2991 video_enc->inter_matrix = inter_matrix;
2992
2993 video_enc->thread_count = thread_count;
2994 p= video_rc_override_string;
2995 for(i=0; p; i++){
2996 int start, end, q;
2997 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2998 if(e!=3){
2999 fprintf(stderr, "error parsing rc_override\n");
3000 av_exit(1);
3001 }
3002 video_enc->rc_override=
3003 av_realloc(video_enc->rc_override,
3004 sizeof(RcOverride)*(i+1));
3005 video_enc->rc_override[i].start_frame= start;
3006 video_enc->rc_override[i].end_frame = end;
3007 if(q>0){
3008 video_enc->rc_override[i].qscale= q;
3009 video_enc->rc_override[i].quality_factor= 1.0;
3010 }
3011 else{
3012 video_enc->rc_override[i].qscale= 0;
3013 video_enc->rc_override[i].quality_factor= -q/100.0;
3014 }
3015 p= strchr(p, '/');
3016 if(p) p++;
3017 }
3018 video_enc->rc_override_count=i;
3019 if (!video_enc->rc_initial_buffer_occupancy)
3020 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3021 video_enc->me_threshold= me_threshold;
3022 video_enc->intra_dc_precision= intra_dc_precision - 8;
3023 video_enc->strict_std_compliance = strict;
3024
3025 if (do_psnr)
3026 video_enc->flags|= CODEC_FLAG_PSNR;
3027
3028 /* two pass mode */
3029 if (do_pass) {
3030 if (do_pass == 1) {
3031 video_enc->flags |= CODEC_FLAG_PASS1;
3032 } else {
3033 video_enc->flags |= CODEC_FLAG_PASS2;
3034 }
3035 }
3036 }
3037
3038 /* reset some key parameters */
3039 video_disable = 0;
3040 av_freep(&video_codec_name);
3041 video_stream_copy = 0;
3042 }
3043
3044 static void new_audio_stream(AVFormatContext *oc)
3045 {
3046 AVStream *st;
3047 AVCodecContext *audio_enc;
3048 int codec_id;
3049
3050 st = av_new_stream(oc, oc->nb_streams);
3051 if (!st) {
3052 fprintf(stderr, "Could not alloc stream\n");
3053 av_exit(1);
3054 }
3055 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3056
3057 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3058 audio_bitstream_filters= NULL;
3059
3060 if(thread_count>1)
3061 avcodec_thread_init(st->codec, thread_count);
3062
3063 audio_enc = st->codec;
3064 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3065 audio_enc->strict_std_compliance = strict;
3066
3067 if(audio_codec_tag)
3068 audio_enc->codec_tag= audio_codec_tag;
3069
3070 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3071 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3072 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3073 }
3074 if (audio_stream_copy) {
3075 st->stream_copy = 1;
3076 audio_enc->channels = audio_channels;
3077 } else {
3078 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3079
3080 set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3081
3082 if (audio_codec_name)
3083 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3084 audio_enc->codec_id = codec_id;
3085
3086 if (audio_qscale > QSCALE_NONE) {
3087 audio_enc->flags |= CODEC_FLAG_QSCALE;
3088 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3089 }
3090 audio_enc->thread_count = thread_count;
3091 audio_enc->channels = audio_channels;
3092 }
3093 audio_enc->sample_rate = audio_sample_rate;
3094 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3095 if (audio_language) {
3096 av_strlcpy(st->language, audio_language, sizeof(st->language));
3097 av_free(audio_language);
3098 audio_language = NULL;
3099 }
3100
3101 /* reset some key parameters */
3102 audio_disable = 0;
3103 av_freep(&audio_codec_name);
3104 audio_stream_copy = 0;
3105 }
3106
3107 static void new_subtitle_stream(AVFormatContext *oc)
3108 {
3109 AVStream *st;
3110 AVCodecContext *subtitle_enc;
3111
3112 st = av_new_stream(oc, oc->nb_streams);
3113 if (!st) {
3114 fprintf(stderr, "Could not alloc stream\n");
3115 av_exit(1);
3116 }
3117 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3118
3119 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3120 subtitle_bitstream_filters= NULL;
3121
3122 subtitle_enc = st->codec;
3123 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3124 if (subtitle_stream_copy) {
3125 st->stream_copy = 1;
3126 } else {
3127 set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3128 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3129 }
3130
3131 if (subtitle_language) {
3132 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3133 av_free(subtitle_language);
3134 subtitle_language = NULL;
3135 }
3136
3137 subtitle_disable = 0;
3138 av_freep(&subtitle_codec_name);
3139 subtitle_stream_copy = 0;
3140 }
3141
3142 static void opt_new_audio_stream(void)
3143 {
3144 AVFormatContext *oc;
3145 if (nb_output_files <= 0) {
3146 fprintf(stderr, "At least one output file must be specified\n");
3147 av_exit(1);
3148 }
3149 oc = output_files[nb_output_files - 1];
3150 new_audio_stream(oc);
3151 }
3152
3153 static void opt_new_video_stream(void)
3154 {
3155 AVFormatContext *oc;
3156 if (nb_output_files <= 0) {
3157 fprintf(stderr, "At least one output file must be specified\n");
3158 av_exit(1);
3159 }
3160 oc = output_files[nb_output_files - 1];
3161 new_video_stream(oc);
3162 }
3163
3164 static void opt_new_subtitle_stream(void)
3165 {
3166 AVFormatContext *oc;
3167 if (nb_output_files <= 0) {
3168 fprintf(stderr, "At least one output file must be specified\n");
3169 av_exit(1);
3170 }
3171 oc = output_files[nb_output_files - 1];
3172 new_subtitle_stream(oc);
3173 }
3174
3175 static void opt_output_file(const char *filename)
3176 {
3177 AVFormatContext *oc;
3178 int use_video, use_audio, use_subtitle;
3179 int input_has_video, input_has_audio, input_has_subtitle;
3180 AVFormatParameters params, *ap = &params;
3181
3182 if (!strcmp(filename, "-"))
3183 filename = "pipe:";
3184
3185 oc = av_alloc_format_context();
3186
3187 if (!file_oformat) {
3188 file_oformat = guess_format(NULL, filename, NULL);
3189 if (!file_oformat) {
3190 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3191 filename);
3192 av_exit(1);
3193 }
3194 }
3195
3196 oc->oformat = file_oformat;
3197 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3198
3199 if (!strcmp(file_oformat->name, "ffm") &&
3200 av_strstart(filename, "http:", NULL)) {
3201 /* special case for files sent to ffserver: we get the stream
3202 parameters from ffserver */
3203 int err = read_ffserver_streams(oc, filename);
3204 if (err < 0) {
3205 print_error(filename, err);
3206 av_exit(1);
3207 }
3208 } else {
3209 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3210 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3211 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3212
3213 /* disable if no corresponding type found and at least one
3214 input file */
3215 if (nb_input_files > 0) {
3216 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3217 &input_has_subtitle);
3218 if (!input_has_video)
3219 use_video = 0;
3220 if (!input_has_audio)
3221 use_audio = 0;
3222 if (!input_has_subtitle)
3223 use_subtitle = 0;
3224 }
3225
3226 /* manual disable */
3227 if (audio_disable) {
3228 use_audio = 0;
3229 }
3230 if (video_disable) {
3231 use_video = 0;
3232 }
3233 if (subtitle_disable) {
3234 use_subtitle = 0;
3235 }
3236
3237 if (use_video) {
3238 new_video_stream(oc);
3239 }
3240
3241 if (use_audio) {
3242 new_audio_stream(oc);
3243 }
3244
3245 if (use_subtitle) {
3246 new_subtitle_stream(oc);
3247 }
3248
3249 oc->timestamp = rec_timestamp;
3250
3251 if (str_title)
3252 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3253 if (str_author)
3254 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3255 if (str_copyright)
3256 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3257 if (str_comment)
3258 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3259 if (str_album)
3260 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3261 if (str_genre)
3262 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3263 }
3264
3265 output_files[nb_output_files++] = oc;
3266
3267 /* check filename in case of an image number is expected */
3268 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3269 if (!av_filename_number_test(oc->filename)) {
3270 print_error(oc->filename, AVERROR_NUMEXPECTED);
3271 av_exit(1);
3272 }
3273 }
3274
3275 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3276 /* test if it already exists to avoid loosing precious files */
3277 if (!file_overwrite &&
3278 (strchr(filename, ':') == NULL ||
3279 filename[1] == ':' ||
3280 av_strstart(filename, "file:", NULL))) {
3281 if (url_exist(filename)) {
3282 int c;
3283
3284 if (!using_stdin) {
3285 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3286 fflush(stderr);
3287 c = getchar();
3288 if (toupper(c) != 'Y') {
3289 fprintf(stderr, "Not overwriting - exiting\n");
3290 av_exit(1);
3291 }
3292 }
3293 else {
3294 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3295 av_exit(1);
3296 }
3297 }
3298 }
3299
3300 /* open the file */
3301 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3302 fprintf(stderr, "Could not open '%s'\n", filename);
3303 av_exit(1);
3304 }
3305 }
3306
3307 memset(ap, 0, sizeof(*ap));
3308 if (av_set_parameters(oc, ap) < 0) {
3309 fprintf(stderr, "%s: Invalid encoding parameters\n",
3310 oc->filename);
3311 av_exit(1);
3312 }
3313
3314 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3315 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3316 oc->loop_output = loop_output;
3317
3318 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3319
3320 /* reset some options */
3321 file_oformat = NULL;
3322 file_iformat = NULL;
3323 }
3324
3325 /* same option as mencoder */
3326 static void opt_pass(const char *pass_str)
3327 {
3328 int pass;
3329 pass = atoi(pass_str);
3330 if (pass != 1 && pass != 2) {
3331 fprintf(stderr, "pass number can be only 1 or 2\n");
3332 av_exit(1);
3333 }
3334 do_pass = pass;
3335 }
3336
3337 static int64_t getutime(void)
3338 {
3339 #ifdef HAVE_GETRUSAGE
3340 struct rusage rusage;
3341
3342 getrusage(RUSAGE_SELF, &rusage);
3343 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3344 #elif defined(HAVE_GETPROCESSTIMES)
3345 HANDLE proc;
3346 FILETIME c, e, k, u;
3347 proc = GetCurrentProcess();
3348 GetProcessTimes(proc, &c, &e, &k, &u);
3349 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3350 #else
3351 return av_gettime();
3352 #endif
3353 }
3354
3355 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3356 {
3357 int i;
3358 const char *p = str;
3359 for(i = 0;; i++) {
3360 dest[i] = atoi(p);
3361 if(i == 63)
3362 break;
3363 p = strchr(p, ',');
3364 if(!p) {
3365 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3366 av_exit(1);
3367 }
3368 p++;
3369 }
3370 }
3371
3372 static void opt_inter_matrix(const char *arg)
3373 {
3374 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3375 parse_matrix_coeffs(inter_matrix, arg);
3376 }
3377
3378 static void opt_intra_matrix(const char *arg)
3379 {
3380 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3381 parse_matrix_coeffs(intra_matrix, arg);
3382 }
3383
3384 /**
3385 * Trivial log callback.
3386 * Only suitable for show_help and similar since it lacks prefix handling.
3387 */
3388 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3389 {
3390 vfprintf(stdout, fmt, vl);
3391 }
3392
3393 static void show_help(void)
3394 {
3395 av_log_set_callback(log_callback_help);
3396 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3397 "Hyper fast Audio and Video encoder\n");
3398 printf("\n");
3399 show_help_options(options, "Main options:\n",
3400 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3401 show_help_options(options, "\nAdvanced options:\n",
3402 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3403 OPT_EXPERT);
3404 show_help_options(options, "\nVideo options:\n",
3405 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3406 OPT_VIDEO);
3407 show_help_options(options, "\nAdvanced Video options:\n",
3408 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3409 OPT_VIDEO | OPT_EXPERT);
3410 show_help_options(options, "\nAudio options:\n",
3411 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3412 OPT_AUDIO);
3413 show_help_options(options, "\nAdvanced Audio options:\n",
3414 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3415 OPT_AUDIO | OPT_EXPERT);
3416 show_help_options(options, "\nSubtitle options:\n",
3417 OPT_SUBTITLE | OPT_GRAB,
3418 OPT_SUBTITLE);
3419 show_help_options(options, "\nAudio/Video grab options:\n",
3420 OPT_GRAB,
3421 OPT_GRAB);
3422 printf("\n");
3423 av_opt_show(avctx_opts[0], NULL);
3424 printf("\n");
3425 av_opt_show(avformat_opts, NULL);
3426 printf("\n");
3427 av_opt_show(sws_opts, NULL);
3428 }
3429
3430 static void opt_target(const char *arg)
3431 {
3432 int norm = -1;
3433 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3434
3435 if(!strncmp(arg, "pal-", 4)) {
3436 norm = 0;
3437 arg += 4;
3438 } else if(!strncmp(arg, "ntsc-", 5)) {
3439 norm = 1;
3440 arg += 5;
3441 } else if(!strncmp(arg, "film-", 5)) {
3442 norm = 2;
3443 arg += 5;
3444 } else {
3445 int fr;
3446 /* Calculate FR via float to avoid int overflow */
3447 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3448 if(fr == 25000) {
3449 norm = 0;
3450 } else if((fr == 29970) || (fr == 23976)) {
3451 norm = 1;
3452 } else {
3453 /* Try to determine PAL/NTSC by peeking in the input files */
3454 if(nb_input_files) {
3455 int i, j;
3456 for(j = 0; j < nb_input_files; j++) {
3457 for(i = 0; i < input_files[j]->nb_streams; i++) {
3458 AVCodecContext *c = input_files[j]->streams[i]->codec;
3459 if(c->codec_type != CODEC_TYPE_VIDEO)
3460 continue;
3461 fr = c->time_base.den * 1000 / c->time_base.num;
3462 if(fr == 25000) {
3463 norm = 0;
3464 break;
3465 } else if((fr == 29970) || (fr == 23976)) {
3466 norm = 1;
3467 break;
3468 }
3469 }
3470 if(norm >= 0)
3471 break;
3472 }
3473 }
3474 }
3475 if(verbose && norm >= 0)
3476 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3477 }
3478
3479 if(norm < 0) {
3480 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3481 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3482 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3483 av_exit(1);
3484 }
3485
3486 if(!strcmp(arg, "vcd")) {
3487
3488 opt_video_codec("mpeg1video");
3489 opt_audio_codec("mp2");
3490 opt_format("vcd");
3491
3492 opt_frame_size(norm ? "352x240" : "352x288");
3493 opt_frame_rate(frame_rates[norm]);
3494 opt_default("gop", norm ? "18" : "15");
3495
3496 opt_default("b", "1150000");
3497 opt_default("maxrate", "1150000");
3498 opt_default("minrate", "1150000");
3499 opt_default("bufsize", "327680"); // 40*1024*8;
3500
3501 opt_default("ab", "224000");
3502 audio_sample_rate = 44100;
3503 audio_channels = 2;
3504
3505 opt_default("packetsize", "2324");
3506 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3507
3508 /* We have to offset the PTS, so that it is consistent with the SCR.
3509 SCR starts at 36000, but the first two packs contain only padding
3510 and the first pack from the other stream, respectively, may also have
3511 been written before.
3512 So the real data starts at SCR 36000+3*1200. */
3513 mux_preload= (36000+3*1200) / 90000.0; //0.44
3514 } else if(!strcmp(arg, "svcd")) {
3515
3516 opt_video_codec("mpeg2video");
3517 opt_audio_codec("mp2");
3518 opt_format("svcd");
3519
3520 opt_frame_size(norm ? "480x480" : "480x576");
3521 opt_frame_rate(frame_rates[norm]);
3522 opt_default("gop", norm ? "18" : "15");
3523
3524 opt_default("b", "2040000");
3525 opt_default("maxrate", "2516000");
3526 opt_default("minrate", "0"); //1145000;
3527 opt_default("bufsize", "1835008"); //224*1024*8;
3528 opt_default("flags", "+SCAN_OFFSET");
3529
3530
3531 opt_default("ab", "224000");
3532 audio_sample_rate = 44100;
3533
3534 opt_default("packetsize", "2324");
3535
3536 } else if(!strcmp(arg, "dvd")) {
3537
3538 opt_video_codec("mpeg2video");
3539 opt_audio_codec("ac3");
3540 opt_format("dvd");
3541
3542 opt_frame_size(norm ? "720x480" : "720x576");
3543 opt_frame_rate(frame_rates[norm]);
3544 opt_default("gop", norm ? "18" : "15");
3545
3546 opt_default("b", "6000000");
3547 opt_default("maxrate", "9000000");
3548 opt_default("minrate", "0"); //1500000;
3549 opt_default("bufsize", "1835008"); //224*1024*8;
3550
3551 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3552 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3553
3554 opt_default("ab", "448000");
3555 audio_sample_rate = 48000;
3556
3557 } else if(!strncmp(arg, "dv", 2)) {
3558
3559 opt_format("dv");
3560
3561 opt_frame_size(norm ? "720x480" : "720x576");
3562 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3563 (norm ? "yuv411p" : "yuv420p"));
3564 opt_frame_rate(frame_rates[norm]);
3565
3566 audio_sample_rate = 48000;
3567 audio_channels = 2;
3568
3569 } else {
3570 fprintf(stderr, "Unknown target: %s\n", arg);
3571 av_exit(1);
3572 }
3573 }
3574
3575 static void opt_vstats_file (const char *arg)
3576 {
3577 av_free (vstats_filename);
3578 vstats_filename=av_strdup (arg);
3579 }
3580
3581 static void opt_vstats (void)
3582 {
3583 char filename[40];
3584 time_t today2 = time(NULL);
3585 struct tm *today = localtime(&today2);
3586
3587 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3588 today->tm_sec);
3589 opt_vstats_file(filename);
3590 }
3591
3592 static int opt_bsf(const char *opt, const char *arg)
3593 {
3594 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3595 AVBitStreamFilterContext **bsfp;
3596
3597 if(!bsfc){
3598 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3599 av_exit(1);
3600 }
3601
3602 bsfp= *opt == 'v' ? &video_bitstream_filters :
3603 *opt == 'a' ? &audio_bitstream_filters :
3604 &subtitle_bitstream_filters;
3605 while(*bsfp)
3606 bsfp= &(*bsfp)->next;
3607
3608 *bsfp= bsfc;
3609
3610 return 0;
3611 }
3612
3613 static int opt_preset(const char *opt, const char *arg)
3614 {
3615 FILE *f=NULL;
3616 char tmp[1000], tmp2[1000];
3617 int i;
3618 const char *base[3]= { getenv("HOME"),
3619 "/usr/local/share",
3620 "/usr/share",
3621 };
3622
3623 for(i=!base[0]; i<3 && !f; i++){
3624 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3625 f= fopen(tmp, "r");
3626 if(!f){
3627 char *codec_name= *opt == 'v' ? video_codec_name :
3628 *opt == 'a' ? audio_codec_name :
3629 subtitle_codec_name;
3630 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg);
3631 f= fopen(tmp, "r");
3632 }
3633 }
3634
3635 if(!f){
3636 fprintf(stderr, "Preset file not found\n");
3637 av_exit(1);
3638 }
3639
3640 while(!feof(f)){
3641 int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3642 if(e!=2){
3643 fprintf(stderr, "Preset file invalid\n");
3644 av_exit(1);
3645 }
3646 if(!strcmp(tmp, "acodec")){
3647 opt_audio_codec(tmp2);
3648 }else if(!strcmp(tmp, "vcodec")){
3649 opt_video_codec(tmp2);
3650 }else if(!strcmp(tmp, "scodec")){
3651 opt_subtitle_codec(tmp2);
3652 }else
3653 opt_default(tmp, tmp2);
3654 }
3655
3656 fclose(f);
3657
3658 return 0;
3659 }
3660
3661 static const OptionDef options[] = {
3662 /* main options */
3663 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3664 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3665 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3666 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3667 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3668 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3669 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3670 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3671 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3672 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3673 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3674 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3675 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3676 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3677 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3678 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3679 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3680 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3681 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3682 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3683 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3684 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3685 "add timings for benchmarking" },
3686 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3687 "dump each input packet" },
3688 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3689 "when dumping packets, also dump the payload" },
3690 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3691 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3692 { "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)", "" },
3693 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3694 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3695 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3696 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3697 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3698 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3699 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3700 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3701 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3702 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3703 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3704
3705 /* video options */
3706 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3707 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3708 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3709 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3710 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3711 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3712 { "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" },
3713 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3714 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3715 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3716 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3717 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3718 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3719 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3720 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3721 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3722 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3723 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3724 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3725 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3726 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3727 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3728 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3729 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3730 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3731 "use same video quality as source (implies VBR)" },
3732 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3733 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3734 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3735 "deinterlace pictures" },
3736 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3737 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3738 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3739 #ifdef CONFIG_VHOOK
3740 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3741 #endif
3742 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3743 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3744 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3745 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3746 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3747 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3748 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3749
3750 /* audio options */
3751 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3752 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3753 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3754 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3755 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3756 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3757 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3758 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3759 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3760 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3761 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3762
3763 /* subtitle options */
3764 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3765 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3766 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3767 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3768
3769 /* grab options */
3770 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3771 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3772 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3773
3774 /* muxer options */
3775 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3776 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3777
3778 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3779 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3780 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3781
3782 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3783 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3784 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3785
3786 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3787 { NULL, },
3788 };
3789
3790 int main(int argc, char **argv)
3791 {
3792 int i;
3793 int64_t ti;
3794
3795 avcodec_register_all();
3796 avdevice_register_all();
3797 av_register_all();
3798
3799 if(isatty(STDIN_FILENO))
3800 url_set_interrupt_cb(decode_interrupt_cb);
3801
3802 for(i=0; i<CODEC_TYPE_NB; i++){
3803 avctx_opts[i]= avcodec_alloc_context2(i);
3804 }
3805 avformat_opts = av_alloc_format_context();
3806 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3807
3808 show_banner();
3809 if (argc <= 1) {
3810 show_help();
3811 av_exit(1);
3812 }
3813
3814 /* parse options */
3815 parse_options(argc, argv, options, opt_output_file);
3816
3817 /* file converter / grab */
3818 if (nb_output_files <= 0) {
3819 fprintf(stderr, "Must supply at least one output file\n");
3820 av_exit(1);
3821 }
3822
3823 if (nb_input_files == 0) {
3824 fprintf(stderr, "Must supply at least one input file\n");
3825 av_exit(1);
3826 }
3827
3828 ti = getutime();
3829 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3830 stream_maps, nb_stream_maps);
3831 ti = getutime() - ti;
3832 if (do_benchmark) {
3833 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3834 }
3835
3836 return av_exit(0);
3837 }
VDPAU for FFmpeg