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