?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make ffmpeg.c:opt_thread use parse_number_or_die().
[FFMpeg-mirror/DVCPRO-HD.git] / ffmpeg.c
blob4490320d26a1f62c46877f8ae48ebb35ef5a979c
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 int video_qdiff = 3;
118 static uint16_t *intra_matrix = NULL;
119 static uint16_t *inter_matrix = NULL;
120 #if 0 //experimental, (can be removed)
121 static float video_rc_qsquish=1.0;
122 static float video_rc_qmod_amp=0;
123 static int video_rc_qmod_freq=0;
124 #endif
125 static const char *video_rc_override_string=NULL;
126 static int video_disable = 0;
127 static int video_discard = 0;
128 static char *video_codec_name = NULL;
129 static int video_codec_tag = 0;
130 static int same_quality = 0;
131 static int do_deinterlace = 0;
132 static int strict = 0;
133 static int top_field_first = -1;
134 static int me_threshold = 0;
135 static int intra_dc_precision = 8;
136 static int loop_input = 0;
137 static int loop_output = AVFMT_NOOUTPUTLOOP;
138 static int qp_hist = 0;
139
140 static int intra_only = 0;
141 static int audio_sample_rate = 44100;
142 #define QSCALE_NONE -99999
143 static float audio_qscale = QSCALE_NONE;
144 static int audio_disable = 0;
145 static int audio_channels = 1;
146 static char *audio_codec_name = NULL;
147 static int audio_codec_tag = 0;
148 static char *audio_language = NULL;
149
150 static int subtitle_disable = 0;
151 static char *subtitle_codec_name = NULL;
152 static char *subtitle_language = NULL;
153
154 static float mux_preload= 0.5;
155 static float mux_max_delay= 0.7;
156
157 static int64_t recording_time = 0;
158 static int64_t start_time = 0;
159 static int64_t rec_timestamp = 0;
160 static int64_t input_ts_offset = 0;
161 static int file_overwrite = 0;
162 static char *str_title = NULL;
163 static char *str_author = NULL;
164 static char *str_copyright = NULL;
165 static char *str_comment = NULL;
166 static char *str_genre = NULL;
167 static char *str_album = NULL;
168 static int do_benchmark = 0;
169 static int do_hex_dump = 0;
170 static int do_pkt_dump = 0;
171 static int do_psnr = 0;
172 static int do_pass = 0;
173 static char *pass_logfilename = NULL;
174 static int audio_stream_copy = 0;
175 static int video_stream_copy = 0;
176 static int subtitle_stream_copy = 0;
177 static int video_sync_method= 1;
178 static int audio_sync_method= 0;
179 static float audio_drift_threshold= 0.1;
180 static int copy_ts= 0;
181 static int opt_shortest = 0; //
182 static int video_global_header = 0;
183 static char *vstats_filename;
184 static FILE *vstats_file;
185 static int opt_programid = 0;
186
187 static int rate_emu = 0;
188
189 static int video_channel = 0;
190 static char *video_standard;
191
192 static int audio_volume = 256;
193
194 static int using_stdin = 0;
195 static int using_vhook = 0;
196 static int verbose = 1;
197 static int thread_count= 1;
198 static int q_pressed = 0;
199 static int64_t video_size = 0;
200 static int64_t audio_size = 0;
201 static int64_t extra_size = 0;
202 static int nb_frames_dup = 0;
203 static int nb_frames_drop = 0;
204 static int input_sync;
205 static uint64_t limit_filesize = 0; //
206
207 static int pgmyuv_compatibility_hack=0;
208 static float dts_delta_threshold = 10;
209
210 static unsigned int sws_flags = SWS_BICUBIC;
211
212 static const char **opt_names;
213 static int opt_name_count;
214 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
215 static AVFormatContext *avformat_opts;
216 static struct SwsContext *sws_opts;
217 static int64_t timer_start;
218
219 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
220 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
221 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
222 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
223
224 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
225
226 struct AVInputStream;
227
228 typedef struct AVOutputStream {
229 int file_index; /* file index */
230 int index; /* stream index in the output file */
231 int source_index; /* AVInputStream index */
232 AVStream *st; /* stream in the output file */
233 int encoding_needed; /* true if encoding needed for this stream */
234 int frame_number;
235 /* input pts and corresponding output pts
236 for A/V sync */
237 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
238 struct AVInputStream *sync_ist; /* input stream to sync against */
239 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
240 /* video only */
241 int video_resample;
242 AVFrame pict_tmp; /* temporary image for resampling */
243 struct SwsContext *img_resample_ctx; /* for image resampling */
244 int resample_height;
245
246 int video_crop;
247 int topBand; /* cropping area sizes */
248 int leftBand;
249
250 int video_pad;
251 int padtop; /* padding area sizes */
252 int padbottom;
253 int padleft;
254 int padright;
255
256 /* audio only */
257 int audio_resample;
258 ReSampleContext *resample; /* for audio resampling */
259 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
260 FILE *logfile;
261 } AVOutputStream;
262
263 typedef struct AVInputStream {
264 int file_index;
265 int index;
266 AVStream *st;
267 int discard; /* true if stream data should be discarded */
268 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
269 int64_t sample_index; /* current sample */
270
271 int64_t start; /* time when read started */
272 unsigned long frame; /* current frame */
273 int64_t next_pts; /* synthetic pts for cases where pkt.pts
274 is not defined */
275 int64_t pts; /* current pts */
276 int is_start; /* is 1 at the start and after a discontinuity */
277 } AVInputStream;
278
279 typedef struct AVInputFile {
280 int eof_reached; /* true if eof reached */
281 int ist_index; /* index of first stream in ist_table */
282 int buffer_size; /* current total buffer size */
283 int nb_streams; /* nb streams we are aware of */
284 } AVInputFile;
285
286 #ifdef HAVE_TERMIOS_H
287
288 /* init terminal so that we can grab keys */
289 static struct termios oldtty;
290 #endif
291
292 static void term_exit(void)
293 {
294 #ifdef HAVE_TERMIOS_H
295 tcsetattr (0, TCSANOW, &oldtty);
296 #endif
297 }
298
299 static volatile sig_atomic_t received_sigterm = 0;
300
301 static void
302 sigterm_handler(int sig)
303 {
304 received_sigterm = sig;
305 term_exit();
306 }
307
308 static void term_init(void)
309 {
310 #ifdef HAVE_TERMIOS_H
311 struct termios tty;
312
313 tcgetattr (0, &tty);
314 oldtty = tty;
315
316 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
317 |INLCR|IGNCR|ICRNL|IXON);
318 tty.c_oflag |= OPOST;
319 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
320 tty.c_cflag &= ~(CSIZE|PARENB);
321 tty.c_cflag |= CS8;
322 tty.c_cc[VMIN] = 1;
323 tty.c_cc[VTIME] = 0;
324
325 tcsetattr (0, TCSANOW, &tty);
326 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
327 #endif
328
329 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
330 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
331 /*
332 register a function to be called at normal program termination
333 */
334 atexit(term_exit);
335 #ifdef CONFIG_BEOS_NETSERVER
336 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
337 #endif
338 }
339
340 /* read a key without blocking */
341 static int read_key(void)
342 {
343 #if defined(HAVE_TERMIOS_H)
344 int n = 1;
345 unsigned char ch;
346 #ifndef CONFIG_BEOS_NETSERVER
347 struct timeval tv;
348 fd_set rfds;
349
350 FD_ZERO(&rfds);
351 FD_SET(0, &rfds);
352 tv.tv_sec = 0;
353 tv.tv_usec = 0;
354 n = select(1, &rfds, NULL, NULL, &tv);
355 #endif
356 if (n > 0) {
357 n = read(0, &ch, 1);
358 if (n == 1)
359 return ch;
360
361 return n;
362 }
363 #elif defined(HAVE_CONIO_H)
364 if(kbhit())
365 return(getch());
366 #endif
367 return -1;
368 }
369
370 static int decode_interrupt_cb(void)
371 {
372 return q_pressed || (q_pressed = read_key() == 'q');
373 }
374
375 static int av_exit(int ret)
376 {
377 int i;
378
379 /* close files */
380 for(i=0;i<nb_output_files;i++) {
381 /* maybe av_close_output_file ??? */
382 AVFormatContext *s = output_files[i];
383 int j;
384 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
385 url_fclose(s->pb);
386 for(j=0;j<s->nb_streams;j++) {
387 av_free(s->streams[j]->codec);
388 av_free(s->streams[j]);
389 }
390 av_free(s);
391 }
392 for(i=0;i<nb_input_files;i++)
393 av_close_input_file(input_files[i]);
394
395 av_free(intra_matrix);
396 av_free(inter_matrix);
397
398 if (vstats_file)
399 fclose(vstats_file);
400 av_free(vstats_filename);
401
402 av_free(opt_names);
403
404 av_free(video_codec_name);
405 av_free(audio_codec_name);
406 av_free(subtitle_codec_name);
407
408 av_free(video_standard);
409
410 #ifdef CONFIG_POWERPC_PERF
411 extern void powerpc_display_perf_report(void);
412 powerpc_display_perf_report();
413 #endif /* CONFIG_POWERPC_PERF */
414
415 if (received_sigterm) {
416 fprintf(stderr,
417 "Received signal %d: terminating.\n",
418 (int) received_sigterm);
419 exit (255);
420 }
421
422 exit(ret); /* not all OS-es handle main() return value */
423 return ret;
424 }
425
426 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
427 {
428 int i, err;
429 AVFormatContext *ic;
430 int nopts = 0;
431
432 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
433 if (err < 0)
434 return err;
435 /* copy stream format */
436 s->nb_streams = ic->nb_streams;
437 for(i=0;i<ic->nb_streams;i++) {
438 AVStream *st;
439
440 // FIXME: a more elegant solution is needed
441 st = av_mallocz(sizeof(AVStream));
442 memcpy(st, ic->streams[i], sizeof(AVStream));
443 st->codec = avcodec_alloc_context();
444 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
445 s->streams[i] = st;
446
447 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
448 st->stream_copy = 1;
449 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
450 st->stream_copy = 1;
451
452 if(st->codec->flags & CODEC_FLAG_BITEXACT)
453 nopts = 1;
454 }
455
456 if (!nopts)
457 s->timestamp = av_gettime();
458
459 av_close_input_file(ic);
460 return 0;
461 }
462
463 static double
464 get_sync_ipts(const AVOutputStream *ost)
465 {
466 const AVInputStream *ist = ost->sync_ist;
467 return (double)(ist->pts - start_time)/AV_TIME_BASE;
468 }
469
470 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
471 int ret;
472
473 while(bsfc){
474 AVPacket new_pkt= *pkt;
475 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
476 &new_pkt.data, &new_pkt.size,
477 pkt->data, pkt->size,
478 pkt->flags & PKT_FLAG_KEY);
479 if(a>0){
480 av_free_packet(pkt);
481 new_pkt.destruct= av_destruct_packet;
482 } else if(a<0){
483 fprintf(stderr, "%s failed for stream %d, codec %s",
484 bsfc->filter->name, pkt->stream_index,
485 avctx->codec ? avctx->codec->name : "copy");
486 print_error("", a);
487 }
488 *pkt= new_pkt;
489
490 bsfc= bsfc->next;
491 }
492
493 ret= av_interleaved_write_frame(s, pkt);
494 if(ret < 0){
495 print_error("av_interleaved_write_frame()", ret);
496 av_exit(1);
497 }
498 }
499
500 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
501
502 static void do_audio_out(AVFormatContext *s,
503 AVOutputStream *ost,
504 AVInputStream *ist,
505 unsigned char *buf, int size)
506 {
507 uint8_t *buftmp;
508 static uint8_t *audio_buf = NULL;
509 static uint8_t *audio_out = NULL;
510 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
511
512 int size_out, frame_bytes, ret;
513 AVCodecContext *enc= ost->st->codec;
514 AVCodecContext *dec= ist->st->codec;
515
516 /* SC: dynamic allocation of buffers */
517 if (!audio_buf)
518 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
519 if (!audio_out)
520 audio_out = av_malloc(audio_out_size);
521 if (!audio_buf || !audio_out)
522 return; /* Should signal an error ! */
523
524 if (enc->channels != dec->channels)
525 ost->audio_resample = 1;
526
527 if (ost->audio_resample && !ost->resample) {
528 ost->resample = audio_resample_init(enc->channels, dec->channels,
529 enc->sample_rate, dec->sample_rate);
530 if (!ost->resample) {
531 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
532 dec->channels, dec->sample_rate,
533 enc->channels, enc->sample_rate);
534 av_exit(1);
535 }
536 }
537
538 if(audio_sync_method){
539 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
540 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
541 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
542 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
543
544 //FIXME resample delay
545 if(fabs(delta) > 50){
546 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
547 if(byte_delta < 0){
548 byte_delta= FFMAX(byte_delta, -size);
549 size += byte_delta;
550 buf -= byte_delta;
551 if(verbose > 2)
552 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
553 if(!size)
554 return;
555 ist->is_start=0;
556 }else{
557 static uint8_t *input_tmp= NULL;
558 input_tmp= av_realloc(input_tmp, byte_delta + size);
559
560 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
561 ist->is_start=0;
562 else
563 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
564
565 memset(input_tmp, 0, byte_delta);
566 memcpy(input_tmp + byte_delta, buf, size);
567 buf= input_tmp;
568 size += byte_delta;
569 if(verbose > 2)
570 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
571 }
572 }else if(audio_sync_method>1){
573 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
574 assert(ost->audio_resample);
575 if(verbose > 2)
576 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
577 // 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));
578 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
579 }
580 }
581 }else
582 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
583 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
584
585 if (ost->audio_resample) {
586 buftmp = audio_buf;
587 size_out = audio_resample(ost->resample,
588 (short *)buftmp, (short *)buf,
589 size / (ist->st->codec->channels * 2));
590 size_out = size_out * enc->channels * 2;
591 } else {
592 buftmp = buf;
593 size_out = size;
594 }
595
596 /* now encode as many frames as possible */
597 if (enc->frame_size > 1) {
598 /* output resampled raw samples */
599 av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
600 av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
601
602 frame_bytes = enc->frame_size * 2 * enc->channels;
603
604 while (av_fifo_size(&ost->fifo) >= frame_bytes) {
605 AVPacket pkt;
606 av_init_packet(&pkt);
607
608 av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
609
610 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
611
612 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
613 (short *)audio_buf);
614 audio_size += ret;
615 pkt.stream_index= ost->index;
616 pkt.data= audio_out;
617 pkt.size= ret;
618 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
619 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
620 pkt.flags |= PKT_FLAG_KEY;
621 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
622
623 ost->sync_opts += enc->frame_size;
624 }
625 } else {
626 AVPacket pkt;
627 av_init_packet(&pkt);
628
629 ost->sync_opts += size_out / (2 * enc->channels);
630
631 /* output a pcm frame */
632 /* XXX: change encoding codec API to avoid this ? */
633 switch(enc->codec->id) {
634 case CODEC_ID_PCM_S32LE:
635 case CODEC_ID_PCM_S32BE:
636 case CODEC_ID_PCM_U32LE:
637 case CODEC_ID_PCM_U32BE:
638 size_out = size_out << 1;
639 break;
640 case CODEC_ID_PCM_S24LE:
641 case CODEC_ID_PCM_S24BE:
642 case CODEC_ID_PCM_U24LE:
643 case CODEC_ID_PCM_U24BE:
644 case CODEC_ID_PCM_S24DAUD:
645 size_out = size_out / 2 * 3;
646 break;
647 case CODEC_ID_PCM_S16LE:
648 case CODEC_ID_PCM_S16BE:
649 case CODEC_ID_PCM_U16LE:
650 case CODEC_ID_PCM_U16BE:
651 break;
652 default:
653 size_out = size_out >> 1;
654 break;
655 }
656 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
657 ret = avcodec_encode_audio(enc, audio_out, size_out,
658 (short *)buftmp);
659 audio_size += ret;
660 pkt.stream_index= ost->index;
661 pkt.data= audio_out;
662 pkt.size= ret;
663 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
664 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
665 pkt.flags |= PKT_FLAG_KEY;
666 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
667 }
668 }
669
670 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
671 {
672 AVCodecContext *dec;
673 AVPicture *picture2;
674 AVPicture picture_tmp;
675 uint8_t *buf = 0;
676
677 dec = ist->st->codec;
678
679 /* deinterlace : must be done before any resize */
680 if (do_deinterlace || using_vhook) {
681 int size;
682
683 /* create temporary picture */
684 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
685 buf = av_malloc(size);
686 if (!buf)
687 return;
688
689 picture2 = &picture_tmp;
690 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
691
692 if (do_deinterlace){
693 if(avpicture_deinterlace(picture2, picture,
694 dec->pix_fmt, dec->width, dec->height) < 0) {
695 /* if error, do not deinterlace */
696 av_free(buf);
697 buf = NULL;
698 picture2 = picture;
699 }
700 } else {
701 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
702 }
703 } else {
704 picture2 = picture;
705 }
706
707 if (ENABLE_VHOOK)
708 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
709 1000000 * ist->pts / AV_TIME_BASE);
710
711 if (picture != picture2)
712 *picture = *picture2;
713 *bufp = buf;
714 }
715
716 /* we begin to correct av delay at this threshold */
717 #define AV_DELAY_MAX 0.100
718
719 static void do_subtitle_out(AVFormatContext *s,
720 AVOutputStream *ost,
721 AVInputStream *ist,
722 AVSubtitle *sub,
723 int64_t pts)
724 {
725 static uint8_t *subtitle_out = NULL;
726 int subtitle_out_max_size = 65536;
727 int subtitle_out_size, nb, i;
728 AVCodecContext *enc;
729 AVPacket pkt;
730
731 if (pts == AV_NOPTS_VALUE) {
732 fprintf(stderr, "Subtitle packets must have a pts\n");
733 return;
734 }
735
736 enc = ost->st->codec;
737
738 if (!subtitle_out) {
739 subtitle_out = av_malloc(subtitle_out_max_size);
740 }
741
742 /* Note: DVB subtitle need one packet to draw them and one other
743 packet to clear them */
744 /* XXX: signal it in the codec context ? */
745 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
746 nb = 2;
747 else
748 nb = 1;
749
750 for(i = 0; i < nb; i++) {
751 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
752 subtitle_out_max_size, sub);
753
754 av_init_packet(&pkt);
755 pkt.stream_index = ost->index;
756 pkt.data = subtitle_out;
757 pkt.size = subtitle_out_size;
758 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
759 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
760 /* XXX: the pts correction is handled here. Maybe handling
761 it in the codec would be better */
762 if (i == 0)
763 pkt.pts += 90 * sub->start_display_time;
764 else
765 pkt.pts += 90 * sub->end_display_time;
766 }
767 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
768 }
769 }
770
771 static int bit_buffer_size= 1024*256;
772 static uint8_t *bit_buffer= NULL;
773
774 static void do_video_out(AVFormatContext *s,
775 AVOutputStream *ost,
776 AVInputStream *ist,
777 AVFrame *in_picture,
778 int *frame_size)
779 {
780 int nb_frames, i, ret;
781 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
782 AVFrame picture_crop_temp, picture_pad_temp;
783 AVCodecContext *enc, *dec;
784
785 avcodec_get_frame_defaults(&picture_crop_temp);
786 avcodec_get_frame_defaults(&picture_pad_temp);
787
788 enc = ost->st->codec;
789 dec = ist->st->codec;
790
791 /* by default, we output a single frame */
792 nb_frames = 1;
793
794 *frame_size = 0;
795
796 if(video_sync_method){
797 double vdelta;
798 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
799 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
800 if (vdelta < -1.1)
801 nb_frames = 0;
802 else if (video_sync_method == 2)
803 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
804 else if (vdelta > 1.1)
805 nb_frames = lrintf(vdelta);
806 //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);
807 if (nb_frames == 0){
808 ++nb_frames_drop;
809 if (verbose>2)
810 fprintf(stderr, "*** drop!\n");
811 }else if (nb_frames > 1) {
812 nb_frames_dup += nb_frames;
813 if (verbose>2)
814 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
815 }
816 }else
817 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
818
819 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
820 if (nb_frames <= 0)
821 return;
822
823 if (ost->video_crop) {
824 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
825 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
826 return;
827 }
828 formatted_picture = &picture_crop_temp;
829 } else {
830 formatted_picture = in_picture;
831 }
832
833 final_picture = formatted_picture;
834 padding_src = formatted_picture;
835 resampling_dst = &ost->pict_tmp;
836 if (ost->video_pad) {
837 final_picture = &ost->pict_tmp;
838 if (ost->video_resample) {
839 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
840 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
841 return;
842 }
843 resampling_dst = &picture_pad_temp;
844 }
845 }
846
847 if (ost->video_resample) {
848 padding_src = NULL;
849 final_picture = &ost->pict_tmp;
850 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
851 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
852 }
853
854 if (ost->video_pad) {
855 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
856 enc->height, enc->width, enc->pix_fmt,
857 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
858 }
859
860 /* duplicates frame if needed */
861 for(i=0;i<nb_frames;i++) {
862 AVPacket pkt;
863 av_init_packet(&pkt);
864 pkt.stream_index= ost->index;
865
866 if (s->oformat->flags & AVFMT_RAWPICTURE) {
867 /* raw pictures are written as AVPicture structure to
868 avoid any copies. We support temorarily the older
869 method. */
870 AVFrame* old_frame = enc->coded_frame;
871 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
872 pkt.data= (uint8_t *)final_picture;
873 pkt.size= sizeof(AVPicture);
874 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
875 pkt.flags |= PKT_FLAG_KEY;
876
877 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
878 enc->coded_frame = old_frame;
879 } else {
880 AVFrame big_picture;
881
882 big_picture= *final_picture;
883 /* better than nothing: use input picture interlaced
884 settings */
885 big_picture.interlaced_frame = in_picture->interlaced_frame;
886 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
887 if(top_field_first == -1)
888 big_picture.top_field_first = in_picture->top_field_first;
889 else
890 big_picture.top_field_first = top_field_first;
891 }
892
893 /* handles sameq here. This is not correct because it may
894 not be a global option */
895 if (same_quality) {
896 big_picture.quality = ist->st->quality;
897 }else
898 big_picture.quality = ost->st->quality;
899 if(!me_threshold)
900 big_picture.pict_type = 0;
901 // big_picture.pts = AV_NOPTS_VALUE;
902 big_picture.pts= ost->sync_opts;
903 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
904 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
905 ret = avcodec_encode_video(enc,
906 bit_buffer, bit_buffer_size,
907 &big_picture);
908 if (ret == -1) {
909 fprintf(stderr, "Video encoding failed\n");
910 av_exit(1);
911 }
912 //enc->frame_number = enc->real_pict_num;
913 if(ret>0){
914 pkt.data= bit_buffer;
915 pkt.size= ret;
916 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
917 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
918 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
919 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
920 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
921
922 if(enc->coded_frame->key_frame)
923 pkt.flags |= PKT_FLAG_KEY;
924 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
925 *frame_size = ret;
926 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
927 // enc->frame_number-1, enc->real_pict_num, ret,
928 // enc->pict_type);
929 /* if two pass, output log */
930 if (ost->logfile && enc->stats_out) {
931 fprintf(ost->logfile, "%s", enc->stats_out);
932 }
933 }
934 }
935 ost->sync_opts++;
936 ost->frame_number++;
937 }
938 }
939
940 static double psnr(double d){
941 return -10.0*log(d)/log(10.0);
942 }
943
944 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
945 int frame_size)
946 {
947 AVCodecContext *enc;
948 int frame_number;
949 double ti1, bitrate, avg_bitrate;
950
951 /* this is executed just the first time do_video_stats is called */
952 if (!vstats_file) {
953 vstats_file = fopen(vstats_filename, "w");
954 if (!vstats_file) {
955 perror("fopen");
956 av_exit(1);
957 }
958 }
959
960 enc = ost->st->codec;
961 if (enc->codec_type == CODEC_TYPE_VIDEO) {
962 frame_number = ost->frame_number;
963 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
964 if (enc->flags&CODEC_FLAG_PSNR)
965 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
966
967 fprintf(vstats_file,"f_size= %6d ", frame_size);
968 /* compute pts value */
969 ti1 = ost->sync_opts * av_q2d(enc->time_base);
970 if (ti1 < 0.01)
971 ti1 = 0.01;
972
973 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
974 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
975 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
976 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
977 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
978 }
979 }
980
981 static void print_report(AVFormatContext **output_files,
982 AVOutputStream **ost_table, int nb_ostreams,
983 int is_last_report)
984 {
985 char buf[1024];
986 AVOutputStream *ost;
987 AVFormatContext *oc, *os;
988 int64_t total_size;
989 AVCodecContext *enc;
990 int frame_number, vid, i;
991 double bitrate, ti1, pts;
992 static int64_t last_time = -1;
993 static int qp_histogram[52];
994
995 if (!is_last_report) {
996 int64_t cur_time;
997 /* display the report every 0.5 seconds */
998 cur_time = av_gettime();
999 if (last_time == -1) {
1000 last_time = cur_time;
1001 return;
1002 }
1003 if ((cur_time - last_time) < 500000)
1004 return;
1005 last_time = cur_time;
1006 }
1007
1008
1009 oc = output_files[0];
1010
1011 total_size = url_fsize(oc->pb);
1012 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1013 total_size= url_ftell(oc->pb);
1014
1015 buf[0] = '\0';
1016 ti1 = 1e10;
1017 vid = 0;
1018 for(i=0;i<nb_ostreams;i++) {
1019 ost = ost_table[i];
1020 os = output_files[ost->file_index];
1021 enc = ost->st->codec;
1022 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1023 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1024 !ost->st->stream_copy ?
1025 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1026 }
1027 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1028 float t = (av_gettime()-timer_start) / 1000000.0;
1029
1030 frame_number = ost->frame_number;
1031 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1032 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1033 !ost->st->stream_copy ?
1034 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1035 if(is_last_report)
1036 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1037 if(qp_hist){
1038 int j;
1039 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1040 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1041 qp_histogram[qp]++;
1042 for(j=0; j<32; j++)
1043 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1044 }
1045 if (enc->flags&CODEC_FLAG_PSNR){
1046 int j;
1047 double error, error_sum=0;
1048 double scale, scale_sum=0;
1049 char type[3]= {'Y','U','V'};
1050 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1051 for(j=0; j<3; j++){
1052 if(is_last_report){
1053 error= enc->error[j];
1054 scale= enc->width*enc->height*255.0*255.0*frame_number;
1055 }else{
1056 error= enc->coded_frame->error[j];
1057 scale= enc->width*enc->height*255.0*255.0;
1058 }
1059 if(j) scale/=4;
1060 error_sum += error;
1061 scale_sum += scale;
1062 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1063 }
1064 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1065 }
1066 vid = 1;
1067 }
1068 /* compute min output value */
1069 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1070 if ((pts < ti1) && (pts > 0))
1071 ti1 = pts;
1072 }
1073 if (ti1 < 0.01)
1074 ti1 = 0.01;
1075
1076 if (verbose || is_last_report) {
1077 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1078
1079 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1080 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1081 (double)total_size / 1024, ti1, bitrate);
1082
1083 if (verbose > 1)
1084 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1085 nb_frames_dup, nb_frames_drop);
1086
1087 if (verbose >= 0)
1088 fprintf(stderr, "%s \r", buf);
1089
1090 fflush(stderr);
1091 }
1092
1093 if (is_last_report && verbose >= 0){
1094 int64_t raw= audio_size + video_size + extra_size;
1095 fprintf(stderr, "\n");
1096 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1097 video_size/1024.0,
1098 audio_size/1024.0,
1099 extra_size/1024.0,
1100 100.0*(total_size - raw)/raw
1101 );
1102 }
1103 }
1104
1105 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1106 static int output_packet(AVInputStream *ist, int ist_index,
1107 AVOutputStream **ost_table, int nb_ostreams,
1108 const AVPacket *pkt)
1109 {
1110 AVFormatContext *os;
1111 AVOutputStream *ost;
1112 uint8_t *ptr;
1113 int len, ret, i;
1114 uint8_t *data_buf;
1115 int data_size, got_picture;
1116 AVFrame picture;
1117 void *buffer_to_free;
1118 static unsigned int samples_size= 0;
1119 static short *samples= NULL;
1120 AVSubtitle subtitle, *subtitle_to_free;
1121 int got_subtitle;
1122
1123 if(ist->next_pts == AV_NOPTS_VALUE)
1124 ist->next_pts= ist->pts;
1125
1126 if (pkt == NULL) {
1127 /* EOF handling */
1128 ptr = NULL;
1129 len = 0;
1130 goto handle_eof;
1131 }
1132
1133 if(pkt->dts != AV_NOPTS_VALUE)
1134 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1135
1136 len = pkt->size;
1137 ptr = pkt->data;
1138 while (len > 0) {
1139 handle_eof:
1140 ist->pts= ist->next_pts;
1141
1142 if(len && len != pkt->size && verbose>0)
1143 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1144
1145 /* decode the packet if needed */
1146 data_buf = NULL; /* fail safe */
1147 data_size = 0;
1148 subtitle_to_free = NULL;
1149 if (ist->decoding_needed) {
1150 switch(ist->st->codec->codec_type) {
1151 case CODEC_TYPE_AUDIO:{
1152 if(pkt)
1153 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1154 data_size= samples_size;
1155 /* XXX: could avoid copy if PCM 16 bits with same
1156 endianness as CPU */
1157 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1158 ptr, len);
1159 if (ret < 0)
1160 goto fail_decode;
1161 ptr += ret;
1162 len -= ret;
1163 /* Some bug in mpeg audio decoder gives */
1164 /* data_size < 0, it seems they are overflows */
1165 if (data_size <= 0) {
1166 /* no audio frame */
1167 continue;
1168 }
1169 data_buf = (uint8_t *)samples;
1170 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1171 (ist->st->codec->sample_rate * ist->st->codec->channels);
1172 break;}
1173 case CODEC_TYPE_VIDEO:
1174 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1175 /* XXX: allocate picture correctly */
1176 avcodec_get_frame_defaults(&picture);
1177
1178 ret = avcodec_decode_video(ist->st->codec,
1179 &picture, &got_picture, ptr, len);
1180 ist->st->quality= picture.quality;
1181 if (ret < 0)
1182 goto fail_decode;
1183 if (!got_picture) {
1184 /* no picture yet */
1185 goto discard_packet;
1186 }
1187 if (ist->st->codec->time_base.num != 0) {
1188 ist->next_pts += ((int64_t)AV_TIME_BASE *
1189 ist->st->codec->time_base.num) /
1190 ist->st->codec->time_base.den;
1191 }
1192 len = 0;
1193 break;
1194 case CODEC_TYPE_SUBTITLE:
1195 ret = avcodec_decode_subtitle(ist->st->codec,
1196 &subtitle, &got_subtitle, ptr, len);
1197 if (ret < 0)
1198 goto fail_decode;
1199 if (!got_subtitle) {
1200 goto discard_packet;
1201 }
1202 subtitle_to_free = &subtitle;
1203 len = 0;
1204 break;
1205 default:
1206 goto fail_decode;
1207 }
1208 } else {
1209 switch(ist->st->codec->codec_type) {
1210 case CODEC_TYPE_AUDIO:
1211 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1212 ist->st->codec->sample_rate;
1213 break;
1214 case CODEC_TYPE_VIDEO:
1215 if (ist->st->codec->time_base.num != 0) {
1216 ist->next_pts += ((int64_t)AV_TIME_BASE *
1217 ist->st->codec->time_base.num) /
1218 ist->st->codec->time_base.den;
1219 }
1220 break;
1221 }
1222 data_buf = ptr;
1223 data_size = len;
1224 ret = len;
1225 len = 0;
1226 }
1227
1228 buffer_to_free = NULL;
1229 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1230 pre_process_video_frame(ist, (AVPicture *)&picture,
1231 &buffer_to_free);
1232 }
1233
1234 // preprocess audio (volume)
1235 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1236 if (audio_volume != 256) {
1237 short *volp;
1238 volp = samples;
1239 for(i=0;i<(data_size / sizeof(short));i++) {
1240 int v = ((*volp) * audio_volume + 128) >> 8;
1241 if (v < -32768) v = -32768;
1242 if (v > 32767) v = 32767;
1243 *volp++ = v;
1244 }
1245 }
1246 }
1247
1248 /* frame rate emulation */
1249 if (ist->st->codec->rate_emu) {
1250 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1251 int64_t now = av_gettime() - ist->start;
1252 if (pts > now)
1253 usleep(pts - now);
1254
1255 ist->frame++;
1256 }
1257
1258 #if 0
1259 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1260 is the one of the next displayed one */
1261 /* XXX: add mpeg4 too ? */
1262 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1263 if (ist->st->codec->pict_type != B_TYPE) {
1264 int64_t tmp;
1265 tmp = ist->last_ip_pts;
1266 ist->last_ip_pts = ist->frac_pts.val;
1267 ist->frac_pts.val = tmp;
1268 }
1269 }
1270 #endif
1271 /* if output time reached then transcode raw format,
1272 encode packets and output them */
1273 if (start_time == 0 || ist->pts >= start_time)
1274 for(i=0;i<nb_ostreams;i++) {
1275 int frame_size;
1276
1277 ost = ost_table[i];
1278 if (ost->source_index == ist_index) {
1279 os = output_files[ost->file_index];
1280
1281 #if 0
1282 printf("%d: got pts=%0.3f %0.3f\n", i,
1283 (double)pkt->pts / AV_TIME_BASE,
1284 ((double)ist->pts / AV_TIME_BASE) -
1285 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1286 #endif
1287 /* set the input output pts pairs */
1288 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1289
1290 if (ost->encoding_needed) {
1291 switch(ost->st->codec->codec_type) {
1292 case CODEC_TYPE_AUDIO:
1293 do_audio_out(os, ost, ist, data_buf, data_size);
1294 break;
1295 case CODEC_TYPE_VIDEO:
1296 do_video_out(os, ost, ist, &picture, &frame_size);
1297 video_size += frame_size;
1298 if (vstats_filename && frame_size)
1299 do_video_stats(os, ost, frame_size);
1300 break;
1301 case CODEC_TYPE_SUBTITLE:
1302 do_subtitle_out(os, ost, ist, &subtitle,
1303 pkt->pts);
1304 break;
1305 default:
1306 abort();
1307 }
1308 } else {
1309 AVFrame avframe; //FIXME/XXX remove this
1310 AVPacket opkt;
1311 av_init_packet(&opkt);
1312
1313 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1314 continue;
1315
1316 /* no reencoding needed : output the packet directly */
1317 /* force the input stream PTS */
1318
1319 avcodec_get_frame_defaults(&avframe);
1320 ost->st->codec->coded_frame= &avframe;
1321 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1322
1323 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1324 audio_size += data_size;
1325 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1326 video_size += data_size;
1327 ost->sync_opts++;
1328 }
1329
1330 opkt.stream_index= ost->index;
1331 if(pkt->pts != AV_NOPTS_VALUE)
1332 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1333 else
1334 opkt.pts= AV_NOPTS_VALUE;
1335
1336 if (pkt->dts == AV_NOPTS_VALUE)
1337 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1338 else
1339 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1340
1341 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1342 opkt.flags= pkt->flags;
1343
1344 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1345 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1346 opkt.destruct= av_destruct_packet;
1347
1348 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1349 ost->st->codec->frame_number++;
1350 ost->frame_number++;
1351 av_free_packet(&opkt);
1352 }
1353 }
1354 }
1355 av_free(buffer_to_free);
1356 /* XXX: allocate the subtitles in the codec ? */
1357 if (subtitle_to_free) {
1358 if (subtitle_to_free->rects != NULL) {
1359 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1360 av_free(subtitle_to_free->rects[i].bitmap);
1361 av_free(subtitle_to_free->rects[i].rgba_palette);
1362 }
1363 av_freep(&subtitle_to_free->rects);
1364 }
1365 subtitle_to_free->num_rects = 0;
1366 subtitle_to_free = NULL;
1367 }
1368 }
1369 discard_packet:
1370 if (pkt == NULL) {
1371 /* EOF handling */
1372
1373 for(i=0;i<nb_ostreams;i++) {
1374 ost = ost_table[i];
1375 if (ost->source_index == ist_index) {
1376 AVCodecContext *enc= ost->st->codec;
1377 os = output_files[ost->file_index];
1378
1379 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1380 continue;
1381 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1382 continue;
1383
1384 if (ost->encoding_needed) {
1385 for(;;) {
1386 AVPacket pkt;
1387 int fifo_bytes;
1388 av_init_packet(&pkt);
1389 pkt.stream_index= ost->index;
1390
1391 switch(ost->st->codec->codec_type) {
1392 case CODEC_TYPE_AUDIO:
1393 fifo_bytes = av_fifo_size(&ost->fifo);
1394 ret = 0;
1395 /* encode any samples remaining in fifo */
1396 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1397 int fs_tmp = enc->frame_size;
1398 enc->frame_size = fifo_bytes / (2 * enc->channels);
1399 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1400 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1401 enc->frame_size = fs_tmp;
1402 }
1403 if(ret <= 0) {
1404 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1405 }
1406 audio_size += ret;
1407 pkt.flags |= PKT_FLAG_KEY;
1408 break;
1409 case CODEC_TYPE_VIDEO:
1410 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1411 video_size += ret;
1412 if(enc->coded_frame && enc->coded_frame->key_frame)
1413 pkt.flags |= PKT_FLAG_KEY;
1414 if (ost->logfile && enc->stats_out) {
1415 fprintf(ost->logfile, "%s", enc->stats_out);
1416 }
1417 break;
1418 default:
1419 ret=-1;
1420 }
1421
1422 if(ret<=0)
1423 break;
1424 pkt.data= bit_buffer;
1425 pkt.size= ret;
1426 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1427 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1428 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1429 }
1430 }
1431 }
1432 }
1433 }
1434
1435 return 0;
1436 fail_decode:
1437 return -1;
1438 }
1439
1440 static void print_sdp(AVFormatContext **avc, int n)
1441 {
1442 char sdp[2048];
1443
1444 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1445 printf("SDP:\n%s\n", sdp);
1446 }
1447
1448 static int stream_index_from_inputs(AVFormatContext **input_files,
1449 int nb_input_files,
1450 AVInputFile *file_table,
1451 AVInputStream **ist_table,
1452 enum CodecType type,
1453 int programid)
1454 {
1455 int p, q, z;
1456 for(z=0; z<nb_input_files; z++) {
1457 AVFormatContext *ic = input_files[z];
1458 for(p=0; p<ic->nb_programs; p++) {
1459 AVProgram *program = ic->programs[p];
1460 if(program->id != programid)
1461 continue;
1462 for(q=0; q<program->nb_stream_indexes; q++) {
1463 int sidx = program->stream_index[q];
1464 int ris = file_table[z].ist_index + sidx;
1465 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1466 return ris;
1467 }
1468 }
1469 }
1470
1471 return -1;
1472 }
1473
1474 /*
1475 * The following code is the main loop of the file converter
1476 */
1477 static int av_encode(AVFormatContext **output_files,
1478 int nb_output_files,
1479 AVFormatContext **input_files,
1480 int nb_input_files,
1481 AVStreamMap *stream_maps, int nb_stream_maps)
1482 {
1483 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1484 AVFormatContext *is, *os;
1485 AVCodecContext *codec, *icodec;
1486 AVOutputStream *ost, **ost_table = NULL;
1487 AVInputStream *ist, **ist_table = NULL;
1488 AVInputFile *file_table;
1489 int key;
1490 int want_sdp = 1;
1491
1492 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1493 if (!file_table)
1494 goto fail;
1495
1496 /* input stream init */
1497 j = 0;
1498 for(i=0;i<nb_input_files;i++) {
1499 is = input_files[i];
1500 file_table[i].ist_index = j;
1501 file_table[i].nb_streams = is->nb_streams;
1502 j += is->nb_streams;
1503 }
1504 nb_istreams = j;
1505
1506 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1507 if (!ist_table)
1508 goto fail;
1509
1510 for(i=0;i<nb_istreams;i++) {
1511 ist = av_mallocz(sizeof(AVInputStream));
1512 if (!ist)
1513 goto fail;
1514 ist_table[i] = ist;
1515 }
1516 j = 0;
1517 for(i=0;i<nb_input_files;i++) {
1518 is = input_files[i];
1519 for(k=0;k<is->nb_streams;k++) {
1520 ist = ist_table[j++];
1521 ist->st = is->streams[k];
1522 ist->file_index = i;
1523 ist->index = k;
1524 ist->discard = 1; /* the stream is discarded by default
1525 (changed later) */
1526
1527 if (ist->st->codec->rate_emu) {
1528 ist->start = av_gettime();
1529 ist->frame = 0;
1530 }
1531 }
1532 }
1533
1534 /* output stream init */
1535 nb_ostreams = 0;
1536 for(i=0;i<nb_output_files;i++) {
1537 os = output_files[i];
1538 if (!os->nb_streams) {
1539 fprintf(stderr, "Output file does not contain any stream\n");
1540 av_exit(1);
1541 }
1542 nb_ostreams += os->nb_streams;
1543 }
1544 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1545 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1546 av_exit(1);
1547 }
1548
1549 /* Sanity check the mapping args -- do the input files & streams exist? */
1550 for(i=0;i<nb_stream_maps;i++) {
1551 int fi = stream_maps[i].file_index;
1552 int si = stream_maps[i].stream_index;
1553
1554 if (fi < 0 || fi > nb_input_files - 1 ||
1555 si < 0 || si > file_table[fi].nb_streams - 1) {
1556 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1557 av_exit(1);
1558 }
1559 fi = stream_maps[i].sync_file_index;
1560 si = stream_maps[i].sync_stream_index;
1561 if (fi < 0 || fi > nb_input_files - 1 ||
1562 si < 0 || si > file_table[fi].nb_streams - 1) {
1563 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1564 av_exit(1);
1565 }
1566 }
1567
1568 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1569 if (!ost_table)
1570 goto fail;
1571 for(i=0;i<nb_ostreams;i++) {
1572 ost = av_mallocz(sizeof(AVOutputStream));
1573 if (!ost)
1574 goto fail;
1575 ost_table[i] = ost;
1576 }
1577
1578 n = 0;
1579 for(k=0;k<nb_output_files;k++) {
1580 os = output_files[k];
1581 for(i=0;i<os->nb_streams;i++) {
1582 int found;
1583 ost = ost_table[n++];
1584 ost->file_index = k;
1585 ost->index = i;
1586 ost->st = os->streams[i];
1587 if (nb_stream_maps > 0) {
1588 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1589 stream_maps[n-1].stream_index;
1590
1591 /* Sanity check that the stream types match */
1592 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1593 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1594 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1595 ost->file_index, ost->index);
1596 av_exit(1);
1597 }
1598
1599 } else {
1600 if(opt_programid) {
1601 found = 0;
1602 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1603 if(j != -1) {
1604 ost->source_index = j;
1605 found = 1;
1606 }
1607 } else {
1608 /* get corresponding input stream index : we select the first one with the right type */
1609 found = 0;
1610 for(j=0;j<nb_istreams;j++) {
1611 ist = ist_table[j];
1612 if (ist->discard &&
1613 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1614 ost->source_index = j;
1615 found = 1;
1616 break;
1617 }
1618 }
1619 }
1620
1621 if (!found) {
1622 if(! opt_programid) {
1623 /* try again and reuse existing stream */
1624 for(j=0;j<nb_istreams;j++) {
1625 ist = ist_table[j];
1626 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1627 ost->source_index = j;
1628 found = 1;
1629 }
1630 }
1631 }
1632 if (!found) {
1633 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1634 ost->file_index, ost->index);
1635 av_exit(1);
1636 }
1637 }
1638 }
1639 ist = ist_table[ost->source_index];
1640 ist->discard = 0;
1641 ost->sync_ist = (nb_stream_maps > 0) ?
1642 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1643 stream_maps[n-1].sync_stream_index] : ist;
1644 }
1645 }
1646
1647 /* for each output stream, we compute the right encoding parameters */
1648 for(i=0;i<nb_ostreams;i++) {
1649 ost = ost_table[i];
1650 os = output_files[ost->file_index];
1651 ist = ist_table[ost->source_index];
1652
1653 codec = ost->st->codec;
1654 icodec = ist->st->codec;
1655
1656 if (!ost->st->language[0])
1657 av_strlcpy(ost->st->language, ist->st->language,
1658 sizeof(ost->st->language));
1659
1660 ost->st->disposition = ist->st->disposition;
1661
1662 if (ost->st->stream_copy) {
1663 /* if stream_copy is selected, no need to decode or encode */
1664 codec->codec_id = icodec->codec_id;
1665 codec->codec_type = icodec->codec_type;
1666
1667 if(!codec->codec_tag){
1668 if( !os->oformat->codec_tag
1669 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1670 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1671 codec->codec_tag = icodec->codec_tag;
1672 }
1673
1674 codec->bit_rate = icodec->bit_rate;
1675 codec->extradata= icodec->extradata;
1676 codec->extradata_size= icodec->extradata_size;
1677 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1678 codec->time_base = icodec->time_base;
1679 else
1680 codec->time_base = ist->st->time_base;
1681 switch(codec->codec_type) {
1682 case CODEC_TYPE_AUDIO:
1683 codec->sample_rate = icodec->sample_rate;
1684 codec->channels = icodec->channels;
1685 codec->frame_size = icodec->frame_size;
1686 codec->block_align= icodec->block_align;
1687 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1688 codec->block_align= 0;
1689 if(codec->codec_id == CODEC_ID_AC3)
1690 codec->block_align= 0;
1691 break;
1692 case CODEC_TYPE_VIDEO:
1693 if(using_vhook) {
1694 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1695 av_exit(1);
1696 }
1697 codec->pix_fmt = icodec->pix_fmt;
1698 codec->width = icodec->width;
1699 codec->height = icodec->height;
1700 codec->has_b_frames = icodec->has_b_frames;
1701 break;
1702 case CODEC_TYPE_SUBTITLE:
1703 break;
1704 default:
1705 abort();
1706 }
1707 } else {
1708 switch(codec->codec_type) {
1709 case CODEC_TYPE_AUDIO:
1710 if (av_fifo_init(&ost->fifo, 1024))
1711 goto fail;
1712 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1713 icodec->request_channels = codec->channels;
1714 ist->decoding_needed = 1;
1715 ost->encoding_needed = 1;
1716 break;
1717 case CODEC_TYPE_VIDEO:
1718 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1719 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1720 ost->video_resample = ((codec->width != icodec->width -
1721 (frame_leftBand + frame_rightBand) +
1722 (frame_padleft + frame_padright)) ||
1723 (codec->height != icodec->height -
1724 (frame_topBand + frame_bottomBand) +
1725 (frame_padtop + frame_padbottom)) ||
1726 (codec->pix_fmt != icodec->pix_fmt));
1727 if (ost->video_crop) {
1728 ost->topBand = frame_topBand;
1729 ost->leftBand = frame_leftBand;
1730 }
1731 if (ost->video_pad) {
1732 ost->padtop = frame_padtop;
1733 ost->padleft = frame_padleft;
1734 ost->padbottom = frame_padbottom;
1735 ost->padright = frame_padright;
1736 if (!ost->video_resample) {
1737 avcodec_get_frame_defaults(&ost->pict_tmp);
1738 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1739 codec->width, codec->height))
1740 goto fail;
1741 }
1742 }
1743 if (ost->video_resample) {
1744 avcodec_get_frame_defaults(&ost->pict_tmp);
1745 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1746 codec->width, codec->height)) {
1747 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1748 av_exit(1);
1749 }
1750 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1751 ost->img_resample_ctx = sws_getContext(
1752 icodec->width - (frame_leftBand + frame_rightBand),
1753 icodec->height - (frame_topBand + frame_bottomBand),
1754 icodec->pix_fmt,
1755 codec->width - (frame_padleft + frame_padright),
1756 codec->height - (frame_padtop + frame_padbottom),
1757 codec->pix_fmt,
1758 sws_flags, NULL, NULL, NULL);
1759 if (ost->img_resample_ctx == NULL) {
1760 fprintf(stderr, "Cannot get resampling context\n");
1761 av_exit(1);
1762 }
1763 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1764 }
1765 ost->encoding_needed = 1;
1766 ist->decoding_needed = 1;
1767 break;
1768 case CODEC_TYPE_SUBTITLE:
1769 ost->encoding_needed = 1;
1770 ist->decoding_needed = 1;
1771 break;
1772 default:
1773 abort();
1774 break;
1775 }
1776 /* two pass mode */
1777 if (ost->encoding_needed &&
1778 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1779 char logfilename[1024];
1780 FILE *f;
1781 int size;
1782 char *logbuffer;
1783
1784 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1785 pass_logfilename ?
1786 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1787 if (codec->flags & CODEC_FLAG_PASS1) {
1788 f = fopen(logfilename, "w");
1789 if (!f) {
1790 perror(logfilename);
1791 av_exit(1);
1792 }
1793 ost->logfile = f;
1794 } else {
1795 /* read the log file */
1796 f = fopen(logfilename, "r");
1797 if (!f) {
1798 perror(logfilename);
1799 av_exit(1);
1800 }
1801 fseek(f, 0, SEEK_END);
1802 size = ftell(f);
1803 fseek(f, 0, SEEK_SET);
1804 logbuffer = av_malloc(size + 1);
1805 if (!logbuffer) {
1806 fprintf(stderr, "Could not allocate log buffer\n");
1807 av_exit(1);
1808 }
1809 size = fread(logbuffer, 1, size, f);
1810 fclose(f);
1811 logbuffer[size] = '\0';
1812 codec->stats_in = logbuffer;
1813 }
1814 }
1815 }
1816 if(codec->codec_type == CODEC_TYPE_VIDEO){
1817 int size= codec->width * codec->height;
1818 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1819 }
1820 }
1821
1822 if (!bit_buffer)
1823 bit_buffer = av_malloc(bit_buffer_size);
1824 if (!bit_buffer)
1825 goto fail;
1826
1827 /* dump the file output parameters - cannot be done before in case
1828 of stream copy */
1829 for(i=0;i<nb_output_files;i++) {
1830 dump_format(output_files[i], i, output_files[i]->filename, 1);
1831 }
1832
1833 /* dump the stream mapping */
1834 if (verbose >= 0) {
1835 fprintf(stderr, "Stream mapping:\n");
1836 for(i=0;i<nb_ostreams;i++) {
1837 ost = ost_table[i];
1838 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1839 ist_table[ost->source_index]->file_index,
1840 ist_table[ost->source_index]->index,
1841 ost->file_index,
1842 ost->index);
1843 if (ost->sync_ist != ist_table[ost->source_index])
1844 fprintf(stderr, " [sync #%d.%d]",
1845 ost->sync_ist->file_index,
1846 ost->sync_ist->index);
1847 fprintf(stderr, "\n");
1848 }
1849 }
1850
1851 /* open each encoder */
1852 for(i=0;i<nb_ostreams;i++) {
1853 ost = ost_table[i];
1854 if (ost->encoding_needed) {
1855 AVCodec *codec;
1856 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1857 if (!codec) {
1858 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1859 ost->file_index, ost->index);
1860 av_exit(1);
1861 }
1862 if (avcodec_open(ost->st->codec, codec) < 0) {
1863 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1864 ost->file_index, ost->index);
1865 av_exit(1);
1866 }
1867 extra_size += ost->st->codec->extradata_size;
1868 }
1869 }
1870
1871 /* open each decoder */
1872 for(i=0;i<nb_istreams;i++) {
1873 ist = ist_table[i];
1874 if (ist->decoding_needed) {
1875 AVCodec *codec;
1876 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1877 if (!codec) {
1878 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1879 ist->st->codec->codec_id, ist->file_index, ist->index);
1880 av_exit(1);
1881 }
1882 if (avcodec_open(ist->st->codec, codec) < 0) {
1883 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1884 ist->file_index, ist->index);
1885 av_exit(1);
1886 }
1887 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1888 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1889 }
1890 }
1891
1892 /* init pts */
1893 for(i=0;i<nb_istreams;i++) {
1894 ist = ist_table[i];
1895 is = input_files[ist->file_index];
1896 ist->pts = 0;
1897 ist->next_pts = AV_NOPTS_VALUE;
1898 ist->is_start = 1;
1899 }
1900
1901 /* set meta data information from input file if required */
1902 for (i=0;i<nb_meta_data_maps;i++) {
1903 AVFormatContext *out_file;
1904 AVFormatContext *in_file;
1905
1906 int out_file_index = meta_data_maps[i].out_file;
1907 int in_file_index = meta_data_maps[i].in_file;
1908 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1909 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1910 ret = AVERROR(EINVAL);
1911 goto fail;
1912 }
1913 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1914 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1915 ret = AVERROR(EINVAL);
1916 goto fail;
1917 }
1918
1919 out_file = output_files[out_file_index];
1920 in_file = input_files[in_file_index];
1921
1922 strcpy(out_file->title, in_file->title);
1923 strcpy(out_file->author, in_file->author);
1924 strcpy(out_file->copyright, in_file->copyright);
1925 strcpy(out_file->comment, in_file->comment);
1926 strcpy(out_file->album, in_file->album);
1927 out_file->year = in_file->year;
1928 out_file->track = in_file->track;
1929 strcpy(out_file->genre, in_file->genre);
1930 }
1931
1932 /* open files and write file headers */
1933 for(i=0;i<nb_output_files;i++) {
1934 os = output_files[i];
1935 if (av_write_header(os) < 0) {
1936 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1937 ret = AVERROR(EINVAL);
1938 goto fail;
1939 }
1940 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1941 want_sdp = 0;
1942 }
1943 }
1944 if (want_sdp) {
1945 print_sdp(output_files, nb_output_files);
1946 }
1947
1948 if (!using_stdin && verbose >= 0) {
1949 fprintf(stderr, "Press [q] to stop encoding\n");
1950 url_set_interrupt_cb(decode_interrupt_cb);
1951 }
1952 term_init();
1953
1954 key = -1;
1955 timer_start = av_gettime();
1956
1957 for(; received_sigterm == 0;) {
1958 int file_index, ist_index;
1959 AVPacket pkt;
1960 double ipts_min;
1961 double opts_min;
1962
1963 redo:
1964 ipts_min= 1e100;
1965 opts_min= 1e100;
1966 /* if 'q' pressed, exits */
1967 if (!using_stdin) {
1968 if (q_pressed)
1969 break;
1970 /* read_key() returns 0 on EOF */
1971 key = read_key();
1972 if (key == 'q')
1973 break;
1974 }
1975
1976 /* select the stream that we must read now by looking at the
1977 smallest output pts */
1978 file_index = -1;
1979 for(i=0;i<nb_ostreams;i++) {
1980 double ipts, opts;
1981 ost = ost_table[i];
1982 os = output_files[ost->file_index];
1983 ist = ist_table[ost->source_index];
1984 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1985 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1986 else
1987 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1988 ipts = (double)ist->pts;
1989 if (!file_table[ist->file_index].eof_reached){
1990 if(ipts < ipts_min) {
1991 ipts_min = ipts;
1992 if(input_sync ) file_index = ist->file_index;
1993 }
1994 if(opts < opts_min) {
1995 opts_min = opts;
1996 if(!input_sync) file_index = ist->file_index;
1997 }
1998 }
1999 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2000 file_index= -1;
2001 break;
2002 }
2003 }
2004 /* if none, if is finished */
2005 if (file_index < 0) {
2006 break;
2007 }
2008
2009 /* finish if recording time exhausted */
2010 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2011 break;
2012
2013 /* finish if limit size exhausted */
2014 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2015 break;
2016
2017 /* read a frame from it and output it in the fifo */
2018 is = input_files[file_index];
2019 if (av_read_frame(is, &pkt) < 0) {
2020 file_table[file_index].eof_reached = 1;
2021 if (opt_shortest)
2022 break;
2023 else
2024 continue;
2025 }
2026
2027 if (do_pkt_dump) {
2028 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2029 }
2030 /* the following test is needed in case new streams appear
2031 dynamically in stream : we ignore them */
2032 if (pkt.stream_index >= file_table[file_index].nb_streams)
2033 goto discard_packet;
2034 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2035 ist = ist_table[ist_index];
2036 if (ist->discard)
2037 goto discard_packet;
2038
2039 if (pkt.dts != AV_NOPTS_VALUE)
2040 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2041 if (pkt.pts != AV_NOPTS_VALUE)
2042 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2043
2044 // 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);
2045 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2046 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2047 int64_t delta= pkt_dts - ist->next_pts;
2048 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2049 input_files_ts_offset[ist->file_index]-= delta;
2050 if (verbose > 2)
2051 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2052 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2053 if(pkt.pts != AV_NOPTS_VALUE)
2054 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2055 }
2056 }
2057
2058 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2059 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2060
2061 if (verbose >= 0)
2062 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2063 ist->file_index, ist->index);
2064
2065 av_free_packet(&pkt);
2066 goto redo;
2067 }
2068
2069 discard_packet:
2070 av_free_packet(&pkt);
2071
2072 /* dump report by using the output first video and audio streams */
2073 print_report(output_files, ost_table, nb_ostreams, 0);
2074 }
2075
2076 /* at the end of stream, we must flush the decoder buffers */
2077 for(i=0;i<nb_istreams;i++) {
2078 ist = ist_table[i];
2079 if (ist->decoding_needed) {
2080 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2081 }
2082 }
2083
2084 term_exit();
2085
2086 /* write the trailer if needed and close file */
2087 for(i=0;i<nb_output_files;i++) {
2088 os = output_files[i];
2089 av_write_trailer(os);
2090 }
2091
2092 /* dump report by using the first video and audio streams */
2093 print_report(output_files, ost_table, nb_ostreams, 1);
2094
2095 /* close each encoder */
2096 for(i=0;i<nb_ostreams;i++) {
2097 ost = ost_table[i];
2098 if (ost->encoding_needed) {
2099 av_freep(&ost->st->codec->stats_in);
2100 avcodec_close(ost->st->codec);
2101 }
2102 }
2103
2104 /* close each decoder */
2105 for(i=0;i<nb_istreams;i++) {
2106 ist = ist_table[i];
2107 if (ist->decoding_needed) {
2108 avcodec_close(ist->st->codec);
2109 }
2110 }
2111
2112 /* finished ! */
2113
2114 ret = 0;
2115 fail1:
2116 av_freep(&bit_buffer);
2117 av_free(file_table);
2118
2119 if (ist_table) {
2120 for(i=0;i<nb_istreams;i++) {
2121 ist = ist_table[i];
2122 av_free(ist);
2123 }
2124 av_free(ist_table);
2125 }
2126 if (ost_table) {
2127 for(i=0;i<nb_ostreams;i++) {
2128 ost = ost_table[i];
2129 if (ost) {
2130 if (ost->logfile) {
2131 fclose(ost->logfile);
2132 ost->logfile = NULL;
2133 }
2134 av_fifo_free(&ost->fifo); /* works even if fifo is not
2135 initialized but set to zero */
2136 av_free(ost->pict_tmp.data[0]);
2137 if (ost->video_resample)
2138 sws_freeContext(ost->img_resample_ctx);
2139 if (ost->resample)
2140 audio_resample_close(ost->resample);
2141 av_free(ost);
2142 }
2143 }
2144 av_free(ost_table);
2145 }
2146 return ret;
2147 fail:
2148 ret = AVERROR(ENOMEM);
2149 goto fail1;
2150 }
2151
2152 #if 0
2153 int file_read(const char *filename)
2154 {
2155 URLContext *h;
2156 unsigned char buffer[1024];
2157 int len, i;
2158
2159 if (url_open(&h, filename, O_RDONLY) < 0) {
2160 printf("could not open '%s'\n", filename);
2161 return -1;
2162 }
2163 for(;;) {
2164 len = url_read(h, buffer, sizeof(buffer));
2165 if (len <= 0)
2166 break;
2167 for(i=0;i<len;i++) putchar(buffer[i]);
2168 }
2169 url_close(h);
2170 return 0;
2171 }
2172 #endif
2173
2174 static void opt_format(const char *arg)
2175 {
2176 /* compatibility stuff for pgmyuv */
2177 if (!strcmp(arg, "pgmyuv")) {
2178 pgmyuv_compatibility_hack=1;
2179 // opt_image_format(arg);
2180 arg = "image2";
2181 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2182 }
2183
2184 file_iformat = av_find_input_format(arg);
2185 file_oformat = guess_format(arg, NULL, NULL);
2186 if (!file_iformat && !file_oformat) {
2187 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2188 av_exit(1);
2189 }
2190 }
2191
2192 static int opt_default(const char *opt, const char *arg){
2193 int type;
2194 const AVOption *o= NULL;
2195 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2196
2197 for(type=0; type<CODEC_TYPE_NB; type++){
2198 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2199 if(o2)
2200 o = av_set_string(avctx_opts[type], opt, arg);
2201 }
2202 if(!o)
2203 o = av_set_string(avformat_opts, opt, arg);
2204 if(!o)
2205 o = av_set_string(sws_opts, opt, arg);
2206 if(!o){
2207 if(opt[0] == 'a')
2208 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2209 else if(opt[0] == 'v')
2210 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2211 else if(opt[0] == 's')
2212 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2213 }
2214 if(!o)
2215 return -1;
2216
2217 // 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));
2218
2219 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2220 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2221 opt_names[opt_name_count++]= o->name;
2222
2223 if(avctx_opts[0]->debug || avformat_opts->debug)
2224 av_log_set_level(AV_LOG_DEBUG);
2225 return 0;
2226 }
2227
2228 static void opt_video_rc_override_string(const char *arg)
2229 {
2230 video_rc_override_string = arg;
2231 }
2232
2233 static int opt_me_threshold(const char *opt, const char *arg)
2234 {
2235 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2236 return 0;
2237 }
2238
2239 static int opt_verbose(const char *opt, const char *arg)
2240 {
2241 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2242 av_log_set_level(verbose);
2243 return 0;
2244 }
2245
2246 static void opt_frame_rate(const char *arg)
2247 {
2248 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2249 fprintf(stderr, "Incorrect frame rate\n");
2250 av_exit(1);
2251 }
2252 }
2253
2254 static int opt_bitrate(const char *opt, const char *arg)
2255 {
2256 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2257
2258 opt_default(opt, arg);
2259
2260 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2261 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2262
2263 return 0;
2264 }
2265
2266 static void opt_frame_crop_top(const char *arg)
2267 {
2268 frame_topBand = atoi(arg);
2269 if (frame_topBand < 0) {
2270 fprintf(stderr, "Incorrect top crop size\n");
2271 av_exit(1);
2272 }
2273 if ((frame_topBand % 2) != 0) {
2274 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2275 av_exit(1);
2276 }
2277 if ((frame_topBand) >= frame_height){
2278 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2279 av_exit(1);
2280 }
2281 frame_height -= frame_topBand;
2282 }
2283
2284 static void opt_frame_crop_bottom(const char *arg)
2285 {
2286 frame_bottomBand = atoi(arg);
2287 if (frame_bottomBand < 0) {
2288 fprintf(stderr, "Incorrect bottom crop size\n");
2289 av_exit(1);
2290 }
2291 if ((frame_bottomBand % 2) != 0) {
2292 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2293 av_exit(1);
2294 }
2295 if ((frame_bottomBand) >= frame_height){
2296 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2297 av_exit(1);
2298 }
2299 frame_height -= frame_bottomBand;
2300 }
2301
2302 static void opt_frame_crop_left(const char *arg)
2303 {
2304 frame_leftBand = atoi(arg);
2305 if (frame_leftBand < 0) {
2306 fprintf(stderr, "Incorrect left crop size\n");
2307 av_exit(1);
2308 }
2309 if ((frame_leftBand % 2) != 0) {
2310 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2311 av_exit(1);
2312 }
2313 if ((frame_leftBand) >= frame_width){
2314 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2315 av_exit(1);
2316 }
2317 frame_width -= frame_leftBand;
2318 }
2319
2320 static void opt_frame_crop_right(const char *arg)
2321 {
2322 frame_rightBand = atoi(arg);
2323 if (frame_rightBand < 0) {
2324 fprintf(stderr, "Incorrect right crop size\n");
2325 av_exit(1);
2326 }
2327 if ((frame_rightBand % 2) != 0) {
2328 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2329 av_exit(1);
2330 }
2331 if ((frame_rightBand) >= frame_width){
2332 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2333 av_exit(1);
2334 }
2335 frame_width -= frame_rightBand;
2336 }
2337
2338 static void opt_frame_size(const char *arg)
2339 {
2340 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2341 fprintf(stderr, "Incorrect frame size\n");
2342 av_exit(1);
2343 }
2344 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2345 fprintf(stderr, "Frame size must be a multiple of 2\n");
2346 av_exit(1);
2347 }
2348 }
2349
2350
2351 #define SCALEBITS 10
2352 #define ONE_HALF (1 << (SCALEBITS - 1))
2353 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2354
2355 #define RGB_TO_Y(r, g, b) \
2356 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2357 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2358
2359 #define RGB_TO_U(r1, g1, b1, shift)\
2360 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2361 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2362
2363 #define RGB_TO_V(r1, g1, b1, shift)\
2364 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2365 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2366
2367 static void opt_pad_color(const char *arg) {
2368 /* Input is expected to be six hex digits similar to
2369 how colors are expressed in html tags (but without the #) */
2370 int rgb = strtol(arg, NULL, 16);
2371 int r,g,b;
2372
2373 r = (rgb >> 16);
2374 g = ((rgb >> 8) & 255);
2375 b = (rgb & 255);
2376
2377 padcolor[0] = RGB_TO_Y(r,g,b);
2378 padcolor[1] = RGB_TO_U(r,g,b,0);
2379 padcolor[2] = RGB_TO_V(r,g,b,0);
2380 }
2381
2382 static void opt_frame_pad_top(const char *arg)
2383 {
2384 frame_padtop = atoi(arg);
2385 if (frame_padtop < 0) {
2386 fprintf(stderr, "Incorrect top pad size\n");
2387 av_exit(1);
2388 }
2389 if ((frame_padtop % 2) != 0) {
2390 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2391 av_exit(1);
2392 }
2393 }
2394
2395 static void opt_frame_pad_bottom(const char *arg)
2396 {
2397 frame_padbottom = atoi(arg);
2398 if (frame_padbottom < 0) {
2399 fprintf(stderr, "Incorrect bottom pad size\n");
2400 av_exit(1);
2401 }
2402 if ((frame_padbottom % 2) != 0) {
2403 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2404 av_exit(1);
2405 }
2406 }
2407
2408
2409 static void opt_frame_pad_left(const char *arg)
2410 {
2411 frame_padleft = atoi(arg);
2412 if (frame_padleft < 0) {
2413 fprintf(stderr, "Incorrect left pad size\n");
2414 av_exit(1);
2415 }
2416 if ((frame_padleft % 2) != 0) {
2417 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2418 av_exit(1);
2419 }
2420 }
2421
2422
2423 static void opt_frame_pad_right(const char *arg)
2424 {
2425 frame_padright = atoi(arg);
2426 if (frame_padright < 0) {
2427 fprintf(stderr, "Incorrect right pad size\n");
2428 av_exit(1);
2429 }
2430 if ((frame_padright % 2) != 0) {
2431 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2432 av_exit(1);
2433 }
2434 }
2435
2436 static void list_pix_fmts(void)
2437 {
2438 int i;
2439 char pix_fmt_str[128];
2440 for (i=-1; i < PIX_FMT_NB; i++) {
2441 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2442 fprintf(stdout, "%s\n", pix_fmt_str);
2443 }
2444 }
2445
2446 static void opt_frame_pix_fmt(const char *arg)
2447 {
2448 if (strcmp(arg, "list"))
2449 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2450 else {
2451 list_pix_fmts();
2452 av_exit(0);
2453 }
2454 }
2455
2456 static void opt_frame_aspect_ratio(const char *arg)
2457 {
2458 int x = 0, y = 0;
2459 double ar = 0;
2460 const char *p;
2461 char *end;
2462
2463 p = strchr(arg, ':');
2464 if (p) {
2465 x = strtol(arg, &end, 10);
2466 if (end == p)
2467 y = strtol(end+1, &end, 10);
2468 if (x > 0 && y > 0)
2469 ar = (double)x / (double)y;
2470 } else
2471 ar = strtod(arg, NULL);
2472
2473 if (!ar) {
2474 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2475 av_exit(1);
2476 }
2477 frame_aspect_ratio = ar;
2478 }
2479
2480 static void opt_qscale(const char *arg)
2481 {
2482 video_qscale = atof(arg);
2483 if (video_qscale <= 0 ||
2484 video_qscale > 255) {
2485 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2486 av_exit(1);
2487 }
2488 }
2489
2490 static void opt_qdiff(const char *arg)
2491 {
2492 video_qdiff = atoi(arg);
2493 if (video_qdiff < 0 ||
2494 video_qdiff > 31) {
2495 fprintf(stderr, "qdiff must be >= 1 and <= 31\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_string(ctx, opt_names[i], str);
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->max_qdiff = video_qdiff;
2994 video_enc->thread_count = thread_count;
2995 p= video_rc_override_string;
2996 for(i=0; p; i++){
2997 int start, end, q;
2998 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2999 if(e!=3){
3000 fprintf(stderr, "error parsing rc_override\n");
3001 av_exit(1);
3002 }
3003 video_enc->rc_override=
3004 av_realloc(video_enc->rc_override,
3005 sizeof(RcOverride)*(i+1));
3006 video_enc->rc_override[i].start_frame= start;
3007 video_enc->rc_override[i].end_frame = end;
3008 if(q>0){
3009 video_enc->rc_override[i].qscale= q;
3010 video_enc->rc_override[i].quality_factor= 1.0;
3011 }
3012 else{
3013 video_enc->rc_override[i].qscale= 0;
3014 video_enc->rc_override[i].quality_factor= -q/100.0;
3015 }
3016 p= strchr(p, '/');
3017 if(p) p++;
3018 }
3019 video_enc->rc_override_count=i;
3020 if (!video_enc->rc_initial_buffer_occupancy)
3021 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3022 video_enc->me_threshold= me_threshold;
3023 video_enc->intra_dc_precision= intra_dc_precision - 8;
3024 video_enc->strict_std_compliance = strict;
3025
3026 if (do_psnr)
3027 video_enc->flags|= CODEC_FLAG_PSNR;
3028
3029 /* two pass mode */
3030 if (do_pass) {
3031 if (do_pass == 1) {
3032 video_enc->flags |= CODEC_FLAG_PASS1;
3033 } else {
3034 video_enc->flags |= CODEC_FLAG_PASS2;
3035 }
3036 }
3037 }
3038
3039 /* reset some key parameters */
3040 video_disable = 0;
3041 av_freep(&video_codec_name);
3042 video_stream_copy = 0;
3043 }
3044
3045 static void new_audio_stream(AVFormatContext *oc)
3046 {
3047 AVStream *st;
3048 AVCodecContext *audio_enc;
3049 int codec_id;
3050
3051 st = av_new_stream(oc, oc->nb_streams);
3052 if (!st) {
3053 fprintf(stderr, "Could not alloc stream\n");
3054 av_exit(1);
3055 }
3056 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3057
3058 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3059 audio_bitstream_filters= NULL;
3060
3061 if(thread_count>1)
3062 avcodec_thread_init(st->codec, thread_count);
3063
3064 audio_enc = st->codec;
3065 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3066 audio_enc->strict_std_compliance = strict;
3067
3068 if(audio_codec_tag)
3069 audio_enc->codec_tag= audio_codec_tag;
3070
3071 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3072 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3073 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3074 }
3075 if (audio_stream_copy) {
3076 st->stream_copy = 1;
3077 audio_enc->channels = audio_channels;
3078 } else {
3079 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3080
3081 set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3082
3083 if (audio_codec_name)
3084 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3085 audio_enc->codec_id = codec_id;
3086
3087 if (audio_qscale > QSCALE_NONE) {
3088 audio_enc->flags |= CODEC_FLAG_QSCALE;
3089 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3090 }
3091 audio_enc->thread_count = thread_count;
3092 audio_enc->channels = audio_channels;
3093 }
3094 audio_enc->sample_rate = audio_sample_rate;
3095 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3096 if (audio_language) {
3097 av_strlcpy(st->language, audio_language, sizeof(st->language));
3098 av_free(audio_language);
3099 audio_language = NULL;
3100 }
3101
3102 /* reset some key parameters */
3103 audio_disable = 0;
3104 av_freep(&audio_codec_name);
3105 audio_stream_copy = 0;
3106 }
3107
3108 static void new_subtitle_stream(AVFormatContext *oc)
3109 {
3110 AVStream *st;
3111 AVCodecContext *subtitle_enc;
3112
3113 st = av_new_stream(oc, oc->nb_streams);
3114 if (!st) {
3115 fprintf(stderr, "Could not alloc stream\n");
3116 av_exit(1);
3117 }
3118 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3119
3120 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3121 subtitle_bitstream_filters= NULL;
3122
3123 subtitle_enc = st->codec;
3124 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3125 if (subtitle_stream_copy) {
3126 st->stream_copy = 1;
3127 } else {
3128 set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3129 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3130 }
3131
3132 if (subtitle_language) {
3133 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3134 av_free(subtitle_language);
3135 subtitle_language = NULL;
3136 }
3137
3138 subtitle_disable = 0;
3139 av_freep(&subtitle_codec_name);
3140 subtitle_stream_copy = 0;
3141 }
3142
3143 static void opt_new_audio_stream(void)
3144 {
3145 AVFormatContext *oc;
3146 if (nb_output_files <= 0) {
3147 fprintf(stderr, "At least one output file must be specified\n");
3148 av_exit(1);
3149 }
3150 oc = output_files[nb_output_files - 1];
3151 new_audio_stream(oc);
3152 }
3153
3154 static void opt_new_video_stream(void)
3155 {
3156 AVFormatContext *oc;
3157 if (nb_output_files <= 0) {
3158 fprintf(stderr, "At least one output file must be specified\n");
3159 av_exit(1);
3160 }
3161 oc = output_files[nb_output_files - 1];
3162 new_video_stream(oc);
3163 }
3164
3165 static void opt_new_subtitle_stream(void)
3166 {
3167 AVFormatContext *oc;
3168 if (nb_output_files <= 0) {
3169 fprintf(stderr, "At least one output file must be specified\n");
3170 av_exit(1);
3171 }
3172 oc = output_files[nb_output_files - 1];
3173 new_subtitle_stream(oc);
3174 }
3175
3176 static void opt_output_file(const char *filename)
3177 {
3178 AVFormatContext *oc;
3179 int use_video, use_audio, use_subtitle;
3180 int input_has_video, input_has_audio, input_has_subtitle;
3181 AVFormatParameters params, *ap = &params;
3182
3183 if (!strcmp(filename, "-"))
3184 filename = "pipe:";
3185
3186 oc = av_alloc_format_context();
3187
3188 if (!file_oformat) {
3189 file_oformat = guess_format(NULL, filename, NULL);
3190 if (!file_oformat) {
3191 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3192 filename);
3193 av_exit(1);
3194 }
3195 }
3196
3197 oc->oformat = file_oformat;
3198 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3199
3200 if (!strcmp(file_oformat->name, "ffm") &&
3201 av_strstart(filename, "http:", NULL)) {
3202 /* special case for files sent to ffserver: we get the stream
3203 parameters from ffserver */
3204 if (read_ffserver_streams(oc, filename) < 0) {
3205 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
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, 0);
3401 show_help_options(options, "\nVideo options:\n",
3402 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3403 OPT_VIDEO);
3404 show_help_options(options, "\nAdvanced Video options:\n",
3405 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3406 OPT_VIDEO | OPT_EXPERT);
3407 show_help_options(options, "\nAudio options:\n",
3408 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3409 OPT_AUDIO);
3410 show_help_options(options, "\nAdvanced Audio options:\n",
3411 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3412 OPT_AUDIO | OPT_EXPERT);
3413 show_help_options(options, "\nSubtitle options:\n",
3414 OPT_SUBTITLE | OPT_GRAB,
3415 OPT_SUBTITLE);
3416 show_help_options(options, "\nAudio/Video grab options:\n",
3417 OPT_GRAB,
3418 OPT_GRAB);
3419 show_help_options(options, "\nAdvanced options:\n",
3420 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3421 OPT_EXPERT);
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 opt_default(tmp, tmp2);
3647 }
3648
3649 fclose(f);
3650
3651 return 0;
3652 }
3653
3654 static const OptionDef options[] = {
3655 /* main options */
3656 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3657 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3658 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3659 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3660 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3661 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3662 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3663 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3664 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3665 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3666 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3667 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3668 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3669 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3670 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3671 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3672 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3673 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3674 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3675 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3676 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3677 "add timings for benchmarking" },
3678 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3679 "dump each input packet" },
3680 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3681 "when dumping packets, also dump the payload" },
3682 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3683 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3684 { "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)", "" },
3685 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3686 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3687 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3688 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3689 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3690 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3691 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3692 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3693 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3694 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3695 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3696
3697 /* video options */
3698 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3699 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3700 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3701 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3702 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3703 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3704 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3705 { "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" },
3706 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3707 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3708 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3709 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3710 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3711 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3712 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3713 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3714 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3715 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3716 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3717 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3718 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3719 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3720 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3721 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3722 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3723 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3724 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3725 "use same video quality as source (implies VBR)" },
3726 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3727 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3728 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3729 "deinterlace pictures" },
3730 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3731 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3732 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3733 #ifdef CONFIG_VHOOK
3734 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3735 #endif
3736 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3737 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3738 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3739 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3740 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3741 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3742 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3743
3744 /* audio options */
3745 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3746 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3747 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3748 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3749 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3750 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3751 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3752 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3753 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3754 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3755 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3756
3757 /* subtitle options */
3758 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3759 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3760 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3761 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3762
3763 /* grab options */
3764 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3765 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3766 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3767
3768 /* muxer options */
3769 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3770 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3771
3772 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3773 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3774 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3775
3776 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3777 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3778 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3779
3780 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3781 { NULL, },
3782 };
3783
3784 int main(int argc, char **argv)
3785 {
3786 int i;
3787 int64_t ti;
3788
3789 avcodec_register_all();
3790 avdevice_register_all();
3791 av_register_all();
3792
3793 for(i=0; i<CODEC_TYPE_NB; i++){
3794 avctx_opts[i]= avcodec_alloc_context2(i);
3795 }
3796 avformat_opts = av_alloc_format_context();
3797 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3798
3799 show_banner();
3800 if (argc <= 1) {
3801 show_help();
3802 av_exit(1);
3803 }
3804
3805 /* parse options */
3806 parse_options(argc, argv, options, opt_output_file);
3807
3808 /* file converter / grab */
3809 if (nb_output_files <= 0) {
3810 fprintf(stderr, "Must supply at least one output file\n");
3811 av_exit(1);
3812 }
3813
3814 if (nb_input_files == 0) {
3815 fprintf(stderr, "Must supply at least one input file\n");
3816 av_exit(1);
3817 }
3818
3819 ti = getutime();
3820 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3821 stream_maps, nb_stream_maps);
3822 ti = getutime() - ti;
3823 if (do_benchmark) {
3824 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3825 }
3826
3827 return av_exit(0);
3828 }
An experimental fork of FFmpeg project for DVCPRO-HD developers