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