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