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