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