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