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