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