?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Hardcode the table for ungrouping 3 values in 5 bits. It will be reused by
[ffmpeg-lucabe.git] / ffmpeg.c
blob850778db91423b115796b088d34bb364cce353b1
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)
1202 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1203 data_size= samples_size;
1204 /* XXX: could avoid copy if PCM 16 bits with same
1205 endianness as CPU */
1206 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1207 ptr, len);
1208 if (ret < 0)
1209 goto fail_decode;
1210 ptr += ret;
1211 len -= ret;
1212 /* Some bug in mpeg audio decoder gives */
1213 /* data_size < 0, it seems they are overflows */
1214 if (data_size <= 0) {
1215 /* no audio frame */
1216 continue;
1217 }
1218 data_buf = (uint8_t *)samples;
1219 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1220 (ist->st->codec->sample_rate * ist->st->codec->channels);
1221 break;}
1222 case CODEC_TYPE_VIDEO:
1223 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1224 /* XXX: allocate picture correctly */
1225 avcodec_get_frame_defaults(&picture);
1226
1227 ret = avcodec_decode_video(ist->st->codec,
1228 &picture, &got_picture, ptr, len);
1229 ist->st->quality= picture.quality;
1230 if (ret < 0)
1231 goto fail_decode;
1232 if (!got_picture) {
1233 /* no picture yet */
1234 goto discard_packet;
1235 }
1236 if (ist->st->codec->time_base.num != 0) {
1237 ist->next_pts += ((int64_t)AV_TIME_BASE *
1238 ist->st->codec->time_base.num) /
1239 ist->st->codec->time_base.den;
1240 }
1241 len = 0;
1242 break;
1243 case CODEC_TYPE_SUBTITLE:
1244 ret = avcodec_decode_subtitle(ist->st->codec,
1245 &subtitle, &got_subtitle, ptr, len);
1246 if (ret < 0)
1247 goto fail_decode;
1248 if (!got_subtitle) {
1249 goto discard_packet;
1250 }
1251 subtitle_to_free = &subtitle;
1252 len = 0;
1253 break;
1254 default:
1255 goto fail_decode;
1256 }
1257 } else {
1258 switch(ist->st->codec->codec_type) {
1259 case CODEC_TYPE_AUDIO:
1260 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1261 ist->st->codec->sample_rate;
1262 break;
1263 case CODEC_TYPE_VIDEO:
1264 if (ist->st->codec->time_base.num != 0) {
1265 ist->next_pts += ((int64_t)AV_TIME_BASE *
1266 ist->st->codec->time_base.num) /
1267 ist->st->codec->time_base.den;
1268 }
1269 break;
1270 }
1271 data_buf = ptr;
1272 data_size = len;
1273 ret = len;
1274 len = 0;
1275 }
1276
1277 buffer_to_free = NULL;
1278 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1279 pre_process_video_frame(ist, (AVPicture *)&picture,
1280 &buffer_to_free);
1281 }
1282
1283 // preprocess audio (volume)
1284 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1285 if (audio_volume != 256) {
1286 short *volp;
1287 volp = samples;
1288 for(i=0;i<(data_size / sizeof(short));i++) {
1289 int v = ((*volp) * audio_volume + 128) >> 8;
1290 if (v < -32768) v = -32768;
1291 if (v > 32767) v = 32767;
1292 *volp++ = v;
1293 }
1294 }
1295 }
1296
1297 /* frame rate emulation */
1298 if (ist->st->codec->rate_emu) {
1299 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1300 int64_t now = av_gettime() - ist->start;
1301 if (pts > now)
1302 usleep(pts - now);
1303
1304 ist->frame++;
1305 }
1306
1307 #if 0
1308 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1309 is the one of the next displayed one */
1310 /* XXX: add mpeg4 too ? */
1311 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1312 if (ist->st->codec->pict_type != B_TYPE) {
1313 int64_t tmp;
1314 tmp = ist->last_ip_pts;
1315 ist->last_ip_pts = ist->frac_pts.val;
1316 ist->frac_pts.val = tmp;
1317 }
1318 }
1319 #endif
1320 /* if output time reached then transcode raw format,
1321 encode packets and output them */
1322 if (start_time == 0 || ist->pts >= start_time)
1323 for(i=0;i<nb_ostreams;i++) {
1324 int frame_size;
1325
1326 ost = ost_table[i];
1327 if (ost->source_index == ist_index) {
1328 os = output_files[ost->file_index];
1329
1330 #if 0
1331 printf("%d: got pts=%0.3f %0.3f\n", i,
1332 (double)pkt->pts / AV_TIME_BASE,
1333 ((double)ist->pts / AV_TIME_BASE) -
1334 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1335 #endif
1336 /* set the input output pts pairs */
1337 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1338
1339 if (ost->encoding_needed) {
1340 switch(ost->st->codec->codec_type) {
1341 case CODEC_TYPE_AUDIO:
1342 do_audio_out(os, ost, ist, data_buf, data_size);
1343 break;
1344 case CODEC_TYPE_VIDEO:
1345 do_video_out(os, ost, ist, &picture, &frame_size);
1346 if (vstats_filename && frame_size)
1347 do_video_stats(os, ost, frame_size);
1348 break;
1349 case CODEC_TYPE_SUBTITLE:
1350 do_subtitle_out(os, ost, ist, &subtitle,
1351 pkt->pts);
1352 break;
1353 default:
1354 abort();
1355 }
1356 } else {
1357 AVFrame avframe; //FIXME/XXX remove this
1358 AVPacket opkt;
1359 av_init_packet(&opkt);
1360
1361 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1362 continue;
1363
1364 /* no reencoding needed : output the packet directly */
1365 /* force the input stream PTS */
1366
1367 avcodec_get_frame_defaults(&avframe);
1368 ost->st->codec->coded_frame= &avframe;
1369 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1370
1371 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1372 audio_size += data_size;
1373 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1374 video_size += data_size;
1375 ost->sync_opts++;
1376 }
1377
1378 opkt.stream_index= ost->index;
1379 if(pkt->pts != AV_NOPTS_VALUE)
1380 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1381 else
1382 opkt.pts= AV_NOPTS_VALUE;
1383
1384 if (pkt->dts == AV_NOPTS_VALUE)
1385 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1386 else
1387 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1388
1389 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1390 opkt.flags= pkt->flags;
1391
1392 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1393 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1394 opkt.destruct= av_destruct_packet;
1395
1396 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1397 ost->st->codec->frame_number++;
1398 ost->frame_number++;
1399 av_free_packet(&opkt);
1400 }
1401 }
1402 }
1403 av_free(buffer_to_free);
1404 /* XXX: allocate the subtitles in the codec ? */
1405 if (subtitle_to_free) {
1406 if (subtitle_to_free->rects != NULL) {
1407 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1408 av_free(subtitle_to_free->rects[i].bitmap);
1409 av_free(subtitle_to_free->rects[i].rgba_palette);
1410 }
1411 av_freep(&subtitle_to_free->rects);
1412 }
1413 subtitle_to_free->num_rects = 0;
1414 subtitle_to_free = NULL;
1415 }
1416 }
1417 discard_packet:
1418 if (pkt == NULL) {
1419 /* EOF handling */
1420
1421 for(i=0;i<nb_ostreams;i++) {
1422 ost = ost_table[i];
1423 if (ost->source_index == ist_index) {
1424 AVCodecContext *enc= ost->st->codec;
1425 os = output_files[ost->file_index];
1426
1427 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1428 continue;
1429 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1430 continue;
1431
1432 if (ost->encoding_needed) {
1433 for(;;) {
1434 AVPacket pkt;
1435 int fifo_bytes;
1436 av_init_packet(&pkt);
1437 pkt.stream_index= ost->index;
1438
1439 switch(ost->st->codec->codec_type) {
1440 case CODEC_TYPE_AUDIO:
1441 fifo_bytes = av_fifo_size(&ost->fifo);
1442 ret = 0;
1443 /* encode any samples remaining in fifo */
1444 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1445 int fs_tmp = enc->frame_size;
1446 enc->frame_size = fifo_bytes / (2 * enc->channels);
1447 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1448 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1449 enc->frame_size = fs_tmp;
1450 }
1451 if(ret <= 0) {
1452 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1453 }
1454 audio_size += ret;
1455 pkt.flags |= PKT_FLAG_KEY;
1456 break;
1457 case CODEC_TYPE_VIDEO:
1458 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1459 video_size += ret;
1460 if(enc->coded_frame && enc->coded_frame->key_frame)
1461 pkt.flags |= PKT_FLAG_KEY;
1462 if (ost->logfile && enc->stats_out) {
1463 fprintf(ost->logfile, "%s", enc->stats_out);
1464 }
1465 break;
1466 default:
1467 ret=-1;
1468 }
1469
1470 if(ret<=0)
1471 break;
1472 pkt.data= bit_buffer;
1473 pkt.size= ret;
1474 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1475 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1476 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1477 }
1478 }
1479 }
1480 }
1481 }
1482
1483 return 0;
1484 fail_decode:
1485 return -1;
1486 }
1487
1488 static void print_sdp(AVFormatContext **avc, int n)
1489 {
1490 char sdp[2048];
1491
1492 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1493 printf("SDP:\n%s\n", sdp);
1494 }
1495
1496 static int stream_index_from_inputs(AVFormatContext **input_files,
1497 int nb_input_files,
1498 AVInputFile *file_table,
1499 AVInputStream **ist_table,
1500 enum CodecType type,
1501 int programid)
1502 {
1503 int p, q, z;
1504 for(z=0; z<nb_input_files; z++) {
1505 AVFormatContext *ic = input_files[z];
1506 for(p=0; p<ic->nb_programs; p++) {
1507 AVProgram *program = ic->programs[p];
1508 if(program->id != programid)
1509 continue;
1510 for(q=0; q<program->nb_stream_indexes; q++) {
1511 int sidx = program->stream_index[q];
1512 int ris = file_table[z].ist_index + sidx;
1513 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1514 return ris;
1515 }
1516 }
1517 }
1518
1519 return -1;
1520 }
1521
1522 /*
1523 * The following code is the main loop of the file converter
1524 */
1525 static int av_encode(AVFormatContext **output_files,
1526 int nb_output_files,
1527 AVFormatContext **input_files,
1528 int nb_input_files,
1529 AVStreamMap *stream_maps, int nb_stream_maps)
1530 {
1531 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1532 AVFormatContext *is, *os;
1533 AVCodecContext *codec, *icodec;
1534 AVOutputStream *ost, **ost_table = NULL;
1535 AVInputStream *ist, **ist_table = NULL;
1536 AVInputFile *file_table;
1537 int key;
1538 int want_sdp = 1;
1539
1540 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1541 if (!file_table)
1542 goto fail;
1543
1544 /* input stream init */
1545 j = 0;
1546 for(i=0;i<nb_input_files;i++) {
1547 is = input_files[i];
1548 file_table[i].ist_index = j;
1549 file_table[i].nb_streams = is->nb_streams;
1550 j += is->nb_streams;
1551 }
1552 nb_istreams = j;
1553
1554 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1555 if (!ist_table)
1556 goto fail;
1557
1558 for(i=0;i<nb_istreams;i++) {
1559 ist = av_mallocz(sizeof(AVInputStream));
1560 if (!ist)
1561 goto fail;
1562 ist_table[i] = ist;
1563 }
1564 j = 0;
1565 for(i=0;i<nb_input_files;i++) {
1566 is = input_files[i];
1567 for(k=0;k<is->nb_streams;k++) {
1568 ist = ist_table[j++];
1569 ist->st = is->streams[k];
1570 ist->file_index = i;
1571 ist->index = k;
1572 ist->discard = 1; /* the stream is discarded by default
1573 (changed later) */
1574
1575 if (ist->st->codec->rate_emu) {
1576 ist->start = av_gettime();
1577 ist->frame = 0;
1578 }
1579 }
1580 }
1581
1582 /* output stream init */
1583 nb_ostreams = 0;
1584 for(i=0;i<nb_output_files;i++) {
1585 os = output_files[i];
1586 if (!os->nb_streams) {
1587 fprintf(stderr, "Output file does not contain any stream\n");
1588 av_exit(1);
1589 }
1590 nb_ostreams += os->nb_streams;
1591 }
1592 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1593 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1594 av_exit(1);
1595 }
1596
1597 /* Sanity check the mapping args -- do the input files & streams exist? */
1598 for(i=0;i<nb_stream_maps;i++) {
1599 int fi = stream_maps[i].file_index;
1600 int si = stream_maps[i].stream_index;
1601
1602 if (fi < 0 || fi > nb_input_files - 1 ||
1603 si < 0 || si > file_table[fi].nb_streams - 1) {
1604 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1605 av_exit(1);
1606 }
1607 fi = stream_maps[i].sync_file_index;
1608 si = stream_maps[i].sync_stream_index;
1609 if (fi < 0 || fi > nb_input_files - 1 ||
1610 si < 0 || si > file_table[fi].nb_streams - 1) {
1611 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1612 av_exit(1);
1613 }
1614 }
1615
1616 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1617 if (!ost_table)
1618 goto fail;
1619 for(i=0;i<nb_ostreams;i++) {
1620 ost = av_mallocz(sizeof(AVOutputStream));
1621 if (!ost)
1622 goto fail;
1623 ost_table[i] = ost;
1624 }
1625
1626 n = 0;
1627 for(k=0;k<nb_output_files;k++) {
1628 os = output_files[k];
1629 for(i=0;i<os->nb_streams;i++) {
1630 int found;
1631 ost = ost_table[n++];
1632 ost->file_index = k;
1633 ost->index = i;
1634 ost->st = os->streams[i];
1635 if (nb_stream_maps > 0) {
1636 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1637 stream_maps[n-1].stream_index;
1638
1639 /* Sanity check that the stream types match */
1640 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1641 int i= ost->file_index;
1642 dump_format(output_files[i], i, output_files[i]->filename, 1);
1643 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1644 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1645 ost->file_index, ost->index);
1646 av_exit(1);
1647 }
1648
1649 } else {
1650 if(opt_programid) {
1651 found = 0;
1652 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1653 if(j != -1) {
1654 ost->source_index = j;
1655 found = 1;
1656 }
1657 } else {
1658 /* get corresponding input stream index : we select the first one with the right type */
1659 found = 0;
1660 for(j=0;j<nb_istreams;j++) {
1661 ist = ist_table[j];
1662 if (ist->discard &&
1663 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1664 ost->source_index = j;
1665 found = 1;
1666 break;
1667 }
1668 }
1669 }
1670
1671 if (!found) {
1672 if(! opt_programid) {
1673 /* try again and reuse existing stream */
1674 for(j=0;j<nb_istreams;j++) {
1675 ist = ist_table[j];
1676 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1677 ost->source_index = j;
1678 found = 1;
1679 }
1680 }
1681 }
1682 if (!found) {
1683 int i= ost->file_index;
1684 dump_format(output_files[i], i, output_files[i]->filename, 1);
1685 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1686 ost->file_index, ost->index);
1687 av_exit(1);
1688 }
1689 }
1690 }
1691 ist = ist_table[ost->source_index];
1692 ist->discard = 0;
1693 ost->sync_ist = (nb_stream_maps > 0) ?
1694 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1695 stream_maps[n-1].sync_stream_index] : ist;
1696 }
1697 }
1698
1699 /* for each output stream, we compute the right encoding parameters */
1700 for(i=0;i<nb_ostreams;i++) {
1701 ost = ost_table[i];
1702 os = output_files[ost->file_index];
1703 ist = ist_table[ost->source_index];
1704
1705 codec = ost->st->codec;
1706 icodec = ist->st->codec;
1707
1708 if (!ost->st->language[0])
1709 av_strlcpy(ost->st->language, ist->st->language,
1710 sizeof(ost->st->language));
1711
1712 ost->st->disposition = ist->st->disposition;
1713
1714 if (ost->st->stream_copy) {
1715 /* if stream_copy is selected, no need to decode or encode */
1716 codec->codec_id = icodec->codec_id;
1717 codec->codec_type = icodec->codec_type;
1718
1719 if(!codec->codec_tag){
1720 if( !os->oformat->codec_tag
1721 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1722 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1723 codec->codec_tag = icodec->codec_tag;
1724 }
1725
1726 codec->bit_rate = icodec->bit_rate;
1727 codec->extradata= icodec->extradata;
1728 codec->extradata_size= icodec->extradata_size;
1729 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1730 codec->time_base = icodec->time_base;
1731 else
1732 codec->time_base = ist->st->time_base;
1733 switch(codec->codec_type) {
1734 case CODEC_TYPE_AUDIO:
1735 if(audio_volume != 256) {
1736 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1737 av_exit(1);
1738 }
1739 codec->sample_rate = icodec->sample_rate;
1740 codec->channels = icodec->channels;
1741 codec->frame_size = icodec->frame_size;
1742 codec->block_align= icodec->block_align;
1743 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1744 codec->block_align= 0;
1745 if(codec->codec_id == CODEC_ID_AC3)
1746 codec->block_align= 0;
1747 break;
1748 case CODEC_TYPE_VIDEO:
1749 if(using_vhook) {
1750 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1751 av_exit(1);
1752 }
1753 codec->pix_fmt = icodec->pix_fmt;
1754 codec->width = icodec->width;
1755 codec->height = icodec->height;
1756 codec->has_b_frames = icodec->has_b_frames;
1757 break;
1758 case CODEC_TYPE_SUBTITLE:
1759 break;
1760 default:
1761 abort();
1762 }
1763 } else {
1764 switch(codec->codec_type) {
1765 case CODEC_TYPE_AUDIO:
1766 if (av_fifo_init(&ost->fifo, 1024))
1767 goto fail;
1768 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1769 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1770 icodec->request_channels = codec->channels;
1771 ist->decoding_needed = 1;
1772 ost->encoding_needed = 1;
1773 break;
1774 case CODEC_TYPE_VIDEO:
1775 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1776 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1777 ost->video_resample = ((codec->width != icodec->width -
1778 (frame_leftBand + frame_rightBand) +
1779 (frame_padleft + frame_padright)) ||
1780 (codec->height != icodec->height -
1781 (frame_topBand + frame_bottomBand) +
1782 (frame_padtop + frame_padbottom)) ||
1783 (codec->pix_fmt != icodec->pix_fmt));
1784 if (ost->video_crop) {
1785 ost->topBand = frame_topBand;
1786 ost->leftBand = frame_leftBand;
1787 }
1788 if (ost->video_pad) {
1789 ost->padtop = frame_padtop;
1790 ost->padleft = frame_padleft;
1791 ost->padbottom = frame_padbottom;
1792 ost->padright = frame_padright;
1793 if (!ost->video_resample) {
1794 avcodec_get_frame_defaults(&ost->pict_tmp);
1795 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1796 codec->width, codec->height))
1797 goto fail;
1798 }
1799 }
1800 if (ost->video_resample) {
1801 avcodec_get_frame_defaults(&ost->pict_tmp);
1802 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1803 codec->width, codec->height)) {
1804 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1805 av_exit(1);
1806 }
1807 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1808 ost->img_resample_ctx = sws_getContext(
1809 icodec->width - (frame_leftBand + frame_rightBand),
1810 icodec->height - (frame_topBand + frame_bottomBand),
1811 icodec->pix_fmt,
1812 codec->width - (frame_padleft + frame_padright),
1813 codec->height - (frame_padtop + frame_padbottom),
1814 codec->pix_fmt,
1815 sws_flags, NULL, NULL, NULL);
1816 if (ost->img_resample_ctx == NULL) {
1817 fprintf(stderr, "Cannot get resampling context\n");
1818 av_exit(1);
1819 }
1820 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1821 }
1822 ost->encoding_needed = 1;
1823 ist->decoding_needed = 1;
1824 break;
1825 case CODEC_TYPE_SUBTITLE:
1826 ost->encoding_needed = 1;
1827 ist->decoding_needed = 1;
1828 break;
1829 default:
1830 abort();
1831 break;
1832 }
1833 /* two pass mode */
1834 if (ost->encoding_needed &&
1835 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1836 char logfilename[1024];
1837 FILE *f;
1838 int size;
1839 char *logbuffer;
1840
1841 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1842 pass_logfilename ?
1843 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1844 if (codec->flags & CODEC_FLAG_PASS1) {
1845 f = fopen(logfilename, "w");
1846 if (!f) {
1847 perror(logfilename);
1848 av_exit(1);
1849 }
1850 ost->logfile = f;
1851 } else {
1852 /* read the log file */
1853 f = fopen(logfilename, "r");
1854 if (!f) {
1855 perror(logfilename);
1856 av_exit(1);
1857 }
1858 fseek(f, 0, SEEK_END);
1859 size = ftell(f);
1860 fseek(f, 0, SEEK_SET);
1861 logbuffer = av_malloc(size + 1);
1862 if (!logbuffer) {
1863 fprintf(stderr, "Could not allocate log buffer\n");
1864 av_exit(1);
1865 }
1866 size = fread(logbuffer, 1, size, f);
1867 fclose(f);
1868 logbuffer[size] = '\0';
1869 codec->stats_in = logbuffer;
1870 }
1871 }
1872 }
1873 if(codec->codec_type == CODEC_TYPE_VIDEO){
1874 int size= codec->width * codec->height;
1875 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1876 }
1877 }
1878
1879 if (!bit_buffer)
1880 bit_buffer = av_malloc(bit_buffer_size);
1881 if (!bit_buffer)
1882 goto fail;
1883
1884 /* dump the file output parameters - cannot be done before in case
1885 of stream copy */
1886 for(i=0;i<nb_output_files;i++) {
1887 dump_format(output_files[i], i, output_files[i]->filename, 1);
1888 }
1889
1890 /* dump the stream mapping */
1891 if (verbose >= 0) {
1892 fprintf(stderr, "Stream mapping:\n");
1893 for(i=0;i<nb_ostreams;i++) {
1894 ost = ost_table[i];
1895 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1896 ist_table[ost->source_index]->file_index,
1897 ist_table[ost->source_index]->index,
1898 ost->file_index,
1899 ost->index);
1900 if (ost->sync_ist != ist_table[ost->source_index])
1901 fprintf(stderr, " [sync #%d.%d]",
1902 ost->sync_ist->file_index,
1903 ost->sync_ist->index);
1904 fprintf(stderr, "\n");
1905 }
1906 }
1907
1908 /* open each encoder */
1909 for(i=0;i<nb_ostreams;i++) {
1910 ost = ost_table[i];
1911 if (ost->encoding_needed) {
1912 AVCodec *codec;
1913 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1914 if (!codec) {
1915 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1916 ost->file_index, ost->index);
1917 av_exit(1);
1918 }
1919 if (avcodec_open(ost->st->codec, codec) < 0) {
1920 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1921 ost->file_index, ost->index);
1922 av_exit(1);
1923 }
1924 extra_size += ost->st->codec->extradata_size;
1925 }
1926 }
1927
1928 /* open each decoder */
1929 for(i=0;i<nb_istreams;i++) {
1930 ist = ist_table[i];
1931 if (ist->decoding_needed) {
1932 AVCodec *codec;
1933 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1934 if (!codec) {
1935 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1936 ist->st->codec->codec_id, ist->file_index, ist->index);
1937 av_exit(1);
1938 }
1939 if (avcodec_open(ist->st->codec, codec) < 0) {
1940 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1941 ist->file_index, ist->index);
1942 av_exit(1);
1943 }
1944 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1945 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1946 }
1947 }
1948
1949 /* init pts */
1950 for(i=0;i<nb_istreams;i++) {
1951 ist = ist_table[i];
1952 is = input_files[ist->file_index];
1953 ist->pts = 0;
1954 ist->next_pts = AV_NOPTS_VALUE;
1955 ist->is_start = 1;
1956 }
1957
1958 /* set meta data information from input file if required */
1959 for (i=0;i<nb_meta_data_maps;i++) {
1960 AVFormatContext *out_file;
1961 AVFormatContext *in_file;
1962
1963 int out_file_index = meta_data_maps[i].out_file;
1964 int in_file_index = meta_data_maps[i].in_file;
1965 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1966 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1967 ret = AVERROR(EINVAL);
1968 goto fail;
1969 }
1970 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1971 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1972 ret = AVERROR(EINVAL);
1973 goto fail;
1974 }
1975
1976 out_file = output_files[out_file_index];
1977 in_file = input_files[in_file_index];
1978
1979 strcpy(out_file->title, in_file->title);
1980 strcpy(out_file->author, in_file->author);
1981 strcpy(out_file->copyright, in_file->copyright);
1982 strcpy(out_file->comment, in_file->comment);
1983 strcpy(out_file->album, in_file->album);
1984 out_file->year = in_file->year;
1985 out_file->track = in_file->track;
1986 strcpy(out_file->genre, in_file->genre);
1987 }
1988
1989 /* open files and write file headers */
1990 for(i=0;i<nb_output_files;i++) {
1991 os = output_files[i];
1992 if (av_write_header(os) < 0) {
1993 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1994 ret = AVERROR(EINVAL);
1995 goto fail;
1996 }
1997 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1998 want_sdp = 0;
1999 }
2000 }
2001 if (want_sdp) {
2002 print_sdp(output_files, nb_output_files);
2003 }
2004
2005 if (!using_stdin && verbose >= 0) {
2006 fprintf(stderr, "Press [q] to stop encoding\n");
2007 url_set_interrupt_cb(decode_interrupt_cb);
2008 }
2009 term_init();
2010
2011 key = -1;
2012 timer_start = av_gettime();
2013
2014 for(; received_sigterm == 0;) {
2015 int file_index, ist_index;
2016 AVPacket pkt;
2017 double ipts_min;
2018 double opts_min;
2019
2020 redo:
2021 ipts_min= 1e100;
2022 opts_min= 1e100;
2023 /* if 'q' pressed, exits */
2024 if (!using_stdin) {
2025 if (q_pressed)
2026 break;
2027 /* read_key() returns 0 on EOF */
2028 key = read_key();
2029 if (key == 'q')
2030 break;
2031 }
2032
2033 /* select the stream that we must read now by looking at the
2034 smallest output pts */
2035 file_index = -1;
2036 for(i=0;i<nb_ostreams;i++) {
2037 double ipts, opts;
2038 ost = ost_table[i];
2039 os = output_files[ost->file_index];
2040 ist = ist_table[ost->source_index];
2041 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2042 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2043 else
2044 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2045 ipts = (double)ist->pts;
2046 if (!file_table[ist->file_index].eof_reached){
2047 if(ipts < ipts_min) {
2048 ipts_min = ipts;
2049 if(input_sync ) file_index = ist->file_index;
2050 }
2051 if(opts < opts_min) {
2052 opts_min = opts;
2053 if(!input_sync) file_index = ist->file_index;
2054 }
2055 }
2056 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2057 file_index= -1;
2058 break;
2059 }
2060 }
2061 /* if none, if is finished */
2062 if (file_index < 0) {
2063 break;
2064 }
2065
2066 /* finish if recording time exhausted */
2067 if (opts_min >= (recording_time / 1000000.0))
2068 break;
2069
2070 /* finish if limit size exhausted */
2071 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2072 break;
2073
2074 /* read a frame from it and output it in the fifo */
2075 is = input_files[file_index];
2076 if (av_read_frame(is, &pkt) < 0) {
2077 file_table[file_index].eof_reached = 1;
2078 if (opt_shortest)
2079 break;
2080 else
2081 continue;
2082 }
2083
2084 if (do_pkt_dump) {
2085 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2086 }
2087 /* the following test is needed in case new streams appear
2088 dynamically in stream : we ignore them */
2089 if (pkt.stream_index >= file_table[file_index].nb_streams)
2090 goto discard_packet;
2091 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2092 ist = ist_table[ist_index];
2093 if (ist->discard)
2094 goto discard_packet;
2095
2096 if (pkt.dts != AV_NOPTS_VALUE)
2097 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2098 if (pkt.pts != AV_NOPTS_VALUE)
2099 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2100
2101 if(input_files_ts_scale[file_index][pkt.stream_index]){
2102 if(pkt.pts != AV_NOPTS_VALUE)
2103 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2104 if(pkt.dts != AV_NOPTS_VALUE)
2105 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2106 }
2107
2108 // 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);
2109 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2110 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2111 int64_t delta= pkt_dts - ist->next_pts;
2112 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2113 input_files_ts_offset[ist->file_index]-= delta;
2114 if (verbose > 2)
2115 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2116 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2117 if(pkt.pts != AV_NOPTS_VALUE)
2118 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2119 }
2120 }
2121
2122 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2123 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2124
2125 if (verbose >= 0)
2126 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2127 ist->file_index, ist->index);
2128
2129 av_free_packet(&pkt);
2130 goto redo;
2131 }
2132
2133 discard_packet:
2134 av_free_packet(&pkt);
2135
2136 /* dump report by using the output first video and audio streams */
2137 print_report(output_files, ost_table, nb_ostreams, 0);
2138 }
2139
2140 /* at the end of stream, we must flush the decoder buffers */
2141 for(i=0;i<nb_istreams;i++) {
2142 ist = ist_table[i];
2143 if (ist->decoding_needed) {
2144 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2145 }
2146 }
2147
2148 term_exit();
2149
2150 /* write the trailer if needed and close file */
2151 for(i=0;i<nb_output_files;i++) {
2152 os = output_files[i];
2153 av_write_trailer(os);
2154 }
2155
2156 /* dump report by using the first video and audio streams */
2157 print_report(output_files, ost_table, nb_ostreams, 1);
2158
2159 /* close each encoder */
2160 for(i=0;i<nb_ostreams;i++) {
2161 ost = ost_table[i];
2162 if (ost->encoding_needed) {
2163 av_freep(&ost->st->codec->stats_in);
2164 avcodec_close(ost->st->codec);
2165 }
2166 }
2167
2168 /* close each decoder */
2169 for(i=0;i<nb_istreams;i++) {
2170 ist = ist_table[i];
2171 if (ist->decoding_needed) {
2172 avcodec_close(ist->st->codec);
2173 }
2174 }
2175
2176 /* finished ! */
2177
2178 ret = 0;
2179 fail1:
2180 av_freep(&bit_buffer);
2181 av_free(file_table);
2182
2183 if (ist_table) {
2184 for(i=0;i<nb_istreams;i++) {
2185 ist = ist_table[i];
2186 av_free(ist);
2187 }
2188 av_free(ist_table);
2189 }
2190 if (ost_table) {
2191 for(i=0;i<nb_ostreams;i++) {
2192 ost = ost_table[i];
2193 if (ost) {
2194 if (ost->logfile) {
2195 fclose(ost->logfile);
2196 ost->logfile = NULL;
2197 }
2198 av_fifo_free(&ost->fifo); /* works even if fifo is not
2199 initialized but set to zero */
2200 av_free(ost->pict_tmp.data[0]);
2201 if (ost->video_resample)
2202 sws_freeContext(ost->img_resample_ctx);
2203 if (ost->resample)
2204 audio_resample_close(ost->resample);
2205 if (ost->reformat_ctx)
2206 av_audio_convert_free(ost->reformat_ctx);
2207 av_free(ost);
2208 }
2209 }
2210 av_free(ost_table);
2211 }
2212 return ret;
2213 fail:
2214 ret = AVERROR(ENOMEM);
2215 goto fail1;
2216 }
2217
2218 #if 0
2219 int file_read(const char *filename)
2220 {
2221 URLContext *h;
2222 unsigned char buffer[1024];
2223 int len, i;
2224
2225 if (url_open(&h, filename, O_RDONLY) < 0) {
2226 printf("could not open '%s'\n", filename);
2227 return -1;
2228 }
2229 for(;;) {
2230 len = url_read(h, buffer, sizeof(buffer));
2231 if (len <= 0)
2232 break;
2233 for(i=0;i<len;i++) putchar(buffer[i]);
2234 }
2235 url_close(h);
2236 return 0;
2237 }
2238 #endif
2239
2240 static void opt_format(const char *arg)
2241 {
2242 /* compatibility stuff for pgmyuv */
2243 if (!strcmp(arg, "pgmyuv")) {
2244 pgmyuv_compatibility_hack=1;
2245 // opt_image_format(arg);
2246 arg = "image2";
2247 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2248 }
2249
2250 file_iformat = av_find_input_format(arg);
2251 file_oformat = guess_format(arg, NULL, NULL);
2252 if (!file_iformat && !file_oformat) {
2253 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2254 av_exit(1);
2255 }
2256 }
2257
2258 static int opt_default(const char *opt, const char *arg){
2259 int type;
2260 const AVOption *o= NULL;
2261 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2262
2263 for(type=0; type<CODEC_TYPE_NB; type++){
2264 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2265 if(o2)
2266 o = av_set_string2(avctx_opts[type], opt, arg, 1);
2267 }
2268 if(!o)
2269 o = av_set_string2(avformat_opts, opt, arg, 1);
2270 if(!o)
2271 o = av_set_string2(sws_opts, opt, arg, 1);
2272 if(!o){
2273 if(opt[0] == 'a')
2274 o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2275 else if(opt[0] == 'v')
2276 o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2277 else if(opt[0] == 's')
2278 o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2279 }
2280 if(!o)
2281 return -1;
2282
2283 // 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));
2284
2285 //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
2286 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2287 opt_names[opt_name_count++]= o->name;
2288
2289 if(avctx_opts[0]->debug || avformat_opts->debug)
2290 av_log_set_level(AV_LOG_DEBUG);
2291 return 0;
2292 }
2293
2294 static void opt_video_rc_override_string(const char *arg)
2295 {
2296 video_rc_override_string = arg;
2297 }
2298
2299 static int opt_me_threshold(const char *opt, const char *arg)
2300 {
2301 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2302 return 0;
2303 }
2304
2305 static int opt_verbose(const char *opt, const char *arg)
2306 {
2307 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2308 av_log_set_level(verbose);
2309 return 0;
2310 }
2311
2312 static void opt_frame_rate(const char *arg)
2313 {
2314 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2315 fprintf(stderr, "Incorrect frame rate\n");
2316 av_exit(1);
2317 }
2318 }
2319
2320 static int opt_bitrate(const char *opt, const char *arg)
2321 {
2322 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2323
2324 opt_default(opt, arg);
2325
2326 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2327 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2328
2329 return 0;
2330 }
2331
2332 static void opt_frame_crop_top(const char *arg)
2333 {
2334 frame_topBand = atoi(arg);
2335 if (frame_topBand < 0) {
2336 fprintf(stderr, "Incorrect top crop size\n");
2337 av_exit(1);
2338 }
2339 if ((frame_topBand % 2) != 0) {
2340 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2341 av_exit(1);
2342 }
2343 if ((frame_topBand) >= frame_height){
2344 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2345 av_exit(1);
2346 }
2347 frame_height -= frame_topBand;
2348 }
2349
2350 static void opt_frame_crop_bottom(const char *arg)
2351 {
2352 frame_bottomBand = atoi(arg);
2353 if (frame_bottomBand < 0) {
2354 fprintf(stderr, "Incorrect bottom crop size\n");
2355 av_exit(1);
2356 }
2357 if ((frame_bottomBand % 2) != 0) {
2358 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2359 av_exit(1);
2360 }
2361 if ((frame_bottomBand) >= frame_height){
2362 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2363 av_exit(1);
2364 }
2365 frame_height -= frame_bottomBand;
2366 }
2367
2368 static void opt_frame_crop_left(const char *arg)
2369 {
2370 frame_leftBand = atoi(arg);
2371 if (frame_leftBand < 0) {
2372 fprintf(stderr, "Incorrect left crop size\n");
2373 av_exit(1);
2374 }
2375 if ((frame_leftBand % 2) != 0) {
2376 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2377 av_exit(1);
2378 }
2379 if ((frame_leftBand) >= frame_width){
2380 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2381 av_exit(1);
2382 }
2383 frame_width -= frame_leftBand;
2384 }
2385
2386 static void opt_frame_crop_right(const char *arg)
2387 {
2388 frame_rightBand = atoi(arg);
2389 if (frame_rightBand < 0) {
2390 fprintf(stderr, "Incorrect right crop size\n");
2391 av_exit(1);
2392 }
2393 if ((frame_rightBand % 2) != 0) {
2394 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2395 av_exit(1);
2396 }
2397 if ((frame_rightBand) >= frame_width){
2398 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2399 av_exit(1);
2400 }
2401 frame_width -= frame_rightBand;
2402 }
2403
2404 static void opt_frame_size(const char *arg)
2405 {
2406 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2407 fprintf(stderr, "Incorrect frame size\n");
2408 av_exit(1);
2409 }
2410 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2411 fprintf(stderr, "Frame size must be a multiple of 2\n");
2412 av_exit(1);
2413 }
2414 }
2415
2416
2417 #define SCALEBITS 10
2418 #define ONE_HALF (1 << (SCALEBITS - 1))
2419 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2420
2421 #define RGB_TO_Y(r, g, b) \
2422 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2423 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2424
2425 #define RGB_TO_U(r1, g1, b1, shift)\
2426 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2427 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2428
2429 #define RGB_TO_V(r1, g1, b1, shift)\
2430 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2431 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2432
2433 static void opt_pad_color(const char *arg) {
2434 /* Input is expected to be six hex digits similar to
2435 how colors are expressed in html tags (but without the #) */
2436 int rgb = strtol(arg, NULL, 16);
2437 int r,g,b;
2438
2439 r = (rgb >> 16);
2440 g = ((rgb >> 8) & 255);
2441 b = (rgb & 255);
2442
2443 padcolor[0] = RGB_TO_Y(r,g,b);
2444 padcolor[1] = RGB_TO_U(r,g,b,0);
2445 padcolor[2] = RGB_TO_V(r,g,b,0);
2446 }
2447
2448 static void opt_frame_pad_top(const char *arg)
2449 {
2450 frame_padtop = atoi(arg);
2451 if (frame_padtop < 0) {
2452 fprintf(stderr, "Incorrect top pad size\n");
2453 av_exit(1);
2454 }
2455 if ((frame_padtop % 2) != 0) {
2456 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2457 av_exit(1);
2458 }
2459 }
2460
2461 static void opt_frame_pad_bottom(const char *arg)
2462 {
2463 frame_padbottom = atoi(arg);
2464 if (frame_padbottom < 0) {
2465 fprintf(stderr, "Incorrect bottom pad size\n");
2466 av_exit(1);
2467 }
2468 if ((frame_padbottom % 2) != 0) {
2469 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2470 av_exit(1);
2471 }
2472 }
2473
2474
2475 static void opt_frame_pad_left(const char *arg)
2476 {
2477 frame_padleft = atoi(arg);
2478 if (frame_padleft < 0) {
2479 fprintf(stderr, "Incorrect left pad size\n");
2480 av_exit(1);
2481 }
2482 if ((frame_padleft % 2) != 0) {
2483 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2484 av_exit(1);
2485 }
2486 }
2487
2488
2489 static void opt_frame_pad_right(const char *arg)
2490 {
2491 frame_padright = atoi(arg);
2492 if (frame_padright < 0) {
2493 fprintf(stderr, "Incorrect right pad size\n");
2494 av_exit(1);
2495 }
2496 if ((frame_padright % 2) != 0) {
2497 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2498 av_exit(1);
2499 }
2500 }
2501
2502 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2503 {
2504 int i;
2505 char fmt_str[128];
2506 for (i=-1; i < nb_fmts; i++) {
2507 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2508 fprintf(stdout, "%s\n", fmt_str);
2509 }
2510 }
2511
2512 static void opt_frame_pix_fmt(const char *arg)
2513 {
2514 if (strcmp(arg, "list"))
2515 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2516 else {
2517 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2518 av_exit(0);
2519 }
2520 }
2521
2522 static void opt_frame_aspect_ratio(const char *arg)
2523 {
2524 int x = 0, y = 0;
2525 double ar = 0;
2526 const char *p;
2527 char *end;
2528
2529 p = strchr(arg, ':');
2530 if (p) {
2531 x = strtol(arg, &end, 10);
2532 if (end == p)
2533 y = strtol(end+1, &end, 10);
2534 if (x > 0 && y > 0)
2535 ar = (double)x / (double)y;
2536 } else
2537 ar = strtod(arg, NULL);
2538
2539 if (!ar) {
2540 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2541 av_exit(1);
2542 }
2543 frame_aspect_ratio = ar;
2544 }
2545
2546 static void opt_qscale(const char *arg)
2547 {
2548 video_qscale = atof(arg);
2549 if (video_qscale <= 0 ||
2550 video_qscale > 255) {
2551 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2552 av_exit(1);
2553 }
2554 }
2555
2556 static void opt_top_field_first(const char *arg)
2557 {
2558 top_field_first= atoi(arg);
2559 }
2560
2561 static int opt_thread_count(const char *opt, const char *arg)
2562 {
2563 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2564 #if !defined(HAVE_THREADS)
2565 if (verbose >= 0)
2566 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2567 #endif
2568 return 0;
2569 }
2570
2571 static void opt_audio_sample_fmt(const char *arg)
2572 {
2573 if (strcmp(arg, "list"))
2574 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2575 else {
2576 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2577 av_exit(0);
2578 }
2579 }
2580
2581 static int opt_audio_rate(const char *opt, const char *arg)
2582 {
2583 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2584 return 0;
2585 }
2586
2587 static int opt_audio_channels(const char *opt, const char *arg)
2588 {
2589 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2590 return 0;
2591 }
2592
2593 static void opt_video_channel(const char *arg)
2594 {
2595 video_channel = strtol(arg, NULL, 0);
2596 }
2597
2598 static void opt_video_standard(const char *arg)
2599 {
2600 video_standard = av_strdup(arg);
2601 }
2602
2603 static void opt_codec(int *pstream_copy, char **pcodec_name,
2604 int codec_type, const char *arg)
2605 {
2606 av_freep(pcodec_name);
2607 if (!strcmp(arg, "copy")) {
2608 *pstream_copy = 1;
2609 } else {
2610 *pcodec_name = av_strdup(arg);
2611 }
2612 }
2613
2614 static void opt_audio_codec(const char *arg)
2615 {
2616 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2617 }
2618
2619 static void opt_audio_tag(const char *arg)
2620 {
2621 char *tail;
2622 audio_codec_tag= strtol(arg, &tail, 0);
2623
2624 if(!tail || *tail)
2625 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2626 }
2627
2628 static void opt_video_tag(const char *arg)
2629 {
2630 char *tail;
2631 video_codec_tag= strtol(arg, &tail, 0);
2632
2633 if(!tail || *tail)
2634 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2635 }
2636
2637 #ifdef CONFIG_VHOOK
2638 static void add_frame_hooker(const char *arg)
2639 {
2640 int argc = 0;
2641 char *argv[64];
2642 int i;
2643 char *args = av_strdup(arg);
2644
2645 using_vhook = 1;
2646
2647 argv[0] = strtok(args, " ");
2648 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2649 }
2650
2651 i = frame_hook_add(argc, argv);
2652
2653 if (i != 0) {
2654 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2655 av_exit(1);
2656 }
2657 }
2658 #endif
2659
2660 static void opt_video_codec(const char *arg)
2661 {
2662 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2663 }
2664
2665 static void opt_subtitle_codec(const char *arg)
2666 {
2667 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2668 }
2669
2670 static void opt_map(const char *arg)
2671 {
2672 AVStreamMap *m;
2673 char *p;
2674
2675 m = &stream_maps[nb_stream_maps++];
2676
2677 m->file_index = strtol(arg, &p, 0);
2678 if (*p)
2679 p++;
2680
2681 m->stream_index = strtol(p, &p, 0);
2682 if (*p) {
2683 p++;
2684 m->sync_file_index = strtol(p, &p, 0);
2685 if (*p)
2686 p++;
2687 m->sync_stream_index = strtol(p, &p, 0);
2688 } else {
2689 m->sync_file_index = m->file_index;
2690 m->sync_stream_index = m->stream_index;
2691 }
2692 }
2693
2694 static void opt_map_meta_data(const char *arg)
2695 {
2696 AVMetaDataMap *m;
2697 char *p;
2698
2699 m = &meta_data_maps[nb_meta_data_maps++];
2700
2701 m->out_file = strtol(arg, &p, 0);
2702 if (*p)
2703 p++;
2704
2705 m->in_file = strtol(p, &p, 0);
2706 }
2707
2708 static void opt_input_ts_scale(const char *arg)
2709 {
2710 unsigned int stream;
2711 double scale;
2712 char *p;
2713
2714 stream = strtol(arg, &p, 0);
2715 if (*p)
2716 p++;
2717 scale= strtod(p, &p);
2718
2719 if(stream >= MAX_STREAMS)
2720 av_exit(1);
2721
2722 input_files_ts_scale[nb_input_files][stream]= scale;
2723 }
2724
2725 static int opt_recording_time(const char *opt, const char *arg)
2726 {
2727 recording_time = parse_time_or_die(opt, arg, 1);
2728 return 0;
2729 }
2730
2731 static int opt_start_time(const char *opt, const char *arg)
2732 {
2733 start_time = parse_time_or_die(opt, arg, 1);
2734 return 0;
2735 }
2736
2737 static int opt_rec_timestamp(const char *opt, const char *arg)
2738 {
2739 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2740 return 0;
2741 }
2742
2743 static int opt_input_ts_offset(const char *opt, const char *arg)
2744 {
2745 input_ts_offset = parse_time_or_die(opt, arg, 1);
2746 return 0;
2747 }
2748
2749 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2750 {
2751 const char *codec_string = encoder ? "encoder" : "decoder";
2752 AVCodec *codec;
2753
2754 if(!name)
2755 return CODEC_ID_NONE;
2756 codec = encoder ?
2757 avcodec_find_encoder_by_name(name) :
2758 avcodec_find_decoder_by_name(name);
2759 if(!codec) {
2760 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2761 av_exit(1);
2762 }
2763 if(codec->type != type) {
2764 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2765 av_exit(1);
2766 }
2767 return codec->id;
2768 }
2769
2770 static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2771 {
2772 int i;
2773 for(i=0; i<opt_name_count; i++){
2774 char buf[256];
2775 const AVOption *opt;
2776 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2777 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2778 if(str && ((opt->flags & flags) == flags))
2779 av_set_string2(ctx, opt_names[i], str, 1);
2780 }
2781 }
2782
2783 static void opt_input_file(const char *filename)
2784 {
2785 AVFormatContext *ic;
2786 AVFormatParameters params, *ap = &params;
2787 int err, i, ret, rfps, rfps_base;
2788 int64_t timestamp;
2789
2790 if (!strcmp(filename, "-"))
2791 filename = "pipe:";
2792
2793 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2794 !strcmp(filename, "/dev/stdin");
2795
2796 /* get default parameters from command line */
2797 ic = av_alloc_format_context();
2798
2799 memset(ap, 0, sizeof(*ap));
2800 ap->prealloced_context = 1;
2801 ap->sample_rate = audio_sample_rate;
2802 ap->channels = audio_channels;
2803 ap->time_base.den = frame_rate.num;
2804 ap->time_base.num = frame_rate.den;
2805 ap->width = frame_width + frame_padleft + frame_padright;
2806 ap->height = frame_height + frame_padtop + frame_padbottom;
2807 ap->pix_fmt = frame_pix_fmt;
2808 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2809 ap->channel = video_channel;
2810 ap->standard = video_standard;
2811 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2812 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2813 if(pgmyuv_compatibility_hack)
2814 ap->video_codec_id= CODEC_ID_PGMYUV;
2815
2816 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2817
2818 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2819 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2820 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2821
2822 /* open the input file with generic libav function */
2823 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2824 if (err < 0) {
2825 print_error(filename, err);
2826 av_exit(1);
2827 }
2828 if(opt_programid) {
2829 int i;
2830 for(i=0; i<ic->nb_programs; i++)
2831 if(ic->programs[i]->id != opt_programid)
2832 ic->programs[i]->discard = AVDISCARD_ALL;
2833 }
2834
2835 ic->loop_input = loop_input;
2836
2837 /* If not enough info to get the stream parameters, we decode the
2838 first frames to get it. (used in mpeg case for example) */
2839 ret = av_find_stream_info(ic);
2840 if (ret < 0 && verbose >= 0) {
2841 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2842 av_exit(1);
2843 }
2844
2845 timestamp = start_time;
2846 /* add the stream start time */
2847 if (ic->start_time != AV_NOPTS_VALUE)
2848 timestamp += ic->start_time;
2849
2850 /* if seeking requested, we execute it */
2851 if (start_time != 0) {
2852 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2853 if (ret < 0) {
2854 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2855 filename, (double)timestamp / AV_TIME_BASE);
2856 }
2857 /* reset seek info */
2858 start_time = 0;
2859 }
2860
2861 /* update the current parameters so that they match the one of the input stream */
2862 for(i=0;i<ic->nb_streams;i++) {
2863 AVCodecContext *enc = ic->streams[i]->codec;
2864 if(thread_count>1)
2865 avcodec_thread_init(enc, thread_count);
2866 enc->thread_count= thread_count;
2867 switch(enc->codec_type) {
2868 case CODEC_TYPE_AUDIO:
2869 set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2870 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2871 audio_channels = enc->channels;
2872 audio_sample_rate = enc->sample_rate;
2873 audio_sample_fmt = enc->sample_fmt;
2874 if(audio_disable)
2875 ic->streams[i]->discard= AVDISCARD_ALL;
2876 break;
2877 case CODEC_TYPE_VIDEO:
2878 set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2879 frame_height = enc->height;
2880 frame_width = enc->width;
2881 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2882 frame_pix_fmt = enc->pix_fmt;
2883 rfps = ic->streams[i]->r_frame_rate.num;
2884 rfps_base = ic->streams[i]->r_frame_rate.den;
2885 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2886 if(me_threshold)
2887 enc->debug |= FF_DEBUG_MV;
2888
2889 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2890
2891 if (verbose >= 0)
2892 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2893 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2894
2895 (float)rfps / rfps_base, rfps, rfps_base);
2896 }
2897 /* update the current frame rate to match the stream frame rate */
2898 frame_rate.num = rfps;
2899 frame_rate.den = rfps_base;
2900
2901 enc->rate_emu = rate_emu;
2902 if(video_disable)
2903 ic->streams[i]->discard= AVDISCARD_ALL;
2904 else if(video_discard)
2905 ic->streams[i]->discard= video_discard;
2906 break;
2907 case CODEC_TYPE_DATA:
2908 break;
2909 case CODEC_TYPE_SUBTITLE:
2910 if(subtitle_disable)
2911 ic->streams[i]->discard = AVDISCARD_ALL;
2912 break;
2913 case CODEC_TYPE_ATTACHMENT:
2914 case CODEC_TYPE_UNKNOWN:
2915 break;
2916 default:
2917 abort();
2918 }
2919 }
2920
2921 input_files[nb_input_files] = ic;
2922 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2923 /* dump the file content */
2924 if (verbose >= 0)
2925 dump_format(ic, nb_input_files, filename, 0);
2926
2927 nb_input_files++;
2928 file_iformat = NULL;
2929 file_oformat = NULL;
2930
2931 video_channel = 0;
2932
2933 rate_emu = 0;
2934 av_freep(&video_codec_name);
2935 av_freep(&audio_codec_name);
2936 av_freep(&subtitle_codec_name);
2937 }
2938
2939 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2940 int *has_subtitle_ptr)
2941 {
2942 int has_video, has_audio, has_subtitle, i, j;
2943 AVFormatContext *ic;
2944
2945 has_video = 0;
2946 has_audio = 0;
2947 has_subtitle = 0;
2948 for(j=0;j<nb_input_files;j++) {
2949 ic = input_files[j];
2950 for(i=0;i<ic->nb_streams;i++) {
2951 AVCodecContext *enc = ic->streams[i]->codec;
2952 switch(enc->codec_type) {
2953 case CODEC_TYPE_AUDIO:
2954 has_audio = 1;
2955 break;
2956 case CODEC_TYPE_VIDEO:
2957 has_video = 1;
2958 break;
2959 case CODEC_TYPE_SUBTITLE:
2960 has_subtitle = 1;
2961 break;
2962 case CODEC_TYPE_DATA:
2963 case CODEC_TYPE_ATTACHMENT:
2964 case CODEC_TYPE_UNKNOWN:
2965 break;
2966 default:
2967 abort();
2968 }
2969 }
2970 }
2971 *has_video_ptr = has_video;
2972 *has_audio_ptr = has_audio;
2973 *has_subtitle_ptr = has_subtitle;
2974 }
2975
2976 static void new_video_stream(AVFormatContext *oc)
2977 {
2978 AVStream *st;
2979 AVCodecContext *video_enc;
2980 int codec_id;
2981
2982 st = av_new_stream(oc, oc->nb_streams);
2983 if (!st) {
2984 fprintf(stderr, "Could not alloc stream\n");
2985 av_exit(1);
2986 }
2987 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2988 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2989 video_bitstream_filters= NULL;
2990
2991 if(thread_count>1)
2992 avcodec_thread_init(st->codec, thread_count);
2993
2994 video_enc = st->codec;
2995
2996 if(video_codec_tag)
2997 video_enc->codec_tag= video_codec_tag;
2998
2999 if( (video_global_header&1)
3000 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3001 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3002 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3003 }
3004 if(video_global_header&2){
3005 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3006 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3007 }
3008
3009 if (video_stream_copy) {
3010 st->stream_copy = 1;
3011 video_enc->codec_type = CODEC_TYPE_VIDEO;
3012 } else {
3013 const char *p;
3014 int i;
3015 AVCodec *codec;
3016 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3017
3018 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3019 if (video_codec_name)
3020 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3021
3022 video_enc->codec_id = codec_id;
3023 codec = avcodec_find_encoder(codec_id);
3024
3025 set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3026
3027 video_enc->time_base.den = fps.num;
3028 video_enc->time_base.num = fps.den;
3029 if(codec && codec->supported_framerates){
3030 const AVRational *p= codec->supported_framerates;
3031 const AVRational *best=NULL;
3032 AVRational best_error= (AVRational){INT_MAX, 1};
3033 for(; p->den!=0; p++){
3034 AVRational error= av_sub_q(fps, *p);
3035 if(error.num <0) error.num *= -1;
3036 if(av_cmp_q(error, best_error) < 0){
3037 best_error= error;
3038 best= p;
3039 }
3040 }
3041 video_enc->time_base.den= best->num;
3042 video_enc->time_base.num= best->den;
3043 }
3044
3045 video_enc->width = frame_width + frame_padright + frame_padleft;
3046 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3047 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3048 video_enc->pix_fmt = frame_pix_fmt;
3049
3050 if(codec && codec->pix_fmts){
3051 const enum PixelFormat *p= codec->pix_fmts;
3052 for(; *p!=-1; p++){
3053 if(*p == video_enc->pix_fmt)
3054 break;
3055 }
3056 if(*p == -1)
3057 video_enc->pix_fmt = codec->pix_fmts[0];
3058 }
3059
3060 if (intra_only)
3061 video_enc->gop_size = 0;
3062 if (video_qscale || same_quality) {
3063 video_enc->flags |= CODEC_FLAG_QSCALE;
3064 video_enc->global_quality=
3065 st->quality = FF_QP2LAMBDA * video_qscale;
3066 }
3067
3068 if(intra_matrix)
3069 video_enc->intra_matrix = intra_matrix;
3070 if(inter_matrix)
3071 video_enc->inter_matrix = inter_matrix;
3072
3073 video_enc->thread_count = thread_count;
3074 p= video_rc_override_string;
3075 for(i=0; p; i++){
3076 int start, end, q;
3077 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3078 if(e!=3){
3079 fprintf(stderr, "error parsing rc_override\n");
3080 av_exit(1);
3081 }
3082 video_enc->rc_override=
3083 av_realloc(video_enc->rc_override,
3084 sizeof(RcOverride)*(i+1));
3085 video_enc->rc_override[i].start_frame= start;
3086 video_enc->rc_override[i].end_frame = end;
3087 if(q>0){
3088 video_enc->rc_override[i].qscale= q;
3089 video_enc->rc_override[i].quality_factor= 1.0;
3090 }
3091 else{
3092 video_enc->rc_override[i].qscale= 0;
3093 video_enc->rc_override[i].quality_factor= -q/100.0;
3094 }
3095 p= strchr(p, '/');
3096 if(p) p++;
3097 }
3098 video_enc->rc_override_count=i;
3099 if (!video_enc->rc_initial_buffer_occupancy)
3100 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3101 video_enc->me_threshold= me_threshold;
3102 video_enc->intra_dc_precision= intra_dc_precision - 8;
3103
3104 if (do_psnr)
3105 video_enc->flags|= CODEC_FLAG_PSNR;
3106
3107 /* two pass mode */
3108 if (do_pass) {
3109 if (do_pass == 1) {
3110 video_enc->flags |= CODEC_FLAG_PASS1;
3111 } else {
3112 video_enc->flags |= CODEC_FLAG_PASS2;
3113 }
3114 }
3115 }
3116
3117 /* reset some key parameters */
3118 video_disable = 0;
3119 av_freep(&video_codec_name);
3120 video_stream_copy = 0;
3121 }
3122
3123 static void new_audio_stream(AVFormatContext *oc)
3124 {
3125 AVStream *st;
3126 AVCodecContext *audio_enc;
3127 int codec_id;
3128
3129 st = av_new_stream(oc, oc->nb_streams);
3130 if (!st) {
3131 fprintf(stderr, "Could not alloc stream\n");
3132 av_exit(1);
3133 }
3134 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3135
3136 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3137 audio_bitstream_filters= NULL;
3138
3139 if(thread_count>1)
3140 avcodec_thread_init(st->codec, thread_count);
3141
3142 audio_enc = st->codec;
3143 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3144
3145 if(audio_codec_tag)
3146 audio_enc->codec_tag= audio_codec_tag;
3147
3148 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3149 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3150 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3151 }
3152 if (audio_stream_copy) {
3153 st->stream_copy = 1;
3154 audio_enc->channels = audio_channels;
3155 } else {
3156 AVCodec *codec;
3157 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3158
3159 set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3160
3161 if (audio_codec_name)
3162 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3163 audio_enc->codec_id = codec_id;
3164 codec = avcodec_find_encoder(codec_id);
3165
3166 if (audio_qscale > QSCALE_NONE) {
3167 audio_enc->flags |= CODEC_FLAG_QSCALE;
3168 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3169 }
3170 audio_enc->thread_count = thread_count;
3171 audio_enc->channels = audio_channels;
3172 audio_enc->sample_fmt = audio_sample_fmt;
3173
3174 if(codec && codec->sample_fmts){
3175 const enum SampleFormat *p= codec->sample_fmts;
3176 for(; *p!=-1; p++){
3177 if(*p == audio_enc->sample_fmt)
3178 break;
3179 }
3180 if(*p == -1)
3181 audio_enc->sample_fmt = codec->sample_fmts[0];
3182 }
3183 }
3184 audio_enc->sample_rate = audio_sample_rate;
3185 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3186 if (audio_language) {
3187 av_strlcpy(st->language, audio_language, sizeof(st->language));
3188 av_free(audio_language);
3189 audio_language = NULL;
3190 }
3191
3192 /* reset some key parameters */
3193 audio_disable = 0;
3194 av_freep(&audio_codec_name);
3195 audio_stream_copy = 0;
3196 }
3197
3198 static void new_subtitle_stream(AVFormatContext *oc)
3199 {
3200 AVStream *st;
3201 AVCodecContext *subtitle_enc;
3202
3203 st = av_new_stream(oc, oc->nb_streams);
3204 if (!st) {
3205 fprintf(stderr, "Could not alloc stream\n");
3206 av_exit(1);
3207 }
3208 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3209
3210 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3211 subtitle_bitstream_filters= NULL;
3212
3213 subtitle_enc = st->codec;
3214 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3215 if (subtitle_stream_copy) {
3216 st->stream_copy = 1;
3217 } else {
3218 set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3219 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3220 }
3221
3222 if (subtitle_language) {
3223 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3224 av_free(subtitle_language);
3225 subtitle_language = NULL;
3226 }
3227
3228 subtitle_disable = 0;
3229 av_freep(&subtitle_codec_name);
3230 subtitle_stream_copy = 0;
3231 }
3232
3233 static void opt_new_audio_stream(void)
3234 {
3235 AVFormatContext *oc;
3236 if (nb_output_files <= 0) {
3237 fprintf(stderr, "At least one output file must be specified\n");
3238 av_exit(1);
3239 }
3240 oc = output_files[nb_output_files - 1];
3241 new_audio_stream(oc);
3242 }
3243
3244 static void opt_new_video_stream(void)
3245 {
3246 AVFormatContext *oc;
3247 if (nb_output_files <= 0) {
3248 fprintf(stderr, "At least one output file must be specified\n");
3249 av_exit(1);
3250 }
3251 oc = output_files[nb_output_files - 1];
3252 new_video_stream(oc);
3253 }
3254
3255 static void opt_new_subtitle_stream(void)
3256 {
3257 AVFormatContext *oc;
3258 if (nb_output_files <= 0) {
3259 fprintf(stderr, "At least one output file must be specified\n");
3260 av_exit(1);
3261 }
3262 oc = output_files[nb_output_files - 1];
3263 new_subtitle_stream(oc);
3264 }
3265
3266 static void opt_output_file(const char *filename)
3267 {
3268 AVFormatContext *oc;
3269 int use_video, use_audio, use_subtitle;
3270 int input_has_video, input_has_audio, input_has_subtitle;
3271 AVFormatParameters params, *ap = &params;
3272
3273 if (!strcmp(filename, "-"))
3274 filename = "pipe:";
3275
3276 oc = av_alloc_format_context();
3277
3278 if (!file_oformat) {
3279 file_oformat = guess_format(NULL, filename, NULL);
3280 if (!file_oformat) {
3281 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3282 filename);
3283 av_exit(1);
3284 }
3285 }
3286
3287 oc->oformat = file_oformat;
3288 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3289
3290 if (!strcmp(file_oformat->name, "ffm") &&
3291 av_strstart(filename, "http:", NULL)) {
3292 /* special case for files sent to ffserver: we get the stream
3293 parameters from ffserver */
3294 int err = read_ffserver_streams(oc, filename);
3295 if (err < 0) {
3296 print_error(filename, err);
3297 av_exit(1);
3298 }
3299 } else {
3300 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3301 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3302 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3303
3304 /* disable if no corresponding type found and at least one
3305 input file */
3306 if (nb_input_files > 0) {
3307 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3308 &input_has_subtitle);
3309 if (!input_has_video)
3310 use_video = 0;
3311 if (!input_has_audio)
3312 use_audio = 0;
3313 if (!input_has_subtitle)
3314 use_subtitle = 0;
3315 }
3316
3317 /* manual disable */
3318 if (audio_disable) {
3319 use_audio = 0;
3320 }
3321 if (video_disable) {
3322 use_video = 0;
3323 }
3324 if (subtitle_disable) {
3325 use_subtitle = 0;
3326 }
3327
3328 if (use_video) {
3329 new_video_stream(oc);
3330 }
3331
3332 if (use_audio) {
3333 new_audio_stream(oc);
3334 }
3335
3336 if (use_subtitle) {
3337 new_subtitle_stream(oc);
3338 }
3339
3340 oc->timestamp = rec_timestamp;
3341
3342 if (str_title)
3343 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3344 if (str_author)
3345 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3346 if (str_copyright)
3347 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3348 if (str_comment)
3349 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3350 if (str_album)
3351 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3352 if (str_genre)
3353 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3354 }
3355
3356 output_files[nb_output_files++] = oc;
3357
3358 /* check filename in case of an image number is expected */
3359 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3360 if (!av_filename_number_test(oc->filename)) {
3361 print_error(oc->filename, AVERROR_NUMEXPECTED);
3362 av_exit(1);
3363 }
3364 }
3365
3366 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3367 /* test if it already exists to avoid loosing precious files */
3368 if (!file_overwrite &&
3369 (strchr(filename, ':') == NULL ||
3370 filename[1] == ':' ||
3371 av_strstart(filename, "file:", NULL))) {
3372 if (url_exist(filename)) {
3373 int c;
3374
3375 if (!using_stdin) {
3376 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3377 fflush(stderr);
3378 c = getchar();
3379 if (toupper(c) != 'Y') {
3380 fprintf(stderr, "Not overwriting - exiting\n");
3381 av_exit(1);
3382 }
3383 }
3384 else {
3385 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3386 av_exit(1);
3387 }
3388 }
3389 }
3390
3391 /* open the file */
3392 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3393 fprintf(stderr, "Could not open '%s'\n", filename);
3394 av_exit(1);
3395 }
3396 }
3397
3398 memset(ap, 0, sizeof(*ap));
3399 if (av_set_parameters(oc, ap) < 0) {
3400 fprintf(stderr, "%s: Invalid encoding parameters\n",
3401 oc->filename);
3402 av_exit(1);
3403 }
3404
3405 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3406 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3407 oc->loop_output = loop_output;
3408
3409 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3410
3411 /* reset some options */
3412 file_oformat = NULL;
3413 file_iformat = NULL;
3414 }
3415
3416 /* same option as mencoder */
3417 static void opt_pass(const char *pass_str)
3418 {
3419 int pass;
3420 pass = atoi(pass_str);
3421 if (pass != 1 && pass != 2) {
3422 fprintf(stderr, "pass number can be only 1 or 2\n");
3423 av_exit(1);
3424 }
3425 do_pass = pass;
3426 }
3427
3428 static int64_t getutime(void)
3429 {
3430 #ifdef HAVE_GETRUSAGE
3431 struct rusage rusage;
3432
3433 getrusage(RUSAGE_SELF, &rusage);
3434 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3435 #elif defined(HAVE_GETPROCESSTIMES)
3436 HANDLE proc;
3437 FILETIME c, e, k, u;
3438 proc = GetCurrentProcess();
3439 GetProcessTimes(proc, &c, &e, &k, &u);
3440 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3441 #else
3442 return av_gettime();
3443 #endif
3444 }
3445
3446 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3447 {
3448 int i;
3449 const char *p = str;
3450 for(i = 0;; i++) {
3451 dest[i] = atoi(p);
3452 if(i == 63)
3453 break;
3454 p = strchr(p, ',');
3455 if(!p) {
3456 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3457 av_exit(1);
3458 }
3459 p++;
3460 }
3461 }
3462
3463 static void opt_inter_matrix(const char *arg)
3464 {
3465 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3466 parse_matrix_coeffs(inter_matrix, arg);
3467 }
3468
3469 static void opt_intra_matrix(const char *arg)
3470 {
3471 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3472 parse_matrix_coeffs(intra_matrix, arg);
3473 }
3474
3475 /**
3476 * Trivial log callback.
3477 * Only suitable for show_help and similar since it lacks prefix handling.
3478 */
3479 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3480 {
3481 vfprintf(stdout, fmt, vl);
3482 }
3483
3484 static void show_help(void)
3485 {
3486 av_log_set_callback(log_callback_help);
3487 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3488 "Hyper fast Audio and Video encoder\n");
3489 printf("\n");
3490 show_help_options(options, "Main options:\n",
3491 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3492 show_help_options(options, "\nAdvanced options:\n",
3493 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3494 OPT_EXPERT);
3495 show_help_options(options, "\nVideo options:\n",
3496 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3497 OPT_VIDEO);
3498 show_help_options(options, "\nAdvanced Video options:\n",
3499 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3500 OPT_VIDEO | OPT_EXPERT);
3501 show_help_options(options, "\nAudio options:\n",
3502 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3503 OPT_AUDIO);
3504 show_help_options(options, "\nAdvanced Audio options:\n",
3505 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3506 OPT_AUDIO | OPT_EXPERT);
3507 show_help_options(options, "\nSubtitle options:\n",
3508 OPT_SUBTITLE | OPT_GRAB,
3509 OPT_SUBTITLE);
3510 show_help_options(options, "\nAudio/Video grab options:\n",
3511 OPT_GRAB,
3512 OPT_GRAB);
3513 printf("\n");
3514 av_opt_show(avctx_opts[0], NULL);
3515 printf("\n");
3516 av_opt_show(avformat_opts, NULL);
3517 printf("\n");
3518 av_opt_show(sws_opts, NULL);
3519 }
3520
3521 static void opt_target(const char *arg)
3522 {
3523 int norm = -1;
3524 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3525
3526 if(!strncmp(arg, "pal-", 4)) {
3527 norm = 0;
3528 arg += 4;
3529 } else if(!strncmp(arg, "ntsc-", 5)) {
3530 norm = 1;
3531 arg += 5;
3532 } else if(!strncmp(arg, "film-", 5)) {
3533 norm = 2;
3534 arg += 5;
3535 } else {
3536 int fr;
3537 /* Calculate FR via float to avoid int overflow */
3538 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3539 if(fr == 25000) {
3540 norm = 0;
3541 } else if((fr == 29970) || (fr == 23976)) {
3542 norm = 1;
3543 } else {
3544 /* Try to determine PAL/NTSC by peeking in the input files */
3545 if(nb_input_files) {
3546 int i, j;
3547 for(j = 0; j < nb_input_files; j++) {
3548 for(i = 0; i < input_files[j]->nb_streams; i++) {
3549 AVCodecContext *c = input_files[j]->streams[i]->codec;
3550 if(c->codec_type != CODEC_TYPE_VIDEO)
3551 continue;
3552 fr = c->time_base.den * 1000 / c->time_base.num;
3553 if(fr == 25000) {
3554 norm = 0;
3555 break;
3556 } else if((fr == 29970) || (fr == 23976)) {
3557 norm = 1;
3558 break;
3559 }
3560 }
3561 if(norm >= 0)
3562 break;
3563 }
3564 }
3565 }
3566 if(verbose && norm >= 0)
3567 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3568 }
3569
3570 if(norm < 0) {
3571 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3572 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3573 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3574 av_exit(1);
3575 }
3576
3577 if(!strcmp(arg, "vcd")) {
3578
3579 opt_video_codec("mpeg1video");
3580 opt_audio_codec("mp2");
3581 opt_format("vcd");
3582
3583 opt_frame_size(norm ? "352x240" : "352x288");
3584 opt_frame_rate(frame_rates[norm]);
3585 opt_default("gop", norm ? "18" : "15");
3586
3587 opt_default("b", "1150000");
3588 opt_default("maxrate", "1150000");
3589 opt_default("minrate", "1150000");
3590 opt_default("bufsize", "327680"); // 40*1024*8;
3591
3592 opt_default("ab", "224000");
3593 audio_sample_rate = 44100;
3594 audio_channels = 2;
3595
3596 opt_default("packetsize", "2324");
3597 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3598
3599 /* We have to offset the PTS, so that it is consistent with the SCR.
3600 SCR starts at 36000, but the first two packs contain only padding
3601 and the first pack from the other stream, respectively, may also have
3602 been written before.
3603 So the real data starts at SCR 36000+3*1200. */
3604 mux_preload= (36000+3*1200) / 90000.0; //0.44
3605 } else if(!strcmp(arg, "svcd")) {
3606
3607 opt_video_codec("mpeg2video");
3608 opt_audio_codec("mp2");
3609 opt_format("svcd");
3610
3611 opt_frame_size(norm ? "480x480" : "480x576");
3612 opt_frame_rate(frame_rates[norm]);
3613 opt_default("gop", norm ? "18" : "15");
3614
3615 opt_default("b", "2040000");
3616 opt_default("maxrate", "2516000");
3617 opt_default("minrate", "0"); //1145000;
3618 opt_default("bufsize", "1835008"); //224*1024*8;
3619 opt_default("flags", "+SCAN_OFFSET");
3620
3621
3622 opt_default("ab", "224000");
3623 audio_sample_rate = 44100;
3624
3625 opt_default("packetsize", "2324");
3626
3627 } else if(!strcmp(arg, "dvd")) {
3628
3629 opt_video_codec("mpeg2video");
3630 opt_audio_codec("ac3");
3631 opt_format("dvd");
3632
3633 opt_frame_size(norm ? "720x480" : "720x576");
3634 opt_frame_rate(frame_rates[norm]);
3635 opt_default("gop", norm ? "18" : "15");
3636
3637 opt_default("b", "6000000");
3638 opt_default("maxrate", "9000000");
3639 opt_default("minrate", "0"); //1500000;
3640 opt_default("bufsize", "1835008"); //224*1024*8;
3641
3642 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3643 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3644
3645 opt_default("ab", "448000");
3646 audio_sample_rate = 48000;
3647
3648 } else if(!strncmp(arg, "dv", 2)) {
3649
3650 opt_format("dv");
3651
3652 opt_frame_size(norm ? "720x480" : "720x576");
3653 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3654 (norm ? "yuv411p" : "yuv420p"));
3655 opt_frame_rate(frame_rates[norm]);
3656
3657 audio_sample_rate = 48000;
3658 audio_channels = 2;
3659
3660 } else {
3661 fprintf(stderr, "Unknown target: %s\n", arg);
3662 av_exit(1);
3663 }
3664 }
3665
3666 static void opt_vstats_file (const char *arg)
3667 {
3668 av_free (vstats_filename);
3669 vstats_filename=av_strdup (arg);
3670 }
3671
3672 static void opt_vstats (void)
3673 {
3674 char filename[40];
3675 time_t today2 = time(NULL);
3676 struct tm *today = localtime(&today2);
3677
3678 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3679 today->tm_sec);
3680 opt_vstats_file(filename);
3681 }
3682
3683 static int opt_bsf(const char *opt, const char *arg)
3684 {
3685 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3686 AVBitStreamFilterContext **bsfp;
3687
3688 if(!bsfc){
3689 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3690 av_exit(1);
3691 }
3692
3693 bsfp= *opt == 'v' ? &video_bitstream_filters :
3694 *opt == 'a' ? &audio_bitstream_filters :
3695 &subtitle_bitstream_filters;
3696 while(*bsfp)
3697 bsfp= &(*bsfp)->next;
3698
3699 *bsfp= bsfc;
3700
3701 return 0;
3702 }
3703
3704 static int opt_preset(const char *opt, const char *arg)
3705 {
3706 FILE *f=NULL;
3707 char tmp[1000], tmp2[1000];
3708 int i;
3709 const char *base[3]= { getenv("HOME"),
3710 "/usr/local/share",
3711 "/usr/share",
3712 };
3713
3714 for(i=!base[0]; i<3 && !f; i++){
3715 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3716 f= fopen(tmp, "r");
3717 if(!f){
3718 char *codec_name= *opt == 'v' ? video_codec_name :
3719 *opt == 'a' ? audio_codec_name :
3720 subtitle_codec_name;
3721 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg);
3722 f= fopen(tmp, "r");
3723 }
3724 }
3725
3726 if(!f){
3727 fprintf(stderr, "Preset file not found\n");
3728 av_exit(1);
3729 }
3730
3731 while(!feof(f)){
3732 int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3733 if(e!=2){
3734 fprintf(stderr, "Preset file invalid\n");
3735 av_exit(1);
3736 }
3737 if(!strcmp(tmp, "acodec")){
3738 opt_audio_codec(tmp2);
3739 }else if(!strcmp(tmp, "vcodec")){
3740 opt_video_codec(tmp2);
3741 }else if(!strcmp(tmp, "scodec")){
3742 opt_subtitle_codec(tmp2);
3743 }else
3744 opt_default(tmp, tmp2);
3745 }
3746
3747 fclose(f);
3748
3749 return 0;
3750 }
3751
3752 static const OptionDef options[] = {
3753 /* main options */
3754 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3755 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3756 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3757 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3758 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3759 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3760 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3761 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3762 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3763 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3764 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3765 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3766 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3767 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3768 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3769 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3770 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3771 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3772 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3773 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3774 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3775 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3776 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3777 "add timings for benchmarking" },
3778 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3779 "dump each input packet" },
3780 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3781 "when dumping packets, also dump the payload" },
3782 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3783 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3784 { "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)", "" },
3785 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3786 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3787 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3788 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3789 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3790 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3791 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3792 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3793 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3794 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3795 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3796
3797 /* video options */
3798 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3799 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3800 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3801 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3802 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3803 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3804 { "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" },
3805 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3806 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3807 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3808 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3809 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3810 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3811 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3812 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3813 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3814 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3815 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3816 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3817 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3818 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3819 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3820 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3821 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3822 "use same video quality as source (implies VBR)" },
3823 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3824 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3825 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3826 "deinterlace pictures" },
3827 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3828 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3829 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3830 #ifdef CONFIG_VHOOK
3831 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3832 #endif
3833 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3834 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3835 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3836 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3837 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3838 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3839 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3840
3841 /* audio options */
3842 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3843 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3844 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3845 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3846 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3847 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3848 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3849 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3850 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3851 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3852 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3853 { "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" },
3854
3855 /* subtitle options */
3856 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3857 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3858 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3859 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3860
3861 /* grab options */
3862 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3863 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3864 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3865
3866 /* muxer options */
3867 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3868 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3869
3870 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3871 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3872 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3873
3874 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3875 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3876 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3877
3878 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3879 { NULL, },
3880 };
3881
3882 int main(int argc, char **argv)
3883 {
3884 int i;
3885 int64_t ti;
3886
3887 avcodec_register_all();
3888 avdevice_register_all();
3889 av_register_all();
3890
3891 if(isatty(STDIN_FILENO))
3892 url_set_interrupt_cb(decode_interrupt_cb);
3893
3894 for(i=0; i<CODEC_TYPE_NB; i++){
3895 avctx_opts[i]= avcodec_alloc_context2(i);
3896 }
3897 avformat_opts = av_alloc_format_context();
3898 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3899
3900 show_banner();
3901 if (argc <= 1) {
3902 show_help();
3903 av_exit(1);
3904 }
3905
3906 /* parse options */
3907 parse_options(argc, argv, options, opt_output_file);
3908
3909 /* file converter / grab */
3910 if (nb_output_files <= 0) {
3911 fprintf(stderr, "Must supply at least one output file\n");
3912 av_exit(1);
3913 }
3914
3915 if (nb_input_files == 0) {
3916 fprintf(stderr, "Must supply at least one input file\n");
3917 av_exit(1);
3918 }
3919
3920 ti = getutime();
3921 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3922 stream_maps, nb_stream_maps);
3923 ti = getutime() - ti;
3924 if (do_benchmark) {
3925 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3926 }
3927
3928 return av_exit(0);
3929 }
lucabe's unfinished and experimental patches for ffmpeg