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