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