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