2001-07-22 16:37:44 +02:00
/*
2003-06-07 20:34:02 +02:00
* Copyright ( c ) 2000 - 2003 Fabrice Bellard
2001-07-22 16:37:44 +02:00
*
2006-10-07 17:30:46 +02:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2002-05-26 00:25:13 +02:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 17:30:46 +02:00
* version 2.1 of the License , or ( at your option ) any later version .
2001-07-22 16:37:44 +02:00
*
2006-10-07 17:30:46 +02:00
* FFmpeg is distributed in the hope that it will be useful ,
2001-07-22 16:37:44 +02:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
2002-05-26 00:25:13 +02:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
2001-07-22 16:37:44 +02:00
*
2002-05-26 00:25:13 +02:00
* You should have received a copy of the GNU Lesser General Public
2006-10-07 17:30:46 +02:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-12 23:43:26 +01:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2001-07-22 16:37:44 +02:00
*/
2007-06-10 16:34:56 +02:00
2011-12-22 10:23:22 +01:00
/**
* @ file
* multimedia converter based on the FFmpeg libraries
*/
2007-07-02 09:43:23 +02:00
# include "config.h"
# include <ctype.h>
# include <string.h>
# include <math.h>
# include <stdlib.h>
# include <errno.h>
2006-11-22 13:15:58 +01:00
# include <signal.h>
2004-05-12 18:51:39 +02:00
# include <limits.h>
2012-06-22 22:34:02 +02:00
# if HAVE_ISATTY
2008-08-15 00:01:59 +02:00
# include <unistd.h>
2012-06-22 22:34:02 +02:00
# endif
2008-05-09 13:56:36 +02:00
# include "libavformat/avformat.h"
# include "libavdevice/avdevice.h"
# include "libswscale/swscale.h"
2012-05-19 12:05:02 +02:00
# include "libswresample/swresample.h"
2011-02-03 14:58:59 +01:00
# include "libavutil/opt.h"
2011-02-07 14:37:08 +01:00
# include "libavutil/audioconvert.h"
# include "libavutil/parseutils.h"
# include "libavutil/samplefmt.h"
2010-07-01 20:49:44 +02:00
# include "libavutil/colorspace.h"
2008-05-09 13:56:36 +02:00
# include "libavutil/fifo.h"
2010-10-31 23:48:44 +01:00
# include "libavutil/intreadwrite.h"
2011-05-22 12:46:29 +02:00
# include "libavutil/dict.h"
2011-06-04 13:58:23 +02:00
# include "libavutil/mathematics.h"
2010-01-30 20:10:26 +01:00
# include "libavutil/pixdesc.h"
2008-05-09 13:56:36 +02:00
# include "libavutil/avstring.h"
2010-03-09 16:10:23 +01:00
# include "libavutil/libm.h"
2011-12-26 03:35:54 +01:00
# include "libavutil/imgutils.h"
2012-01-20 17:06:26 +01:00
# include "libavutil/timestamp.h"
2012-05-17 19:31:35 +02:00
# include "libavutil/bprint.h"
2012-06-21 21:31:44 +02:00
# include "libavutil/time.h"
2008-05-09 13:56:36 +02:00
# include "libavformat/os_support.h"
2001-08-16 00:29:44 +02:00
2011-04-09 03:09:49 +02:00
# include "libavformat/ffm.h" // not public API
2011-05-01 14:47:05 +02:00
# include "libavfilter / avcodec.h"
2010-05-07 11:43:21 +02:00
# include "libavfilter / avfilter.h"
# include "libavfilter / avfiltergraph.h"
2011-12-26 03:35:54 +01:00
# include "libavfilter / buffersrc.h"
2012-05-19 12:05:02 +02:00
# include "libavfilter / buffersink.h"
2010-05-07 11:43:21 +02:00
2009-01-14 00:44:16 +01:00
# if HAVE_SYS_RESOURCE_H
2008-05-11 13:17:23 +02:00
# include <sys/types.h>
2008-05-08 02:44:42 +02:00
# include <sys/resource.h>
2009-01-14 00:44:16 +01:00
# elif HAVE_GETPROCESSTIMES
2007-07-13 18:11:36 +02:00
# include <windows.h>
# endif
2010-02-22 23:21:58 +01:00
# if HAVE_GETPROCESSMEMORYINFO
# include <windows.h>
# include <psapi.h>
# endif
2007-07-13 18:11:36 +02:00
2009-01-14 00:44:16 +01:00
# if HAVE_SYS_SELECT_H
2008-09-26 04:13:38 +02:00
# include <sys/select.h>
# endif
2011-03-30 20:58:13 +02:00
# if HAVE_TERMIOS_H
# include <fcntl.h>
# include <sys/ioctl.h>
# include <sys/time.h>
# include <termios.h>
# elif HAVE_KBHIT
2007-07-11 16:07:55 +02:00
# include <conio.h>
2001-08-13 23:43:02 +02:00
# endif
2012-06-10 21:34:15 +02:00
2012-06-02 07:26:41 +02:00
# if HAVE_PTHREADS
# include <pthread.h>
# endif
2002-05-26 00:25:13 +02:00
# include <time.h>
2001-07-22 16:37:44 +02:00
2003-06-07 20:34:02 +02:00
# include "cmdutils.h"
2010-10-01 15:55:13 +02:00
# include "libavutil/avassert.h"
2004-09-22 19:50:53 +02:00
2012-01-05 02:03:12 +01:00
# define VSYNC_AUTO -1
# define VSYNC_PASSTHROUGH 0
# define VSYNC_CFR 1
# define VSYNC_VFR 2
2012-01-28 19:56:13 +01:00
# define VSYNC_DROP 0xff
2012-01-05 02:03:12 +01:00
2011-04-23 15:19:17 +02:00
const char program_name [ ] = " ffmpeg " ;
2008-05-29 10:48:51 +02:00
const int program_birth_year = 2000 ;
2007-09-27 08:38:40 +02:00
2001-07-22 16:37:44 +02:00
/* select an input stream for an output stream */
2011-06-23 19:14:08 +02:00
typedef struct StreamMap {
2011-08-30 04:06:24 +02:00
int disabled ; /** 1 is this mapping is disabled by a negative map */
2001-07-22 16:37:44 +02:00
int file_index ;
int stream_index ;
2005-05-26 10:59:05 +02:00
int sync_file_index ;
int sync_stream_index ;
2012-04-01 15:08:33 +02:00
char * linklabel ; /** name of an output link, for mapping lavfi outputs */
2011-06-23 19:14:08 +02:00
} StreamMap ;
2001-07-22 16:37:44 +02:00
2011-11-04 18:54:01 +01:00
typedef struct {
int file_idx , stream_idx , channel_idx ; // input
int ofile_idx , ostream_idx ; // output
} AudioChannelMap ;
2008-05-01 17:12:00 +02:00
static const OptionDef options [ ] ;
2001-07-22 16:37:44 +02:00
2010-10-01 23:56:09 +02:00
# define MAX_STREAMS 1024 /* arbitrary sanity check value */
2010-11-12 07:56:19 +01:00
2011-04-03 02:14:00 +02:00
static int frame_bits_per_raw_sample = 0 ;
2005-03-17 02:25:01 +01:00
static int video_discard = 0 ;
2011-08-30 01:46:34 +02:00
static int same_quant = 0 ;
2001-08-11 20:58:18 +02:00
static int do_deinterlace = 0 ;
2004-06-05 23:08:45 +02:00
static int intra_dc_precision = 8 ;
2005-12-18 21:01:02 +01:00
static int qp_hist = 0 ;
2001-07-22 16:37:44 +02:00
static int intra_only = 0 ;
2011-09-12 12:02:41 +02:00
static const char * video_codec_name = NULL ;
static const char * audio_codec_name = NULL ;
static const char * subtitle_codec_name = NULL ;
2001-07-22 16:37:44 +02:00
static int file_overwrite = 0 ;
2011-11-24 21:42:42 +01:00
static int no_file_overwrite = 0 ;
2001-07-31 01:19:22 +02:00
static int do_benchmark = 0 ;
2012-04-11 19:26:09 +02:00
static int do_benchmark_all = 0 ;
2001-09-23 19:14:51 +02:00
static int do_hex_dump = 0 ;
2003-11-10 19:54:17 +01:00
static int do_pkt_dump = 0 ;
2011-11-09 18:58:07 +01:00
static int do_psnr = 0 ;
2002-10-10 19:09:01 +02:00
static int do_pass = 0 ;
2011-04-21 00:46:20 +02:00
static const char * pass_logfilename_prefix ;
2012-01-05 02:03:12 +01:00
static int video_sync_method = VSYNC_AUTO ;
2011-12-30 03:46:24 +01:00
static int audio_sync_method = 0 ;
static float audio_drift_threshold = 0.1 ;
static int copy_ts = 0 ;
static int copy_tb = - 1 ;
2008-12-14 16:02:27 +01:00
static int opt_shortest = 0 ;
2007-04-25 15:55:11 +02:00
static char * vstats_filename ;
2007-09-06 22:11:02 +02:00
static FILE * vstats_file ;
2002-10-10 19:09:01 +02:00
2005-03-23 03:10:23 +01:00
static int audio_volume = 256 ;
2003-01-22 23:40:52 +01:00
2008-09-05 01:23:44 +02:00
static int exit_on_error = 0 ;
2012-07-14 17:52:51 +02:00
static int stdin_interaction = 1 ;
2011-04-22 18:49:44 +02:00
static int run_as_daemon = 0 ;
2011-10-08 17:21:25 +02:00
static volatile int received_nb_signals = 0 ;
2004-04-15 15:57:55 +02:00
static int64_t video_size = 0 ;
static int64_t audio_size = 0 ;
2012-06-17 19:50:36 +02:00
static int64_t subtitle_size = 0 ;
2004-04-15 15:57:55 +02:00
static int64_t extra_size = 0 ;
2004-06-12 00:03:16 +02:00
static int nb_frames_dup = 0 ;
static int nb_frames_drop = 0 ;
2004-06-18 05:03:32 +02:00
static int input_sync ;
2003-08-29 22:51:10 +02:00
2007-08-07 02:26:37 +02:00
static float dts_delta_threshold = 10 ;
2012-02-07 23:43:10 +01:00
static float dts_error_threshold = 3600 * 30 ;
2004-11-11 19:09:28 +01:00
2011-10-10 03:41:49 +02:00
static int print_stats = 1 ;
2012-01-20 17:06:26 +01:00
static int debug_ts = 0 ;
2012-04-11 19:26:09 +02:00
static int current_time ;
2012-07-08 13:03:39 +02:00
static AVIOContext * progress_avio = NULL ;
2005-09-11 13:10:25 +02:00
2012-06-22 22:15:24 +02:00
static uint8_t * subtitle_out ;
2012-06-11 15:34:12 +02:00
# if HAVE_PTHREADS
2012-06-02 07:26:41 +02:00
/* signal to input threads that they should exit; set by the main thread */
static int transcoding_finished ;
# endif
2008-12-26 20:25:24 +01:00
# define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
2001-07-22 16:37:44 +02:00
2012-03-29 08:51:17 +02:00
typedef struct InputFilter {
AVFilterContext * filter ;
struct InputStream * ist ;
struct FilterGraph * graph ;
2012-05-26 13:31:54 +02:00
uint8_t * name ;
2012-03-29 08:51:17 +02:00
} InputFilter ;
typedef struct OutputFilter {
AVFilterContext * filter ;
struct OutputStream * ost ;
struct FilterGraph * graph ;
2012-05-26 13:31:54 +02:00
uint8_t * name ;
2012-04-01 15:08:33 +02:00
/* temporary storage until stream maps are processed */
AVFilterInOut * out_tmp ;
2012-03-29 08:51:17 +02:00
} OutputFilter ;
typedef struct FilterGraph {
2012-04-01 15:08:33 +02:00
int index ;
const char * graph_desc ;
2012-03-29 08:51:17 +02:00
AVFilterGraph * graph ;
InputFilter * * inputs ;
int nb_inputs ;
OutputFilter * * outputs ;
int nb_outputs ;
} FilterGraph ;
2011-08-30 15:44:47 +02:00
typedef struct InputStream {
int file_index ;
AVStream * st ;
int discard ; /* true if stream data should be discarded */
int decoding_needed ; /* true if the packets must be decoded in 'raw_fifo' */
AVCodec * dec ;
2011-12-06 01:37:27 +01:00
AVFrame * decoded_frame ;
2011-08-30 15:44:47 +02:00
int64_t start ; /* time when read started */
2012-02-08 06:13:44 +01:00
/* predicted dts of the next packet read for this stream or (when there are
2012-07-26 17:58:26 +02:00
* several frames in a packet ) of the next frame in current packet ( in AV_TIME_BASE units ) */
2012-02-08 06:13:44 +01:00
int64_t next_dts ;
2012-07-26 17:58:26 +02:00
int64_t dts ; ///< dts of the last packet read for this stream (in AV_TIME_BASE units)
2012-02-08 06:13:44 +01:00
2012-07-26 17:58:26 +02:00
int64_t next_pts ; ///< synthetic pts for the next decode frame (in AV_TIME_BASE units)
int64_t pts ; ///< current pts of the decoded frame (in AV_TIME_BASE units)
2011-08-30 15:44:47 +02:00
double ts_scale ;
int is_start ; /* is 1 at the start and after a discontinuity */
2012-04-24 18:44:51 +02:00
int saw_first_ts ;
2011-08-30 15:44:47 +02:00
int showed_multi_packet_warning ;
AVDictionary * opts ;
2012-05-26 16:52:58 +02:00
AVRational framerate ; /* framerate forced with -r */
2012-05-31 12:29:07 +02:00
int top_field_first ;
2011-12-26 03:35:54 +01:00
2012-03-29 07:40:26 +02:00
int resample_height ;
int resample_width ;
int resample_pix_fmt ;
2012-05-05 18:22:46 +02:00
int resample_sample_fmt ;
int resample_sample_rate ;
int resample_channels ;
uint64_t resample_channel_layout ;
2011-12-26 03:35:54 +01:00
/* a pool of free buffers for decoded data */
FrameBuffer * buffer_pool ;
2011-12-27 05:22:44 +01:00
int dr1 ;
2012-03-29 08:51:17 +02:00
/* decoded data from this stream goes into all those filters
2012-05-17 13:22:17 +02:00
* currently video and audio only */
2012-03-29 08:51:17 +02:00
InputFilter * * filters ;
int nb_filters ;
2011-08-30 15:44:47 +02:00
} InputStream ;
typedef struct InputFile {
AVFormatContext * ctx ;
int eof_reached ; /* true if eof reached */
2012-07-23 16:58:22 +02:00
int unavailable ; /* true if the file is unavailable (possibly temporarily) */
2011-10-11 14:24:20 +02:00
int ist_index ; /* index of first stream in input_streams */
2011-08-30 15:44:47 +02:00
int64_t ts_offset ;
2011-10-11 14:24:20 +02:00
int nb_streams ; /* number of stream that ffmpeg is aware of; may be different
2011-08-30 16:43:11 +02:00
from ctx . nb_streams if new streams appear during av_read_frame ( ) */
2012-07-25 17:46:00 +02:00
int nb_streams_warn ; /* number of streams that the user was warned of */
2011-09-05 22:10:26 +02:00
int rate_emu ;
2012-06-02 07:26:41 +02:00
2012-06-11 15:34:12 +02:00
# if HAVE_PTHREADS
2012-06-02 07:26:41 +02:00
pthread_t thread ; /* thread reading from this file */
int finished ; /* the thread has exited */
int joined ; /* the thread has been joined */
pthread_mutex_t fifo_lock ; /* lock for access to fifo */
pthread_cond_t fifo_cond ; /* the main thread will signal on this cond after reading from fifo */
AVFifoBuffer * fifo ; /* demuxed packets are stored here; freed by the main thread */
# endif
2011-08-30 15:44:47 +02:00
} InputFile ;
2005-05-26 10:59:05 +02:00
2011-06-23 19:14:08 +02:00
typedef struct OutputStream {
2001-07-22 16:37:44 +02:00
int file_index ; /* file index */
int index ; /* stream index in the output file */
2011-06-23 19:14:08 +02:00
int source_index ; /* InputStream index */
2001-07-22 16:37:44 +02:00
AVStream * st ; /* stream in the output file */
2002-10-21 19:42:47 +02:00
int encoding_needed ; /* true if encoding needed for this stream */
int frame_number ;
/* input pts and corresponding output pts
for A / V sync */
2011-06-23 19:14:08 +02:00
struct InputStream * sync_ist ; /* input stream to sync against */
2011-12-30 03:46:24 +01:00
int64_t sync_opts ; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
2012-05-20 10:28:41 +02:00
/* pts of the first frame encoded for this stream, used for limiting
* recording time */
int64_t first_pts ;
2010-10-16 12:06:13 +02:00
AVBitStreamFilterContext * bitstream_filters ;
2011-06-16 18:04:56 +02:00
AVCodec * enc ;
2011-09-05 22:10:26 +02:00
int64_t max_frames ;
2012-03-29 09:00:09 +02:00
AVFrame * filtered_frame ;
2011-06-16 18:04:56 +02:00
2001-07-22 16:37:44 +02:00
/* video only */
2011-06-15 08:00:03 +02:00
AVRational frame_rate ;
2011-09-11 23:35:35 +02:00
int force_fps ;
int top_field_first ;
2002-12-05 10:00:18 +01:00
2011-04-17 01:47:24 +02:00
float frame_aspect_ratio ;
2012-03-29 08:51:17 +02:00
float last_quality ;
2011-04-01 17:30:45 +02:00
2010-10-18 23:47:15 +02:00
/* forced key frames */
int64_t * forced_kf_pts ;
int forced_kf_count ;
int forced_kf_index ;
2012-06-22 14:36:27 +02:00
char * forced_keyframes ;
2010-10-18 23:47:15 +02:00
2012-05-17 19:31:35 +02:00
/* audio only */
int audio_channels_map [ SWR_CH_MAX ] ; /* list of the channels id to pick from the source stream */
int audio_channels_mapped ; /* number of channels in audio_channels_map */
2002-10-10 19:09:01 +02:00
FILE * logfile ;
2011-02-14 23:02:10 +01:00
2012-03-29 08:51:17 +02:00
OutputFilter * filter ;
2011-02-14 23:02:10 +01:00
char * avfilter ;
2011-05-10 04:01:29 +02:00
2011-11-07 02:41:01 +01:00
int64_t sws_flags ;
2012-04-11 13:46:31 +02:00
int64_t swr_dither_method ;
double swr_dither_scale ;
2011-11-07 02:41:01 +01:00
AVDictionary * opts ;
int is_past_recording_time ;
2012-07-23 16:58:22 +02:00
int unavailable ; /* true if the steram is unavailable (possibly temporarily) */
2011-11-07 02:41:01 +01:00
int stream_copy ;
const char * attachment_filename ;
int copy_initial_nonkeyframes ;
2012-03-23 15:46:30 +01:00
2012-04-27 10:55:12 +02:00
int keep_pix_fmt ;
2011-06-23 19:14:08 +02:00
} OutputStream ;
2001-07-22 16:37:44 +02:00
2011-03-30 20:58:13 +02:00
# if HAVE_TERMIOS_H
/* init terminal so that we can grab keys */
static struct termios oldtty ;
2012-01-17 00:10:17 +01:00
static int restore_tty ;
2011-03-30 20:58:13 +02:00
# endif
2011-08-30 14:19:39 +02:00
typedef struct OutputFile {
AVFormatContext * ctx ;
AVDictionary * opts ;
2011-08-30 15:03:53 +02:00
int ost_index ; /* index of the first stream in output_streams */
2012-07-26 17:58:26 +02:00
int64_t recording_time ; ///< desired length of the resulting file in microseconds == AV_TIME_BASE units
int64_t start_time ; ///< start time in microseconds == AV_TIME_BASE units
2012-01-18 13:13:41 +01:00
uint64_t limit_filesize ; /* filesize limit expressed in bytes */
2011-08-30 14:19:39 +02:00
} OutputFile ;
2012-04-15 15:28:30 +02:00
static InputStream * * input_streams = NULL ;
static int nb_input_streams = 0 ;
static InputFile * * input_files = NULL ;
static int nb_input_files = 0 ;
2011-05-22 22:12:35 +02:00
2012-04-15 15:28:30 +02:00
static OutputStream * * output_streams = NULL ;
static int nb_output_streams = 0 ;
static OutputFile * * output_files = NULL ;
static int nb_output_files = 0 ;
2011-08-17 09:56:08 +02:00
2012-03-29 08:51:17 +02:00
static FilterGraph * * filtergraphs ;
int nb_filtergraphs ;
2011-08-30 14:19:39 +02:00
2011-09-05 02:04:27 +02:00
typedef struct OptionsContext {
/* input/output options */
int64_t start_time ;
const char * format ;
2011-09-05 22:10:26 +02:00
SpecifierOpt * codec_names ;
int nb_codec_names ;
2011-09-10 20:52:48 +02:00
SpecifierOpt * audio_channels ;
int nb_audio_channels ;
2011-09-11 23:35:35 +02:00
SpecifierOpt * audio_sample_rate ;
int nb_audio_sample_rate ;
SpecifierOpt * frame_rates ;
int nb_frame_rates ;
SpecifierOpt * frame_sizes ;
int nb_frame_sizes ;
SpecifierOpt * frame_pix_fmts ;
int nb_frame_pix_fmts ;
2011-09-05 22:10:26 +02:00
2011-09-05 02:04:27 +02:00
/* input options */
int64_t input_ts_offset ;
2011-09-05 22:10:26 +02:00
int rate_emu ;
SpecifierOpt * ts_scale ;
int nb_ts_scale ;
2011-11-04 01:44:06 +01:00
SpecifierOpt * dump_attachment ;
int nb_dump_attachment ;
2011-09-05 02:04:27 +02:00
/* output options */
StreamMap * stream_maps ;
int nb_stream_maps ;
2012-05-19 12:05:02 +02:00
AudioChannelMap * audio_channel_maps ; /* one info entry per -map_channel */
int nb_audio_channel_maps ; /* number of (valid) -map_channel settings */
2011-09-05 22:10:26 +02:00
int metadata_global_manual ;
int metadata_streams_manual ;
int metadata_chapters_manual ;
2011-11-04 01:44:06 +01:00
const char * * attachments ;
int nb_attachments ;
2011-09-05 22:10:26 +02:00
int chapters_input_file ;
2011-09-05 02:04:27 +02:00
int64_t recording_time ;
uint64_t limit_filesize ;
2011-09-05 22:10:26 +02:00
float mux_preload ;
float mux_max_delay ;
2011-09-10 20:52:48 +02:00
int video_disable ;
int audio_disable ;
int subtitle_disable ;
int data_disable ;
2011-09-11 23:35:35 +02:00
/* indexed by output file stream index */
int * streamid_map ;
int nb_streamid_map ;
2011-09-05 22:10:26 +02:00
SpecifierOpt * metadata ;
int nb_metadata ;
SpecifierOpt * max_frames ;
int nb_max_frames ;
SpecifierOpt * bitstream_filters ;
int nb_bitstream_filters ;
2011-09-10 20:52:48 +02:00
SpecifierOpt * codec_tags ;
int nb_codec_tags ;
2011-09-11 23:35:35 +02:00
SpecifierOpt * sample_fmts ;
int nb_sample_fmts ;
SpecifierOpt * qscale ;
int nb_qscale ;
SpecifierOpt * forced_key_frames ;
int nb_forced_key_frames ;
SpecifierOpt * force_fps ;
int nb_force_fps ;
SpecifierOpt * frame_aspect_ratios ;
int nb_frame_aspect_ratios ;
SpecifierOpt * rc_overrides ;
int nb_rc_overrides ;
SpecifierOpt * intra_matrices ;
int nb_intra_matrices ;
SpecifierOpt * inter_matrices ;
int nb_inter_matrices ;
SpecifierOpt * top_field_first ;
int nb_top_field_first ;
2011-12-17 01:36:59 +01:00
SpecifierOpt * metadata_map ;
int nb_metadata_map ;
2011-10-18 01:33:09 +02:00
SpecifierOpt * presets ;
int nb_presets ;
2011-11-07 02:41:01 +01:00
SpecifierOpt * copy_initial_nonkeyframes ;
int nb_copy_initial_nonkeyframes ;
2011-09-11 23:35:35 +02:00
SpecifierOpt * filters ;
int nb_filters ;
2011-09-05 02:04:27 +02:00
} OptionsContext ;
2012-05-20 12:06:56 +02:00
static void do_video_stats ( AVFormatContext * os , OutputStream * ost , int frame_size ) ;
2011-09-05 22:10:26 +02:00
# define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
{ \
int i , ret ; \
for ( i = 0 ; i < o - > nb_ # # name ; i + + ) { \
char * spec = o - > name [ i ] . specifier ; \
if ( ( ret = check_stream_specifier ( fmtctx , st , spec ) ) > 0 ) \
outvar = o - > name [ i ] . u . type ; \
else if ( ret < 0 ) \
exit_program ( 1 ) ; \
} \
}
2012-04-11 19:26:29 +02:00
static int64_t getutime ( void )
{
# if HAVE_GETRUSAGE
struct rusage rusage ;
getrusage ( RUSAGE_SELF , & rusage ) ;
return ( rusage . ru_utime . tv_sec * 1000000LL ) + rusage . ru_utime . tv_usec ;
# elif HAVE_GETPROCESSTIMES
HANDLE proc ;
FILETIME c , e , k , u ;
proc = GetCurrentProcess ( ) ;
GetProcessTimes ( proc , & c , & e , & k , & u ) ;
return ( ( int64_t ) u . dwHighDateTime < < 32 | u . dwLowDateTime ) / 10 ;
# else
return av_gettime ( ) ;
# endif
}
2012-04-11 19:26:09 +02:00
static void update_benchmark ( const char * fmt , . . . )
{
if ( do_benchmark_all ) {
int64_t t = getutime ( ) ;
va_list va ;
char buf [ 1024 ] ;
if ( fmt ) {
va_start ( va , fmt ) ;
vsnprintf ( buf , sizeof ( buf ) , fmt , va ) ;
va_end ( va ) ;
printf ( " bench: %8 " PRIu64 " %s \n " , t - current_time , buf ) ;
}
current_time = t ;
}
}
2011-09-05 03:11:18 +02:00
static void reset_options ( OptionsContext * o , int is_input )
2011-09-05 02:04:27 +02:00
{
const OptionDef * po = options ;
2011-09-05 03:11:18 +02:00
OptionsContext bak = * o ;
2012-04-01 15:08:33 +02:00
int i ;
2011-09-05 02:04:27 +02:00
/* all OPT_SPEC and OPT_STRING can be freed in generic way */
while ( po - > name ) {
void * dst = ( uint8_t * ) o + po - > u . off ;
if ( po - > flags & OPT_SPEC ) {
SpecifierOpt * * so = dst ;
int i , * count = ( int * ) ( so + 1 ) ;
for ( i = 0 ; i < * count ; i + + ) {
av_freep ( & ( * so ) [ i ] . specifier ) ;
if ( po - > flags & OPT_STRING )
av_freep ( & ( * so ) [ i ] . u . str ) ;
}
av_freep ( so ) ;
* count = 0 ;
} else if ( po - > flags & OPT_OFFSET & & po - > flags & OPT_STRING )
av_freep ( dst ) ;
po + + ;
}
2012-04-01 15:08:33 +02:00
for ( i = 0 ; i < o - > nb_stream_maps ; i + + )
av_freep ( & o - > stream_maps [ i ] . linklabel ) ;
2011-09-05 02:04:27 +02:00
av_freep ( & o - > stream_maps ) ;
2011-11-04 18:54:01 +01:00
av_freep ( & o - > audio_channel_maps ) ;
2011-09-11 23:35:35 +02:00
av_freep ( & o - > streamid_map ) ;
2011-09-05 02:04:27 +02:00
memset ( o , 0 , sizeof ( * o ) ) ;
2012-06-28 20:26:13 +02:00
if ( is_input ) {
o - > recording_time = bak . recording_time ;
if ( o - > recording_time ! = INT64_MAX )
av_log ( NULL , AV_LOG_WARNING ,
" -t is not an input option, keeping it for the next output; "
" consider fixing your command line. \n " ) ;
} else
o - > recording_time = INT64_MAX ;
2011-09-05 22:10:26 +02:00
o - > mux_max_delay = 0.7 ;
o - > limit_filesize = UINT64_MAX ;
o - > chapters_input_file = INT_MAX ;
2011-09-05 02:04:27 +02:00
uninit_opts ( ) ;
init_opts ( ) ;
}
2012-04-17 03:15:19 +02:00
static enum PixelFormat choose_pixel_fmt ( AVStream * st , AVCodec * codec , enum PixelFormat target )
2010-05-07 11:43:21 +02:00
{
2012-04-17 04:01:17 +02:00
if ( codec & & codec - > pix_fmts ) {
const enum PixelFormat * p = codec - > pix_fmts ;
2012-04-17 03:15:19 +02:00
int has_alpha = av_pix_fmt_descriptors [ target ] . nb_components % 2 = = 0 ;
2012-04-17 04:01:17 +02:00
enum PixelFormat best = PIX_FMT_NONE ;
if ( st - > codec - > strict_std_compliance < = FF_COMPLIANCE_UNOFFICIAL ) {
if ( st - > codec - > codec_id = = CODEC_ID_MJPEG ) {
p = ( const enum PixelFormat [ ] ) { PIX_FMT_YUVJ420P , PIX_FMT_YUVJ422P , PIX_FMT_YUV420P , PIX_FMT_YUV422P , PIX_FMT_NONE } ;
} else if ( st - > codec - > codec_id = = CODEC_ID_LJPEG ) {
p = ( const enum PixelFormat [ ] ) { PIX_FMT_YUVJ420P , PIX_FMT_YUVJ422P , PIX_FMT_YUVJ444P , PIX_FMT_YUV420P ,
PIX_FMT_YUV422P , PIX_FMT_YUV444P , PIX_FMT_BGRA , PIX_FMT_NONE } ;
}
}
for ( ; * p ! = PIX_FMT_NONE ; p + + ) {
2012-04-17 03:15:19 +02:00
best = avcodec_find_best_pix_fmt2 ( best , * p , target , has_alpha , NULL ) ;
if ( * p = = target )
2012-04-17 04:01:17 +02:00
break ;
}
if ( * p = = PIX_FMT_NONE ) {
2012-04-17 03:15:19 +02:00
if ( target ! = PIX_FMT_NONE )
2012-04-17 04:01:17 +02:00
av_log ( NULL , AV_LOG_WARNING ,
" Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s' \n " ,
2012-04-17 03:15:19 +02:00
av_pix_fmt_descriptors [ target ] . name ,
2012-04-17 04:01:17 +02:00
codec - > name ,
av_pix_fmt_descriptors [ best ] . name ) ;
2012-04-17 03:15:19 +02:00
return best ;
2012-04-17 04:01:17 +02:00
}
}
2012-04-17 03:15:19 +02:00
return target ;
2012-04-17 04:01:17 +02:00
}
2012-05-05 18:22:46 +02:00
static char * choose_pix_fmts ( OutputStream * ost )
2012-03-23 15:46:30 +01:00
{
2012-05-05 18:22:46 +02:00
if ( ost - > keep_pix_fmt ) {
2012-04-27 10:55:12 +02:00
if ( ost - > filter )
avfilter_graph_set_auto_convert ( ost - > filter - > graph - > graph ,
AVFILTER_AUTO_CONVERT_NONE ) ;
if ( ost - > st - > codec - > pix_fmt = = PIX_FMT_NONE )
return NULL ;
2012-05-19 00:15:03 +02:00
return av_strdup ( av_get_pix_fmt_name ( ost - > st - > codec - > pix_fmt ) ) ;
2012-04-27 10:55:12 +02:00
}
2012-03-23 15:46:30 +01:00
if ( ost - > st - > codec - > pix_fmt ! = PIX_FMT_NONE ) {
2012-05-10 02:14:44 +02:00
return av_strdup ( av_get_pix_fmt_name ( choose_pixel_fmt ( ost - > st , ost - > enc , ost - > st - > codec - > pix_fmt ) ) ) ;
2012-05-04 15:40:34 +02:00
} else if ( ost - > enc & & ost - > enc - > pix_fmts ) {
2012-04-27 06:56:56 +02:00
const enum PixelFormat * p ;
AVIOContext * s = NULL ;
uint8_t * ret ;
int len ;
if ( avio_open_dyn_buf ( & s ) < 0 )
exit_program ( 1 ) ;
2012-05-10 02:14:44 +02:00
p = ost - > enc - > pix_fmts ;
2012-04-17 03:16:40 +02:00
if ( ost - > st - > codec - > strict_std_compliance < = FF_COMPLIANCE_UNOFFICIAL ) {
if ( ost - > st - > codec - > codec_id = = CODEC_ID_MJPEG ) {
2012-05-10 02:14:44 +02:00
p = ( const enum PixelFormat [ ] ) { PIX_FMT_YUVJ420P , PIX_FMT_YUVJ422P , PIX_FMT_YUV420P , PIX_FMT_YUV422P , PIX_FMT_NONE } ;
2012-04-17 03:16:40 +02:00
} else if ( ost - > st - > codec - > codec_id = = CODEC_ID_LJPEG ) {
2012-05-10 02:14:44 +02:00
p = ( const enum PixelFormat [ ] ) { PIX_FMT_YUVJ420P , PIX_FMT_YUVJ422P , PIX_FMT_YUVJ444P , PIX_FMT_YUV420P ,
2012-04-17 03:16:40 +02:00
PIX_FMT_YUV422P , PIX_FMT_YUV444P , PIX_FMT_BGRA , PIX_FMT_NONE } ;
}
}
2012-05-10 02:14:44 +02:00
2012-05-05 18:22:46 +02:00
for ( ; * p ! = PIX_FMT_NONE ; p + + ) {
const char * name = av_get_pix_fmt_name ( * p ) ;
avio_printf ( s , " %s: " , name ) ;
}
2012-04-27 06:56:56 +02:00
len = avio_close_dyn_buf ( s , & ret ) ;
ret [ len - 1 ] = 0 ;
return ret ;
2012-04-17 03:16:40 +02:00
} else
2012-03-23 15:46:30 +01:00
return NULL ;
}
2012-05-05 18:22:46 +02:00
/**
* Define a function for building a string containing a list of
* allowed formats ,
*/
# define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name, separator) \
static char * choose_ # # var # # s ( OutputStream * ost ) \
{ \
if ( ost - > st - > codec - > var ! = none ) { \
get_name ( ost - > st - > codec - > var ) ; \
return av_strdup ( name ) ; \
} else if ( ost - > enc - > supported_list ) { \
const type * p ; \
AVIOContext * s = NULL ; \
uint8_t * ret ; \
int len ; \
\
if ( avio_open_dyn_buf ( & s ) < 0 ) \
exit_program ( 1 ) ; \
\
for ( p = ost - > enc - > supported_list ; * p ! = none ; p + + ) { \
get_name ( * p ) ; \
avio_printf ( s , " %s " separator , name ) ; \
} \
len = avio_close_dyn_buf ( s , & ret ) ; \
ret [ len - 1 ] = 0 ; \
return ret ; \
} else \
return NULL ; \
}
# define GET_PIX_FMT_NAME(pix_fmt)\
const char * name = av_get_pix_fmt_name ( pix_fmt ) ;
// DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE,
// GET_PIX_FMT_NAME, ":")
# define GET_SAMPLE_FMT_NAME(sample_fmt)\
const char * name = av_get_sample_fmt_name ( sample_fmt )
DEF_CHOOSE_FORMAT ( enum AVSampleFormat , sample_fmt , sample_fmts ,
AV_SAMPLE_FMT_NONE , GET_SAMPLE_FMT_NAME , " , " )
# define GET_SAMPLE_RATE_NAME(rate)\
char name [ 16 ] ; \
snprintf ( name , sizeof ( name ) , " %d " , rate ) ;
DEF_CHOOSE_FORMAT ( int , sample_rate , supported_samplerates , 0 ,
GET_SAMPLE_RATE_NAME , " , " )
# define GET_CH_LAYOUT_NAME(ch_layout)\
char name [ 16 ] ; \
snprintf ( name , sizeof ( name ) , " 0x% " PRIx64 , ch_layout ) ;
DEF_CHOOSE_FORMAT ( uint64_t , channel_layout , channel_layouts , 0 ,
GET_CH_LAYOUT_NAME , " , " )
2012-03-29 08:51:17 +02:00
static FilterGraph * init_simple_filtergraph ( InputStream * ist , OutputStream * ost )
{
FilterGraph * fg = av_mallocz ( sizeof ( * fg ) ) ;
if ( ! fg )
exit_program ( 1 ) ;
2012-04-01 15:08:33 +02:00
fg - > index = nb_filtergraphs ;
2012-03-29 08:51:17 +02:00
fg - > outputs = grow_array ( fg - > outputs , sizeof ( * fg - > outputs ) , & fg - > nb_outputs ,
fg - > nb_outputs + 1 ) ;
if ( ! ( fg - > outputs [ 0 ] = av_mallocz ( sizeof ( * fg - > outputs [ 0 ] ) ) ) )
exit_program ( 1 ) ;
fg - > outputs [ 0 ] - > ost = ost ;
fg - > outputs [ 0 ] - > graph = fg ;
2012-05-26 12:47:47 +02:00
ost - > filter = fg - > outputs [ 0 ] ;
2012-03-29 08:51:17 +02:00
fg - > inputs = grow_array ( fg - > inputs , sizeof ( * fg - > inputs ) , & fg - > nb_inputs ,
fg - > nb_inputs + 1 ) ;
if ( ! ( fg - > inputs [ 0 ] = av_mallocz ( sizeof ( * fg - > inputs [ 0 ] ) ) ) )
exit_program ( 1 ) ;
fg - > inputs [ 0 ] - > ist = ist ;
fg - > inputs [ 0 ] - > graph = fg ;
ist - > filters = grow_array ( ist - > filters , sizeof ( * ist - > filters ) ,
& ist - > nb_filters , ist - > nb_filters + 1 ) ;
ist - > filters [ ist - > nb_filters - 1 ] = fg - > inputs [ 0 ] ;
filtergraphs = grow_array ( filtergraphs , sizeof ( * filtergraphs ) ,
& nb_filtergraphs , nb_filtergraphs + 1 ) ;
filtergraphs [ nb_filtergraphs - 1 ] = fg ;
return fg ;
}
2012-04-01 15:08:33 +02:00
static void init_input_filter ( FilterGraph * fg , AVFilterInOut * in )
{
2012-05-10 20:02:49 +02:00
InputStream * ist = NULL ;
2012-06-12 20:12:42 +02:00
enum AVMediaType type = avfilter_pad_get_type ( in - > filter_ctx - > input_pads , in - > pad_idx ) ;
2012-04-01 15:08:33 +02:00
int i ;
// TODO: support other filter types
2012-05-17 13:22:17 +02:00
if ( type ! = AVMEDIA_TYPE_VIDEO & & type ! = AVMEDIA_TYPE_AUDIO ) {
av_log ( NULL , AV_LOG_FATAL , " Only video and audio filters supported "
" currently. \n " ) ;
2012-04-01 15:08:33 +02:00
exit_program ( 1 ) ;
}
if ( in - > name ) {
AVFormatContext * s ;
AVStream * st = NULL ;
char * p ;
int file_idx = strtol ( in - > name , & p , 0 ) ;
2012-04-22 12:11:50 +02:00
if ( file_idx < 0 | | file_idx > = nb_input_files ) {
av_log ( NULL , AV_LOG_FATAL , " Invalid file index %d in filtergraph description %s. \n " ,
2012-04-01 15:08:33 +02:00
file_idx , fg - > graph_desc ) ;
exit_program ( 1 ) ;
}
s = input_files [ file_idx ] - > ctx ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
if ( s - > streams [ i ] - > codec - > codec_type ! = type )
continue ;
if ( check_stream_specifier ( s , s - > streams [ i ] , * p = = ' : ' ? p + 1 : p ) = = 1 ) {
st = s - > streams [ i ] ;
break ;
}
}
if ( ! st ) {
av_log ( NULL , AV_LOG_FATAL , " Stream specifier '%s' in filtergraph description %s "
" matches no streams. \n " , p , fg - > graph_desc ) ;
exit_program ( 1 ) ;
}
ist = input_streams [ input_files [ file_idx ] - > ist_index + st - > index ] ;
} else {
/* find the first unused stream of corresponding type */
for ( i = 0 ; i < nb_input_streams ; i + + ) {
ist = input_streams [ i ] ;
if ( ist - > st - > codec - > codec_type = = type & & ist - > discard )
break ;
}
if ( i = = nb_input_streams ) {
av_log ( NULL , AV_LOG_FATAL , " Cannot find a matching stream for "
2012-06-04 09:09:13 +02:00
" unlabeled input pad %d on filter %s \n " , in - > pad_idx ,
2012-04-01 15:08:33 +02:00
in - > filter_ctx - > name ) ;
exit_program ( 1 ) ;
}
}
2012-06-25 13:16:57 +02:00
av_assert0 ( ist ) ;
2012-04-01 15:08:33 +02:00
ist - > discard = 0 ;
ist - > decoding_needed = 1 ;
ist - > st - > discard = AVDISCARD_NONE ;
fg - > inputs = grow_array ( fg - > inputs , sizeof ( * fg - > inputs ) ,
& fg - > nb_inputs , fg - > nb_inputs + 1 ) ;
if ( ! ( fg - > inputs [ fg - > nb_inputs - 1 ] = av_mallocz ( sizeof ( * fg - > inputs [ 0 ] ) ) ) )
exit_program ( 1 ) ;
fg - > inputs [ fg - > nb_inputs - 1 ] - > ist = ist ;
fg - > inputs [ fg - > nb_inputs - 1 ] - > graph = fg ;
ist - > filters = grow_array ( ist - > filters , sizeof ( * ist - > filters ) ,
& ist - > nb_filters , ist - > nb_filters + 1 ) ;
ist - > filters [ ist - > nb_filters - 1 ] = fg - > inputs [ fg - > nb_inputs - 1 ] ;
}
2012-05-17 13:22:17 +02:00
static int configure_output_video_filter ( FilterGraph * fg , OutputFilter * ofilter , AVFilterInOut * out )
2012-04-01 15:08:33 +02:00
{
2012-04-27 06:56:56 +02:00
char * pix_fmts ;
2012-05-26 12:47:47 +02:00
OutputStream * ost = ofilter - > ost ;
AVCodecContext * codec = ost - > st - > codec ;
2012-04-01 15:08:33 +02:00
AVFilterContext * last_filter = out - > filter_ctx ;
int pad_idx = out - > pad_idx ;
int ret ;
2012-06-23 16:08:24 +02:00
char name [ 255 ] ;
2012-04-17 04:01:17 +02:00
AVBufferSinkParams * buffersink_params = av_buffersink_params_alloc ( ) ;
2012-04-01 15:08:33 +02:00
2012-06-23 16:08:24 +02:00
snprintf ( name , sizeof ( name ) , " output stream %d:%d " , ost - > file_index , ost - > index ) ;
2012-05-10 02:14:44 +02:00
ret = avfilter_graph_create_filter ( & ofilter - > filter ,
avfilter_get_by_name ( " buffersink " ) ,
2012-06-24 21:34:54 +02:00
name , NULL , NULL /*buffersink_params*/ , fg - > graph ) ;
2012-04-17 04:01:17 +02:00
av_freep ( & buffersink_params ) ;
2012-04-01 15:08:33 +02:00
if ( ret < 0 )
return ret ;
if ( codec - > width | | codec - > height ) {
char args [ 255 ] ;
2012-04-27 06:56:56 +02:00
AVFilterContext * filter ;
2012-04-01 15:08:33 +02:00
snprintf ( args , sizeof ( args ) , " %d:%d:flags=0x%X " ,
codec - > width ,
codec - > height ,
2012-05-26 12:47:47 +02:00
( unsigned ) ost - > sws_flags ) ;
2012-06-23 16:08:24 +02:00
snprintf ( name , sizeof ( name ) , " scaler for output stream %d:%d " ,
ost - > file_index , ost - > index ) ;
2012-04-27 06:56:56 +02:00
if ( ( ret = avfilter_graph_create_filter ( & filter , avfilter_get_by_name ( " scale " ) ,
2012-06-23 16:08:24 +02:00
name , args , NULL , fg - > graph ) ) < 0 )
2012-04-01 15:08:33 +02:00
return ret ;
2012-04-27 06:56:56 +02:00
if ( ( ret = avfilter_link ( last_filter , pad_idx , filter , 0 ) ) < 0 )
2012-04-01 15:08:33 +02:00
return ret ;
2012-04-27 06:56:56 +02:00
last_filter = filter ;
2012-04-01 15:08:33 +02:00
pad_idx = 0 ;
}
2012-05-26 12:47:47 +02:00
if ( ( pix_fmts = choose_pix_fmts ( ost ) ) ) {
2012-04-27 06:56:56 +02:00
AVFilterContext * filter ;
2012-06-23 16:08:24 +02:00
snprintf ( name , sizeof ( name ) , " pixel format for output stream %d:%d " ,
ost - > file_index , ost - > index ) ;
2012-04-27 06:56:56 +02:00
if ( ( ret = avfilter_graph_create_filter ( & filter ,
avfilter_get_by_name ( " format " ) ,
" format " , pix_fmts , NULL ,
fg - > graph ) ) < 0 )
return ret ;
if ( ( ret = avfilter_link ( last_filter , pad_idx , filter , 0 ) ) < 0 )
return ret ;
last_filter = filter ;
pad_idx = 0 ;
av_freep ( & pix_fmts ) ;
}
2012-05-30 03:32:32 +02:00
if ( ost - > frame_rate . num & & 0 ) {
2012-05-26 12:47:47 +02:00
AVFilterContext * fps ;
char args [ 255 ] ;
snprintf ( args , sizeof ( args ) , " fps=%d/%d " , ost - > frame_rate . num ,
ost - > frame_rate . den ) ;
2012-06-23 16:08:24 +02:00
snprintf ( name , sizeof ( name ) , " fps for output stream %d:%d " ,
ost - > file_index , ost - > index ) ;
2012-05-26 12:47:47 +02:00
ret = avfilter_graph_create_filter ( & fps , avfilter_get_by_name ( " fps " ) ,
2012-06-23 16:08:24 +02:00
name , args , NULL , fg - > graph ) ;
2012-05-26 12:47:47 +02:00
if ( ret < 0 )
return ret ;
ret = avfilter_link ( last_filter , pad_idx , fps , 0 ) ;
if ( ret < 0 )
return ret ;
last_filter = fps ;
pad_idx = 0 ;
}
2012-04-01 15:08:33 +02:00
if ( ( ret = avfilter_link ( last_filter , pad_idx , ofilter - > filter , 0 ) ) < 0 )
return ret ;
return 0 ;
}
2012-05-17 13:22:17 +02:00
static int configure_output_audio_filter ( FilterGraph * fg , OutputFilter * ofilter , AVFilterInOut * out )
{
OutputStream * ost = ofilter - > ost ;
AVCodecContext * codec = ost - > st - > codec ;
AVFilterContext * last_filter = out - > filter_ctx ;
int pad_idx = out - > pad_idx ;
char * sample_fmts , * sample_rates , * channel_layouts ;
2012-06-23 16:08:24 +02:00
char name [ 255 ] ;
2012-05-17 13:22:17 +02:00
int ret ;
2012-06-23 16:08:24 +02:00
snprintf ( name , sizeof ( name ) , " output stream %d:%d " , ost - > file_index , ost - > index ) ;
2012-05-17 13:22:17 +02:00
ret = avfilter_graph_create_filter ( & ofilter - > filter ,
2012-06-25 00:32:49 +02:00
avfilter_get_by_name ( " abuffersink " ) ,
2012-06-23 16:08:24 +02:00
name , NULL , NULL , fg - > graph ) ;
2012-05-17 13:22:17 +02:00
if ( ret < 0 )
return ret ;
2012-06-01 18:42:12 +02:00
# define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \
AVFilterContext * filt_ctx ; \
\
av_log ( NULL , AV_LOG_INFO , opt_name " is forwarded to lavfi " \
" similarly to -af " filter_name " =%s. \n " , arg ) ; \
\
ret = avfilter_graph_create_filter ( & filt_ctx , \
avfilter_get_by_name ( filter_name ) , \
filter_name , arg , NULL , fg - > graph ) ; \
if ( ret < 0 ) \
return ret ; \
\
ret = avfilter_link ( last_filter , pad_idx , filt_ctx , 0 ) ; \
if ( ret < 0 ) \
return ret ; \
\
last_filter = filt_ctx ; \
pad_idx = 0 ; \
} while ( 0 )
if ( ost - > audio_channels_mapped ) {
int i ;
AVBPrint pan_buf ;
av_bprint_init ( & pan_buf , 256 , 8192 ) ;
av_bprintf ( & pan_buf , " 0x% " PRIx64 ,
av_get_default_channel_layout ( ost - > audio_channels_mapped ) ) ;
for ( i = 0 ; i < ost - > audio_channels_mapped ; i + + )
if ( ost - > audio_channels_map [ i ] ! = - 1 )
av_bprintf ( & pan_buf , " :c%d=c%d " , i , ost - > audio_channels_map [ i ] ) ;
AUTO_INSERT_FILTER ( " -map_channel " , " pan " , pan_buf . str ) ;
av_bprint_finalize ( & pan_buf , NULL ) ;
}
2012-05-17 13:22:17 +02:00
if ( codec - > channels & & ! codec - > channel_layout )
codec - > channel_layout = av_get_default_channel_layout ( codec - > channels ) ;
sample_fmts = choose_sample_fmts ( ost ) ;
sample_rates = choose_sample_rates ( ost ) ;
channel_layouts = choose_channel_layouts ( ost ) ;
if ( sample_fmts | | sample_rates | | channel_layouts ) {
AVFilterContext * format ;
char args [ 256 ] ;
int len = 0 ;
if ( sample_fmts )
len + = snprintf ( args + len , sizeof ( args ) - len , " sample_fmts=%s: " ,
sample_fmts ) ;
if ( sample_rates )
len + = snprintf ( args + len , sizeof ( args ) - len , " sample_rates=%s: " ,
sample_rates ) ;
if ( channel_layouts )
len + = snprintf ( args + len , sizeof ( args ) - len , " channel_layouts=%s: " ,
channel_layouts ) ;
args [ len - 1 ] = 0 ;
av_freep ( & sample_fmts ) ;
av_freep ( & sample_rates ) ;
av_freep ( & channel_layouts ) ;
2012-06-23 16:08:24 +02:00
snprintf ( name , sizeof ( name ) , " audio format for output stream %d:%d " ,
ost - > file_index , ost - > index ) ;
2012-05-17 13:22:17 +02:00
ret = avfilter_graph_create_filter ( & format ,
avfilter_get_by_name ( " aformat " ) ,
2012-06-23 16:08:24 +02:00
name , args , NULL , fg - > graph ) ;
2012-05-17 13:22:17 +02:00
if ( ret < 0 )
return ret ;
ret = avfilter_link ( last_filter , pad_idx , format , 0 ) ;
if ( ret < 0 )
return ret ;
last_filter = format ;
pad_idx = 0 ;
}
2012-06-04 15:46:59 +02:00
if ( audio_volume ! = 256 & & 0 ) {
2012-05-30 03:32:32 +02:00
char args [ 256 ] ;
snprintf ( args , sizeof ( args ) , " %f " , audio_volume / 256. ) ;
AUTO_INSERT_FILTER ( " -vol " , " volume " , args ) ;
2012-05-17 13:22:17 +02:00
}
if ( ( ret = avfilter_link ( last_filter , pad_idx , ofilter - > filter , 0 ) ) < 0 )
return ret ;
return 0 ;
}
2012-05-26 13:31:54 +02:00
# define DESCRIBE_FILTER_LINK(f, inout, in) \
{ \
AVFilterContext * ctx = inout - > filter_ctx ; \
AVFilterPad * pads = in ? ctx - > input_pads : ctx - > output_pads ; \
int nb_pads = in ? ctx - > input_count : ctx - > output_count ; \
AVIOContext * pb ; \
\
if ( avio_open_dyn_buf ( & pb ) < 0 ) \
exit_program ( 1 ) ; \
\
avio_printf ( pb , " %s " , ctx - > filter - > name ) ; \
if ( nb_pads > 1 ) \
2012-06-12 20:12:42 +02:00
avio_printf ( pb , " :%s " , avfilter_pad_get_name ( pads , inout - > pad_idx ) ) ; \
2012-05-26 13:31:54 +02:00
avio_w8 ( pb , 0 ) ; \
avio_close_dyn_buf ( pb , & f - > name ) ; \
}
2012-05-17 13:22:17 +02:00
static int configure_output_filter ( FilterGraph * fg , OutputFilter * ofilter , AVFilterInOut * out )
{
2012-05-26 13:31:54 +02:00
av_freep ( & ofilter - > name ) ;
DESCRIBE_FILTER_LINK ( ofilter , out , 0 ) ;
2012-06-12 20:12:42 +02:00
switch ( avfilter_pad_get_type ( out - > filter_ctx - > output_pads , out - > pad_idx ) ) {
2012-05-17 13:22:17 +02:00
case AVMEDIA_TYPE_VIDEO : return configure_output_video_filter ( fg , ofilter , out ) ;
case AVMEDIA_TYPE_AUDIO : return configure_output_audio_filter ( fg , ofilter , out ) ;
default : av_assert0 ( 0 ) ;
}
}
2012-05-26 11:18:21 +02:00
static int configure_input_video_filter ( FilterGraph * fg , InputFilter * ifilter ,
AVFilterInOut * in )
{
2012-05-26 16:52:58 +02:00
AVFilterContext * first_filter = in - > filter_ctx ;
2012-05-26 11:18:21 +02:00
AVFilter * filter = avfilter_get_by_name ( " buffer " ) ;
InputStream * ist = ifilter - > ist ;
2012-05-26 16:52:58 +02:00
AVRational tb = ist - > framerate . num ? ( AVRational ) { ist - > framerate . den ,
ist - > framerate . num } :
ist - > st - > time_base ;
2012-06-05 12:42:39 +02:00
AVRational fr = ist - > framerate . num ? ist - > framerate :
ist - > st - > r_frame_rate ;
2012-05-26 11:18:21 +02:00
AVRational sar ;
2012-06-05 12:42:39 +02:00
AVBPrint args ;
2012-06-24 21:34:54 +02:00
char name [ 255 ] ;
2012-05-26 16:52:58 +02:00
int pad_idx = in - > pad_idx ;
2012-05-26 11:18:21 +02:00
int ret ;
sar = ist - > st - > sample_aspect_ratio . num ?
ist - > st - > sample_aspect_ratio :
ist - > st - > codec - > sample_aspect_ratio ;
2012-06-09 13:59:00 +02:00
if ( ! sar . den )
sar = ( AVRational ) { 0 , 1 } ;
2012-06-05 12:42:39 +02:00
av_bprint_init ( & args , 0 , 1 ) ;
av_bprintf ( & args ,
" video_size=%dx%d:pix_fmt=%d:time_base=%d/%d: "
" pixel_aspect=%d/%d:sws_param=flags=%d " , ist - > st - > codec - > width ,
2012-05-26 12:47:47 +02:00
ist - > st - > codec - > height , ist - > st - > codec - > pix_fmt ,
2012-05-30 03:32:32 +02:00
tb . num , tb . den , sar . num , sar . den ,
SWS_BILINEAR + ( ( ist - > st - > codec - > flags & CODEC_FLAG_BITEXACT ) ? SWS_BITEXACT : 0 ) ) ;
2012-06-05 12:42:39 +02:00
if ( fr . num & & fr . den )
av_bprintf ( & args , " :frame_rate=%d/%d " , fr . num , fr . den ) ;
2012-06-23 16:08:24 +02:00
snprintf ( name , sizeof ( name ) , " graph %d input from stream %d:%d " , fg - > index ,
ist - > file_index , ist - > st - > index ) ;
2012-05-26 11:18:21 +02:00
2012-06-23 16:08:24 +02:00
if ( ( ret = avfilter_graph_create_filter ( & ifilter - > filter , filter , name ,
2012-06-05 12:42:39 +02:00
args . str , NULL , fg - > graph ) ) < 0 )
2012-05-26 11:18:21 +02:00
return ret ;
2012-05-26 16:52:58 +02:00
if ( ist - > framerate . num ) {
AVFilterContext * setpts ;
2012-06-23 16:08:24 +02:00
snprintf ( name , sizeof ( name ) , " force CFR for input from stream %d:%d " ,
ist - > file_index , ist - > st - > index ) ;
2012-05-26 16:52:58 +02:00
if ( ( ret = avfilter_graph_create_filter ( & setpts ,
avfilter_get_by_name ( " setpts " ) ,
2012-06-23 16:08:24 +02:00
name , " N " , NULL ,
2012-05-26 16:52:58 +02:00
fg - > graph ) ) < 0 )
return ret ;
if ( ( ret = avfilter_link ( setpts , 0 , first_filter , pad_idx ) ) < 0 )
return ret ;
first_filter = setpts ;
pad_idx = 0 ;
}
if ( ( ret = avfilter_link ( ifilter - > filter , 0 , first_filter , pad_idx ) ) < 0 )
2012-05-26 11:18:21 +02:00
return ret ;
return 0 ;
}
static int configure_input_audio_filter ( FilterGraph * fg , InputFilter * ifilter ,
AVFilterInOut * in )
{
2012-05-26 12:47:47 +02:00
AVFilterContext * first_filter = in - > filter_ctx ;
2012-05-26 11:18:21 +02:00
AVFilter * filter = avfilter_get_by_name ( " abuffer " ) ;
InputStream * ist = ifilter - > ist ;
2012-05-26 12:47:47 +02:00
int pad_idx = in - > pad_idx ;
2012-06-23 16:08:24 +02:00
char args [ 255 ] , name [ 255 ] ;
2012-05-26 11:18:21 +02:00
int ret ;
snprintf ( args , sizeof ( args ) , " time_base=%d/%d:sample_rate=%d:sample_fmt=%s "
" :channel_layout=0x% " PRIx64 ,
avconv: Set audio filter time base to the sample rate
If the output frame size is smaller than the input sample rate,
and the input stream time base corresponds exactly to the input
frame size (getting input packet timestamps like 0, 1, 2, 3, 4 etc),
the output timestamps from the filter will be like
0, 1, 2, 3, 4, 4, 5 ..., leadning to non-monotone timestamps later.
A concrete example is input mp3 data having frame sizes of 1152
samples, transcoded to aac with 1024 sample frames.
By setting the audio filter time base to the sample rate, we will
get sensible timestamps for all output packets, regardless of
the ratio between the input and output frame sizes.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-06-30 10:26:11 +02:00
1 , ist - > st - > codec - > sample_rate ,
2012-05-26 11:18:21 +02:00
ist - > st - > codec - > sample_rate ,
av_get_sample_fmt_name ( ist - > st - > codec - > sample_fmt ) ,
ist - > st - > codec - > channel_layout ) ;
2012-06-23 16:08:24 +02:00
snprintf ( name , sizeof ( name ) , " graph %d input from stream %d:%d " , fg - > index ,
ist - > file_index , ist - > st - > index ) ;
2012-05-26 11:18:21 +02:00
if ( ( ret = avfilter_graph_create_filter ( & ifilter - > filter , filter ,
2012-06-23 16:08:24 +02:00
name , args , NULL ,
2012-05-26 11:18:21 +02:00
fg - > graph ) ) < 0 )
return ret ;
2012-05-26 12:47:47 +02:00
2012-05-30 03:32:32 +02:00
# define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg) do { \
AVFilterContext * filt_ctx ; \
\
av_log ( NULL , AV_LOG_INFO , opt_name " is forwarded to lavfi " \
" similarly to -af " filter_name " =%s. \n " , arg ) ; \
\
2012-06-24 21:34:54 +02:00
snprintf ( name , sizeof ( name ) , " graph %d %s for input stream %d:%d " , \
fg - > index , filter_name , ist - > file_index , ist - > st - > index ) ; \
2012-05-30 03:32:32 +02:00
ret = avfilter_graph_create_filter ( & filt_ctx , \
avfilter_get_by_name ( filter_name ) , \
2012-06-24 21:34:54 +02:00
name , arg , NULL , fg - > graph ) ; \
2012-05-30 03:32:32 +02:00
if ( ret < 0 ) \
return ret ; \
\
ret = avfilter_link ( filt_ctx , 0 , first_filter , pad_idx ) ; \
if ( ret < 0 ) \
return ret ; \
\
first_filter = filt_ctx ; \
} while ( 0 )
2012-05-26 12:47:47 +02:00
2012-05-30 03:32:32 +02:00
if ( audio_sync_method > 0 ) {
char args [ 256 ] = { 0 } ;
2012-05-26 12:47:47 +02:00
2012-05-30 03:32:32 +02:00
av_strlcatf ( args , sizeof ( args ) , " min_comp=0.001:min_hard_comp=%f " , audio_drift_threshold ) ;
2012-05-26 12:47:47 +02:00
if ( audio_sync_method > 1 )
2012-05-30 03:32:32 +02:00
av_strlcatf ( args , sizeof ( args ) , " :max_soft_comp=%f " , audio_sync_method / ( double ) ist - > st - > codec - > sample_rate ) ;
AUTO_INSERT_FILTER_INPUT ( " -async " , " aresample " , args ) ;
}
// if (ost->audio_channels_mapped) {
// int i;
// AVBPrint pan_buf;
// av_bprint_init(&pan_buf, 256, 8192);
// av_bprintf(&pan_buf, "0x%"PRIx64,
// av_get_default_channel_layout(ost->audio_channels_mapped));
// for (i = 0; i < ost->audio_channels_mapped; i++)
// if (ost->audio_channels_map[i] != -1)
// av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
// AUTO_INSERT_FILTER_INPUT("-map_channel", "pan", pan_buf.str);
// av_bprint_finalize(&pan_buf, NULL);
// }
2012-05-26 12:47:47 +02:00
2012-05-30 03:32:32 +02:00
if ( audio_volume ! = 256 ) {
char args [ 256 ] ;
2012-05-26 12:47:47 +02:00
2012-05-30 03:32:32 +02:00
snprintf ( args , sizeof ( args ) , " %f " , audio_volume / 256. ) ;
AUTO_INSERT_FILTER_INPUT ( " -vol " , " volume " , args ) ;
2012-05-26 12:47:47 +02:00
}
if ( ( ret = avfilter_link ( ifilter - > filter , 0 , first_filter , pad_idx ) ) < 0 )
2012-05-26 11:18:21 +02:00
return ret ;
return 0 ;
}
static int configure_input_filter ( FilterGraph * fg , InputFilter * ifilter ,
AVFilterInOut * in )
{
2012-05-26 13:31:54 +02:00
av_freep ( & ifilter - > name ) ;
DESCRIBE_FILTER_LINK ( ifilter , in , 1 ) ;
2012-06-12 20:12:42 +02:00
switch ( avfilter_pad_get_type ( in - > filter_ctx - > input_pads , in - > pad_idx ) ) {
2012-05-26 11:18:21 +02:00
case AVMEDIA_TYPE_VIDEO : return configure_input_video_filter ( fg , ifilter , in ) ;
case AVMEDIA_TYPE_AUDIO : return configure_input_audio_filter ( fg , ifilter , in ) ;
default : av_assert0 ( 0 ) ;
}
}
2012-05-26 12:47:47 +02:00
static int configure_filtergraph ( FilterGraph * fg )
2012-04-01 15:08:33 +02:00
{
AVFilterInOut * inputs , * outputs , * cur ;
2012-05-26 12:47:47 +02:00
int ret , i , init = ! fg - > graph , simple = ! fg - > graph_desc ;
const char * graph_desc = simple ? fg - > outputs [ 0 ] - > ost - > avfilter :
fg - > graph_desc ;
2012-04-01 15:08:33 +02:00
avfilter_graph_free ( & fg - > graph ) ;
if ( ! ( fg - > graph = avfilter_graph_alloc ( ) ) )
return AVERROR ( ENOMEM ) ;
2012-05-26 12:47:47 +02:00
if ( simple ) {
OutputStream * ost = fg - > outputs [ 0 ] - > ost ;
char args [ 255 ] ;
snprintf ( args , sizeof ( args ) , " flags=0x%X " , ( unsigned ) ost - > sws_flags ) ;
fg - > graph - > scale_sws_opts = av_strdup ( args ) ;
}
2012-04-01 15:08:33 +02:00
2012-05-26 12:47:47 +02:00
if ( ( ret = avfilter_graph_parse2 ( fg - > graph , graph_desc , & inputs , & outputs ) ) < 0 )
2012-04-01 15:08:33 +02:00
return ret ;
2012-05-26 12:47:47 +02:00
if ( simple & & ( ! inputs | | inputs - > next | | ! outputs | | outputs - > next ) ) {
av_log ( NULL , AV_LOG_ERROR , " Simple filtergraph '%s' does not have "
" exactly one input and output. \n " , graph_desc ) ;
return AVERROR ( EINVAL ) ;
}
2012-04-01 15:08:33 +02:00
2012-05-26 12:47:47 +02:00
for ( cur = inputs ; ! simple & & init & & cur ; cur = cur - > next )
2012-04-01 15:08:33 +02:00
init_input_filter ( fg , cur ) ;
2012-05-26 11:18:21 +02:00
for ( cur = inputs , i = 0 ; cur ; cur = cur - > next , i + + )
if ( ( ret = configure_input_filter ( fg , fg - > inputs [ i ] , cur ) ) < 0 )
2012-04-01 15:08:33 +02:00
return ret ;
avfilter_inout_free ( & inputs ) ;
2012-05-26 12:47:47 +02:00
if ( ! init | | simple ) {
2012-04-01 15:08:33 +02:00
/* we already know the mappings between lavfi outputs and output streams,
* so we can finish the setup */
for ( cur = outputs , i = 0 ; cur ; cur = cur - > next , i + + )
configure_output_filter ( fg , fg - > outputs [ i ] , cur ) ;
avfilter_inout_free ( & outputs ) ;
if ( ( ret = avfilter_graph_config ( fg - > graph , NULL ) ) < 0 )
return ret ;
} else {
/* wait until output mappings are processed */
for ( cur = outputs ; cur ; ) {
fg - > outputs = grow_array ( fg - > outputs , sizeof ( * fg - > outputs ) ,
& fg - > nb_outputs , fg - > nb_outputs + 1 ) ;
if ( ! ( fg - > outputs [ fg - > nb_outputs - 1 ] = av_mallocz ( sizeof ( * fg - > outputs [ 0 ] ) ) ) )
exit_program ( 1 ) ;
fg - > outputs [ fg - > nb_outputs - 1 ] - > graph = fg ;
fg - > outputs [ fg - > nb_outputs - 1 ] - > out_tmp = cur ;
cur = cur - > next ;
fg - > outputs [ fg - > nb_outputs - 1 ] - > out_tmp - > next = NULL ;
}
}
return 0 ;
}
static int configure_complex_filters ( void )
{
int i , ret = 0 ;
for ( i = 0 ; i < nb_filtergraphs ; i + + )
if ( ! filtergraphs [ i ] - > graph & &
2012-05-26 12:47:47 +02:00
( ret = configure_filtergraph ( filtergraphs [ i ] ) ) < 0 )
2012-04-01 15:08:33 +02:00
return ret ;
return 0 ;
}
static int ist_in_filtergraph ( FilterGraph * fg , InputStream * ist )
{
int i ;
for ( i = 0 ; i < fg - > nb_inputs ; i + + )
if ( fg - > inputs [ i ] - > ist = = ist )
return 1 ;
return 0 ;
}
2001-07-22 16:37:44 +02:00
static void term_exit ( void )
{
2011-06-15 11:24:00 +02:00
av_log ( NULL , AV_LOG_QUIET , " %s " , " " ) ;
2011-03-30 20:58:13 +02:00
# if HAVE_TERMIOS_H
2012-01-17 00:10:17 +01:00
if ( restore_tty )
2011-04-18 13:10:52 +02:00
tcsetattr ( 0 , TCSANOW , & oldtty ) ;
2011-03-30 20:58:13 +02:00
# endif
2010-03-20 02:02:45 +01:00
}
2001-07-22 16:37:44 +02:00
2009-07-27 15:01:44 +02:00
static volatile int received_sigterm = 0 ;
2003-04-10 20:21:06 +02:00
2011-09-12 11:44:14 +02:00
static void sigterm_handler ( int sig )
2003-04-10 20:21:06 +02:00
{
received_sigterm = sig ;
2011-10-08 17:21:25 +02:00
received_nb_signals + + ;
2003-04-10 20:21:06 +02:00
term_exit ( ) ;
2011-12-16 19:37:32 +01:00
if ( received_nb_signals > 3 )
exit ( 123 ) ;
2003-04-10 20:21:06 +02:00
}
2001-07-22 16:37:44 +02:00
static void term_init ( void )
{
2011-03-30 20:58:13 +02:00
# if HAVE_TERMIOS_H
2011-04-22 18:49:44 +02:00
if ( ! run_as_daemon ) {
2012-05-04 19:21:31 +02:00
struct termios tty ;
2012-06-06 12:39:07 +02:00
int istty = 1 ;
2012-06-05 19:58:03 +02:00
# if HAVE_ISATTY
2012-06-06 12:39:07 +02:00
istty = isatty ( 0 ) & & isatty ( 2 ) ;
2012-06-05 19:58:03 +02:00
# endif
2012-06-06 12:39:07 +02:00
if ( istty & & tcgetattr ( 0 , & tty ) = = 0 ) {
2012-05-04 19:21:31 +02:00
oldtty = tty ;
restore_tty = 1 ;
atexit ( term_exit ) ;
tty . c_iflag & = ~ ( IGNBRK | BRKINT | PARMRK | ISTRIP
| INLCR | IGNCR | ICRNL | IXON ) ;
tty . c_oflag | = OPOST ;
tty . c_lflag & = ~ ( ECHO | ECHONL | ICANON | IEXTEN ) ;
tty . c_cflag & = ~ ( CSIZE | PARENB ) ;
tty . c_cflag | = CS8 ;
tty . c_cc [ VMIN ] = 1 ;
tty . c_cc [ VTIME ] = 0 ;
tcsetattr ( 0 , TCSANOW , & tty ) ;
}
signal ( SIGQUIT , sigterm_handler ) ; /* Quit (POSIX). */
2011-04-18 13:10:52 +02:00
}
2011-03-30 20:58:13 +02:00
# endif
2011-11-07 02:41:01 +01:00
avformat_network_deinit ( ) ;
2011-03-30 20:58:13 +02:00
2011-12-30 03:46:24 +01:00
signal ( SIGINT , sigterm_handler ) ; /* Interrupt (ANSI). */
2003-04-10 20:21:06 +02:00
signal ( SIGTERM , sigterm_handler ) ; /* Termination (ANSI). */
2010-01-20 07:42:39 +01:00
# ifdef SIGXCPU
signal ( SIGXCPU , sigterm_handler ) ;
# endif
2001-07-22 16:37:44 +02:00
}
/* read a key without blocking */
static int read_key ( void )
{
2011-09-04 00:24:06 +02:00
unsigned char ch ;
2011-03-30 20:58:13 +02:00
# if HAVE_TERMIOS_H
int n = 1 ;
struct timeval tv ;
fd_set rfds ;
FD_ZERO ( & rfds ) ;
FD_SET ( 0 , & rfds ) ;
tv . tv_sec = 0 ;
tv . tv_usec = 0 ;
n = select ( 1 , & rfds , NULL , NULL , & tv ) ;
if ( n > 0 ) {
n = read ( 0 , & ch , 1 ) ;
if ( n = = 1 )
return ch ;
return n ;
}
# elif HAVE_KBHIT
2011-09-04 00:24:06 +02:00
# if HAVE_PEEKNAMEDPIPE
static int is_pipe ;
static HANDLE input_handle ;
DWORD dw , nchars ;
if ( ! input_handle ) {
input_handle = GetStdHandle ( STD_INPUT_HANDLE ) ;
is_pipe = ! GetConsoleMode ( input_handle , & dw ) ;
}
if ( stdin - > _cnt > 0 ) {
read ( 0 , & ch , 1 ) ;
return ch ;
}
if ( is_pipe ) {
/* When running under a GUI, you will end here. */
if ( ! PeekNamedPipe ( input_handle , NULL , 0 , NULL , & nchars , NULL ) )
return - 1 ;
//Read it
if ( nchars ! = 0 ) {
read ( 0 , & ch , 1 ) ;
return ch ;
} else {
return - 1 ;
}
}
# endif
2007-07-11 16:07:55 +02:00
if ( kbhit ( ) )
return ( getch ( ) ) ;
2006-11-22 13:15:58 +01:00
# endif
2001-07-22 16:37:44 +02:00
return - 1 ;
}
2011-11-19 01:55:55 +01:00
static int decode_interrupt_cb ( void * ctx )
2004-03-14 20:40:43 +01:00
{
2011-10-08 17:21:25 +02:00
return received_nb_signals > 1 ;
2004-03-14 20:40:43 +01:00
}
2011-11-19 01:55:55 +01:00
static const AVIOInterruptCB int_cb = { decode_interrupt_cb , NULL } ;
2011-11-11 04:24:25 +01:00
void av_noreturn exit_program ( int ret )
2008-04-15 00:31:49 +02:00
{
2012-03-29 08:51:17 +02:00
int i , j ;
for ( i = 0 ; i < nb_filtergraphs ; i + + ) {
avfilter_graph_free ( & filtergraphs [ i ] - > graph ) ;
2012-05-26 13:31:54 +02:00
for ( j = 0 ; j < filtergraphs [ i ] - > nb_inputs ; j + + ) {
av_freep ( & filtergraphs [ i ] - > inputs [ j ] - > name ) ;
2012-03-29 08:51:17 +02:00
av_freep ( & filtergraphs [ i ] - > inputs [ j ] ) ;
2012-05-26 13:31:54 +02:00
}
2012-03-29 08:51:17 +02:00
av_freep ( & filtergraphs [ i ] - > inputs ) ;
2012-05-26 13:31:54 +02:00
for ( j = 0 ; j < filtergraphs [ i ] - > nb_outputs ; j + + ) {
av_freep ( & filtergraphs [ i ] - > outputs [ j ] - > name ) ;
2012-03-29 08:51:17 +02:00
av_freep ( & filtergraphs [ i ] - > outputs [ j ] ) ;
2012-05-26 13:31:54 +02:00
}
2012-03-29 08:51:17 +02:00
av_freep ( & filtergraphs [ i ] - > outputs ) ;
av_freep ( & filtergraphs [ i ] ) ;
}
av_freep ( & filtergraphs ) ;
2008-04-15 00:31:49 +02:00
2012-06-22 22:15:24 +02:00
av_freep ( & subtitle_out ) ;
2008-04-15 00:31:49 +02:00
/* close files */
2011-12-30 03:46:24 +01:00
for ( i = 0 ; i < nb_output_files ; i + + ) {
2012-04-15 15:28:30 +02:00
AVFormatContext * s = output_files [ i ] - > ctx ;
2008-04-21 03:22:25 +02:00
if ( ! ( s - > oformat - > flags & AVFMT_NOFILE ) & & s - > pb )
2011-02-21 22:45:20 +01:00
avio_close ( s - > pb ) ;
2011-02-04 11:04:18 +01:00
avformat_free_context ( s ) ;
2012-04-15 15:28:30 +02:00
av_dict_free ( & output_files [ i ] - > opts ) ;
av_freep ( & output_files [ i ] ) ;
2008-04-15 00:31:49 +02:00
}
2012-01-02 02:48:34 +01:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
AVBitStreamFilterContext * bsfc = output_streams [ i ] - > bitstream_filters ;
2012-01-02 02:48:34 +01:00
while ( bsfc ) {
AVBitStreamFilterContext * next = bsfc - > next ;
av_bitstream_filter_close ( bsfc ) ;
bsfc = next ;
}
2012-04-15 15:28:30 +02:00
output_streams [ i ] - > bitstream_filters = NULL ;
2012-01-17 01:40:45 +01:00
2012-06-22 14:36:27 +02:00
av_freep ( & output_streams [ i ] - > forced_keyframes ) ;
2012-03-29 09:00:09 +02:00
av_freep ( & output_streams [ i ] - > filtered_frame ) ;
2012-06-01 12:31:13 +02:00
av_freep ( & output_streams [ i ] - > avfilter ) ;
2012-04-15 15:28:30 +02:00
av_freep ( & output_streams [ i ] ) ;
2008-04-15 00:31:49 +02:00
}
2011-12-30 03:46:24 +01:00
for ( i = 0 ; i < nb_input_files ; i + + ) {
2012-04-15 15:28:30 +02:00
avformat_close_input ( & input_files [ i ] - > ctx ) ;
av_freep ( & input_files [ i ] ) ;
2010-10-01 23:36:13 +02:00
}
2011-12-06 01:37:27 +01:00
for ( i = 0 ; i < nb_input_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
av_freep ( & input_streams [ i ] - > decoded_frame ) ;
av_dict_free ( & input_streams [ i ] - > opts ) ;
2012-05-30 07:32:43 +02:00
free_buffer_pool ( & input_streams [ i ] - > buffer_pool ) ;
2012-03-29 08:51:17 +02:00
av_freep ( & input_streams [ i ] - > filters ) ;
2012-04-15 15:28:30 +02:00
av_freep ( & input_streams [ i ] ) ;
2011-12-06 01:37:27 +01:00
}
2008-04-15 00:31:49 +02:00
if ( vstats_file )
fclose ( vstats_file ) ;
av_free ( vstats_filename ) ;
2011-05-22 22:12:35 +02:00
av_freep ( & input_streams ) ;
av_freep ( & input_files ) ;
2011-08-30 15:03:53 +02:00
av_freep ( & output_streams ) ;
2011-08-30 14:19:39 +02:00
av_freep ( & output_files ) ;
2011-05-22 22:12:35 +02:00
2010-10-02 10:44:33 +02:00
uninit_opts ( ) ;
2009-04-13 05:47:12 +02:00
2010-05-07 11:43:21 +02:00
avfilter_uninit ( ) ;
2011-11-06 01:47:48 +01:00
avformat_network_deinit ( ) ;
2010-05-07 11:43:21 +02:00
2008-04-15 00:31:49 +02:00
if ( received_sigterm ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_INFO , " Received signal %d: terminating. \n " ,
( int ) received_sigterm ) ;
2008-04-15 00:31:49 +02:00
exit ( 255 ) ;
}
2012-05-19 12:05:02 +02:00
exit ( ret ) ;
2010-10-01 23:29:37 +02:00
}
2011-06-09 10:58:23 +02:00
static void assert_avoptions ( AVDictionary * m )
{
AVDictionaryEntry * t ;
if ( ( t = av_dict_get ( m , " " , NULL , AV_DICT_IGNORE_SUFFIX ) ) ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Option %s not found. \n " , t - > key ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2011-06-09 10:58:23 +02:00
}
}
2011-07-12 17:18:42 +02:00
static void assert_codec_experimental ( AVCodecContext * c , int encoder )
{
const char * codec_string = encoder ? " encoder " : " decoder " ;
AVCodec * codec ;
if ( c - > codec - > capabilities & CODEC_CAP_EXPERIMENTAL & &
c - > strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " %s '%s' is experimental and might produce bad "
2011-07-12 17:18:42 +02:00
" results. \n Add '-strict experimental' if you want to use it. \n " ,
codec_string , c - > codec - > name ) ;
2011-07-14 22:01:29 +02:00
codec = encoder ? avcodec_find_encoder ( c - > codec - > id ) : avcodec_find_decoder ( c - > codec - > id ) ;
2011-07-12 17:18:42 +02:00
if ( ! ( codec - > capabilities & CODEC_CAP_EXPERIMENTAL ) )
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Or use the non experimental %s '%s'. \n " ,
2011-07-12 17:18:42 +02:00
codec_string , codec - > name ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2011-07-12 17:18:42 +02:00
}
}
2010-03-30 21:37:07 +02:00
static void choose_sample_fmt ( AVStream * st , AVCodec * codec )
{
2011-12-30 03:46:24 +01:00
if ( codec & & codec - > sample_fmts ) {
const enum AVSampleFormat * p = codec - > sample_fmts ;
for ( ; * p ! = - 1 ; p + + ) {
if ( * p = = st - > codec - > sample_fmt )
2010-03-30 21:37:07 +02:00
break ;
}
2011-01-14 15:50:55 +01:00
if ( * p = = - 1 ) {
2011-06-18 21:54:11 +02:00
if ( ( codec - > capabilities & CODEC_CAP_LOSSLESS ) & & av_get_sample_fmt_name ( st - > codec - > sample_fmt ) > av_get_sample_fmt_name ( codec - > sample_fmts [ 0 ] ) )
2011-11-05 11:30:16 +01:00
av_log ( NULL , AV_LOG_ERROR , " Conversion will not be lossless. \n " ) ;
2011-08-13 14:16:55 +02:00
if ( av_get_sample_fmt_name ( st - > codec - > sample_fmt ) )
2011-01-14 15:50:55 +01:00
av_log ( NULL , AV_LOG_WARNING ,
" Incompatible sample format '%s' for codec '%s', auto-selecting format '%s' \n " ,
av_get_sample_fmt_name ( st - > codec - > sample_fmt ) ,
codec - > name ,
av_get_sample_fmt_name ( codec - > sample_fmts [ 0 ] ) ) ;
2010-03-30 21:37:07 +02:00
st - > codec - > sample_fmt = codec - > sample_fmts [ 0 ] ;
2011-01-14 15:50:55 +01:00
}
2010-03-30 21:37:07 +02:00
}
}
2012-01-02 02:48:34 +01:00
static void write_frame ( AVFormatContext * s , AVPacket * pkt , OutputStream * ost )
2011-09-12 11:44:14 +02:00
{
2012-01-02 02:48:34 +01:00
AVBitStreamFilterContext * bsfc = ost - > bitstream_filters ;
AVCodecContext * avctx = ost - > st - > codec ;
2007-11-01 02:59:22 +01:00
int ret ;
2012-03-22 20:17:42 +01:00
if ( ( avctx - > codec_type = = AVMEDIA_TYPE_VIDEO & & video_sync_method = = VSYNC_DROP ) | |
( avctx - > codec_type = = AVMEDIA_TYPE_AUDIO & & audio_sync_method < 0 ) )
pkt - > pts = pkt - > dts = AV_NOPTS_VALUE ;
2012-05-17 04:07:16 +02:00
if ( avctx - > codec_type = = AVMEDIA_TYPE_AUDIO & & pkt - > dts ! = AV_NOPTS_VALUE ) {
int64_t max = ost - > st - > cur_dts + ! ( s - > oformat - > flags & AVFMT_TS_NONSTRICT ) ;
if ( ost - > st - > cur_dts & & ost - > st - > cur_dts ! = AV_NOPTS_VALUE & & max > pkt - > dts ) {
av_log ( s , max - pkt - > dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG , " Audio timestamp % " PRId64 " < % " PRId64 " invalid, cliping \n " , pkt - > dts , max ) ;
pkt - > pts = pkt - > dts = max ;
}
}
2012-01-18 02:07:42 +01:00
/*
* Audio encoders may split the packets - - # frames in ! = # packets out .
* But there is no reordering , so we can limit the number of output packets
* by simply dropping them here .
* Counting encoded video frames needs to be done separately because of
* reordering , see do_video_out ( )
*/
if ( ! ( avctx - > codec_type = = AVMEDIA_TYPE_VIDEO & & avctx - > codec ) ) {
2012-03-20 20:36:28 +01:00
if ( ost - > frame_number > = ost - > max_frames ) {
av_free_packet ( pkt ) ;
2012-01-18 02:07:42 +01:00
return ;
2012-03-20 20:36:28 +01:00
}
2012-01-18 02:07:42 +01:00
ost - > frame_number + + ;
}
2008-06-12 03:43:52 +02:00
2011-12-30 03:46:24 +01:00
while ( bsfc ) {
AVPacket new_pkt = * pkt ;
int a = av_bitstream_filter_filter ( bsfc , avctx , NULL ,
& new_pkt . data , & new_pkt . size ,
pkt - > data , pkt - > size ,
pkt - > flags & AV_PKT_FLAG_KEY ) ;
if ( a > 0 ) {
2006-07-06 17:04:46 +02:00
av_free_packet ( pkt ) ;
2011-12-30 03:46:24 +01:00
new_pkt . destruct = av_destruct_packet ;
} else if ( a < 0 ) {
2012-01-12 23:56:58 +01:00
av_log ( NULL , AV_LOG_ERROR , " Failed to open bitstream filter %s for stream %d with codec %s " ,
2011-09-27 02:14:37 +02:00
bsfc - > filter - > name , pkt - > stream_index ,
avctx - > codec ? avctx - > codec - > name : " copy " ) ;
2008-01-21 14:36:20 +01:00
print_error ( " " , a ) ;
2008-09-05 01:23:44 +02:00
if ( exit_on_error )
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2006-07-06 17:04:46 +02:00
}
2011-12-30 03:46:24 +01:00
* pkt = new_pkt ;
2006-07-06 17:04:46 +02:00
2011-12-30 03:46:24 +01:00
bsfc = bsfc - > next ;
2006-07-06 17:04:46 +02:00
}
2012-02-01 10:23:28 +01:00
pkt - > stream_index = ost - > index ;
2011-12-30 03:46:24 +01:00
ret = av_interleaved_write_frame ( s , pkt ) ;
if ( ret < 0 ) {
2007-11-01 02:59:22 +01:00
print_error ( " av_interleaved_write_frame() " , ret ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2007-11-01 02:59:22 +01:00
}
2006-07-06 17:04:46 +02:00
}
2012-05-20 10:28:41 +02:00
static int check_recording_time ( OutputStream * ost )
{
OutputFile * of = output_files [ ost - > file_index ] ;
if ( of - > recording_time ! = INT64_MAX & &
av_compare_ts ( ost - > sync_opts - ost - > first_pts , ost - > st - > codec - > time_base , of - > recording_time ,
AV_TIME_BASE_Q ) > = 0 ) {
ost - > is_past_recording_time = 1 ;
return 0 ;
}
return 1 ;
}
2001-07-22 16:37:44 +02:00
2012-05-05 18:22:46 +02:00
static void do_audio_out ( AVFormatContext * s , OutputStream * ost ,
AVFrame * frame )
2012-01-17 01:40:45 +01:00
{
AVCodecContext * enc = ost - > st - > codec ;
AVPacket pkt ;
2012-05-05 18:22:46 +02:00
int got_packet = 0 ;
2007-11-01 02:59:22 +01:00
2012-01-17 01:40:45 +01:00
av_init_packet ( & pkt ) ;
pkt . data = NULL ;
pkt . size = 0 ;
2012-07-03 20:34:27 +02:00
2012-05-05 18:22:46 +02:00
if ( ! check_recording_time ( ost ) )
return ;
2012-07-03 20:34:27 +02:00
2012-05-05 18:22:46 +02:00
if ( frame - > pts = = AV_NOPTS_VALUE | | audio_sync_method < 0 )
2012-03-01 19:02:49 +01:00
frame - > pts = ost - > sync_opts ;
2012-05-05 18:22:46 +02:00
ost - > sync_opts = frame - > pts + frame - > nb_samples ;
2006-07-06 17:04:46 +02:00
2012-05-05 18:22:46 +02:00
av_assert0 ( pkt . size | | ! pkt . data ) ;
2012-04-11 19:26:09 +02:00
update_benchmark ( NULL ) ;
2012-01-17 01:40:45 +01:00
if ( avcodec_encode_audio2 ( enc , & pkt , frame , & got_packet ) < 0 ) {
2012-03-27 02:30:08 +02:00
av_log ( NULL , AV_LOG_FATAL , " Audio encoding failed (avcodec_encode_audio2) \n " ) ;
2011-08-29 07:03:24 +02:00
exit_program ( 1 ) ;
2007-11-01 02:59:22 +01:00
}
2012-04-11 19:26:09 +02:00
update_benchmark ( " encode_audio %d.%d " , ost - > file_index , ost - > index ) ;
2006-07-06 17:04:46 +02:00
2012-01-17 01:40:45 +01:00
if ( got_packet ) {
if ( pkt . pts ! = AV_NOPTS_VALUE )
pkt . pts = av_rescale_q ( pkt . pts , enc - > time_base , ost - > st - > time_base ) ;
2012-05-19 12:05:02 +02:00
if ( pkt . dts ! = AV_NOPTS_VALUE )
2012-02-07 01:08:32 +01:00
pkt . dts = av_rescale_q ( pkt . dts , enc - > time_base , ost - > st - > time_base ) ;
2012-01-17 01:40:45 +01:00
if ( pkt . duration > 0 )
pkt . duration = av_rescale_q ( pkt . duration , enc - > time_base , ost - > st - > time_base ) ;
2012-05-05 18:22:46 +02:00
if ( debug_ts ) {
av_log ( NULL , AV_LOG_INFO , " encoder -> type:audio "
" pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s \n " ,
av_ts2str ( pkt . pts ) , av_ts2timestr ( pkt . pts , & ost - > st - > time_base ) ,
av_ts2str ( pkt . dts ) , av_ts2timestr ( pkt . dts , & ost - > st - > time_base ) ) ;
}
2012-01-17 01:40:45 +01:00
write_frame ( s , & pkt , ost ) ;
2001-07-22 16:37:44 +02:00
2012-01-17 01:40:45 +01:00
audio_size + = pkt . size ;
2012-01-17 20:55:54 +01:00
av_free_packet ( & pkt ) ;
2012-01-17 01:40:45 +01:00
}
2001-07-22 16:37:44 +02:00
}
2011-06-23 19:14:08 +02:00
static void pre_process_video_frame ( InputStream * ist , AVPicture * picture , void * * bufp )
2002-11-20 04:06:12 +01:00
{
AVCodecContext * dec ;
AVPicture * picture2 ;
AVPicture picture_tmp ;
2003-02-11 17:35:48 +01:00
uint8_t * buf = 0 ;
2002-11-20 04:06:12 +01:00
2005-07-18 00:24:36 +02:00
dec = ist - > st - > codec ;
2002-11-20 04:06:12 +01:00
/* deinterlace : must be done before any resize */
2009-03-03 15:09:10 +01:00
if ( do_deinterlace ) {
2002-11-20 04:06:12 +01:00
int size ;
/* create temporary picture */
size = avpicture_get_size ( dec - > pix_fmt , dec - > width , dec - > height ) ;
2011-12-30 03:46:24 +01:00
buf = av_malloc ( size ) ;
2002-11-20 04:06:12 +01:00
if ( ! buf )
return ;
2005-12-17 19:14:38 +01:00
2002-11-20 04:06:12 +01:00
picture2 = & picture_tmp ;
avpicture_fill ( picture2 , buf , dec - > pix_fmt , dec - > width , dec - > height ) ;
2011-12-30 03:46:24 +01:00
if ( avpicture_deinterlace ( picture2 , picture ,
2009-05-31 22:19:16 +02:00
dec - > pix_fmt , dec - > width , dec - > height ) < 0 ) {
/* if error, do not deinterlace */
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_WARNING , " Deinterlacing failed \n " ) ;
2009-05-31 22:19:16 +02:00
av_free ( buf ) ;
buf = NULL ;
picture2 = picture ;
}
2002-11-20 04:06:12 +01:00
} else {
picture2 = picture ;
}
if ( picture ! = picture2 )
* picture = * picture2 ;
* bufp = buf ;
}
2005-12-17 19:14:38 +01:00
static void do_subtitle_out ( AVFormatContext * s ,
2011-06-23 19:14:08 +02:00
OutputStream * ost ,
InputStream * ist ,
2005-06-03 16:31:45 +02:00
AVSubtitle * sub ,
int64_t pts )
{
2009-08-26 12:22:27 +02:00
int subtitle_out_max_size = 1024 * 1024 ;
2005-06-03 16:31:45 +02:00
int subtitle_out_size , nb , i ;
AVCodecContext * enc ;
AVPacket pkt ;
if ( pts = = AV_NOPTS_VALUE ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_ERROR , " Subtitle packets must have a pts \n " ) ;
2008-09-05 01:23:44 +02:00
if ( exit_on_error )
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2005-06-03 16:31:45 +02:00
return ;
}
2005-07-18 00:24:36 +02:00
enc = ost - > st - > codec ;
2005-06-03 16:31:45 +02:00
if ( ! subtitle_out ) {
subtitle_out = av_malloc ( subtitle_out_max_size ) ;
}
/* Note: DVB subtitle need one packet to draw them and one other
packet to clear them */
/* XXX: signal it in the codec context ? */
if ( enc - > codec_id = = CODEC_ID_DVB_SUBTITLE )
nb = 2 ;
else
nb = 1 ;
2011-12-30 03:46:24 +01:00
for ( i = 0 ; i < nb ; i + + ) {
2012-02-08 23:14:28 +01:00
ost - > sync_opts = av_rescale_q ( pts , ist - > st - > time_base , enc - > time_base ) ;
2012-07-03 20:34:27 +02:00
if ( ! check_recording_time ( ost ) )
return ;
2012-02-08 23:14:28 +01:00
2009-06-19 10:28:07 +02:00
sub - > pts = av_rescale_q ( pts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
2009-08-26 10:43:11 +02:00
// start_display_time is required to be 0
2011-12-30 03:46:24 +01:00
sub - > pts + = av_rescale_q ( sub - > start_display_time , ( AVRational ) { 1 , 1000 } , AV_TIME_BASE_Q ) ;
sub - > end_display_time - = sub - > start_display_time ;
2009-08-26 10:43:11 +02:00
sub - > start_display_time = 0 ;
2005-12-17 19:14:38 +01:00
subtitle_out_size = avcodec_encode_subtitle ( enc , subtitle_out ,
2005-06-03 16:31:45 +02:00
subtitle_out_max_size , sub ) ;
2009-08-15 02:37:31 +02:00
if ( subtitle_out_size < 0 ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Subtitle encoding failed \n " ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2009-08-15 02:37:31 +02:00
}
2005-12-17 19:14:38 +01:00
2005-06-03 16:31:45 +02:00
av_init_packet ( & pkt ) ;
pkt . data = subtitle_out ;
pkt . size = subtitle_out_size ;
2011-12-30 03:46:24 +01:00
pkt . pts = av_rescale_q ( sub - > pts , AV_TIME_BASE_Q , ost - > st - > time_base ) ;
2012-05-31 06:08:01 +02:00
pkt . duration = av_rescale_q ( sub - > end_display_time , ( AVRational ) { 1 , 1000 } , ost - > st - > time_base ) ;
2005-06-03 16:31:45 +02:00
if ( enc - > codec_id = = CODEC_ID_DVB_SUBTITLE ) {
/* XXX: the pts correction is handled here. Maybe handling
it in the codec would be better */
if ( i = = 0 )
pkt . pts + = 90 * sub - > start_display_time ;
else
pkt . pts + = 90 * sub - > end_display_time ;
}
2012-01-02 02:48:34 +01:00
write_frame ( s , & pkt , ost ) ;
2012-06-17 19:50:36 +02:00
subtitle_size + = pkt . size ;
2005-06-03 16:31:45 +02:00
}
}
2012-05-20 12:24:49 +02:00
static void do_video_out ( AVFormatContext * s ,
OutputStream * ost ,
AVFrame * in_picture ,
float quality )
2001-07-22 16:37:44 +02:00
{
2012-05-20 12:24:49 +02:00
int ret , format_video_sync ;
2012-05-20 12:04:09 +02:00
AVPacket pkt ;
2012-05-20 12:24:49 +02:00
AVCodecContext * enc = ost - > st - > codec ;
2012-07-18 16:35:01 +02:00
int nb_frames , i ;
2012-02-06 21:47:41 +01:00
double sync_ipts , delta ;
2011-09-13 05:13:34 +02:00
double duration = 0 ;
2012-02-07 13:22:20 +01:00
int frame_size = 0 ;
2012-04-17 04:01:17 +02:00
InputStream * ist = NULL ;
if ( ost - > source_index > = 0 )
ist = input_streams [ ost - > source_index ] ;
2005-12-17 19:14:38 +01:00
2012-05-09 18:15:03 +02:00
if ( ist & & ist - > st - > start_time ! = AV_NOPTS_VALUE & & ist - > st - > first_dts ! = AV_NOPTS_VALUE & & ost - > frame_rate . num )
duration = 1 / ( av_q2d ( ost - > frame_rate ) * av_q2d ( enc - > time_base ) ) ;
2011-09-13 05:13:34 +02:00
2012-05-20 14:12:48 +02:00
sync_ipts = in_picture - > pts ;
2012-02-27 02:33:48 +01:00
delta = sync_ipts - ost - > sync_opts + duration ;
2010-03-15 03:32:21 +01:00
2002-10-21 19:42:47 +02:00
/* by default, we output a single frame */
nb_frames = 1 ;
2011-08-30 13:42:27 +02:00
format_video_sync = video_sync_method ;
2012-01-05 02:03:12 +01:00
if ( format_video_sync = = VSYNC_AUTO )
format_video_sync = ( s - > oformat - > flags & AVFMT_VARIABLE_FPS ) ? ( ( s - > oformat - > flags & AVFMT_NOTIMESTAMPS ) ? VSYNC_PASSTHROUGH : VSYNC_VFR ) : 1 ;
2011-08-30 13:42:27 +02:00
2012-02-06 21:47:41 +01:00
switch ( format_video_sync ) {
case VSYNC_CFR :
2011-12-30 03:46:24 +01:00
// FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
2012-02-06 21:47:41 +01:00
if ( delta < - 1.1 )
2004-05-29 04:06:32 +02:00
nb_frames = 0 ;
2012-02-06 21:47:41 +01:00
else if ( delta > 1.1 )
nb_frames = lrintf ( delta ) ;
break ;
case VSYNC_VFR :
if ( delta < = - 0.6 )
nb_frames = 0 ;
else if ( delta > 0.6 )
2012-05-10 13:19:10 +02:00
ost - > sync_opts = lrint ( sync_ipts ) ;
2012-02-06 21:47:41 +01:00
break ;
2012-02-27 02:33:48 +01:00
case VSYNC_DROP :
2012-02-06 21:47:41 +01:00
case VSYNC_PASSTHROUGH :
2012-05-10 13:19:10 +02:00
ost - > sync_opts = lrint ( sync_ipts ) ;
2012-02-06 21:47:41 +01:00
break ;
default :
av_assert0 ( 0 ) ;
}
2003-07-12 09:37:05 +02:00
2011-09-05 22:10:26 +02:00
nb_frames = FFMIN ( nb_frames , ost - > max_frames - ost - > frame_number ) ;
2012-02-06 21:47:41 +01:00
if ( nb_frames = = 0 ) {
nb_frames_drop + + ;
av_log ( NULL , AV_LOG_VERBOSE , " *** drop! \n " ) ;
2001-07-22 16:37:44 +02:00
return ;
2012-02-06 21:47:41 +01:00
} else if ( nb_frames > 1 ) {
2012-07-04 03:48:36 +02:00
if ( nb_frames > dts_error_threshold * 30 ) {
av_log ( NULL , AV_LOG_ERROR , " %d frame duplication too large, skiping \n " , nb_frames - 1 ) ;
nb_frames_drop + + ;
return ;
}
2012-02-06 21:47:41 +01:00
nb_frames_dup + = nb_frames - 1 ;
av_log ( NULL , AV_LOG_VERBOSE , " *** %d dup! \n " , nb_frames - 1 ) ;
}
2002-03-19 07:30:41 +01:00
2012-07-18 16:35:01 +02:00
/* duplicates frame if needed */
for ( i = 0 ; i < nb_frames ; i + + ) {
2012-05-20 12:04:09 +02:00
av_init_packet ( & pkt ) ;
pkt . data = NULL ;
pkt . size = 0 ;
2003-12-12 17:56:38 +01:00
2012-05-20 14:11:48 +02:00
in_picture - > pts = ost - > sync_opts ;
2012-07-03 20:34:27 +02:00
if ( ! check_recording_time ( ost ) )
return ;
2012-05-20 12:04:09 +02:00
if ( s - > oformat - > flags & AVFMT_RAWPICTURE & &
enc - > codec - > id = = CODEC_ID_RAWVIDEO ) {
/* raw pictures are written as AVPicture structure to
avoid any copies . We support temporarily the older
method . */
enc - > coded_frame - > interlaced_frame = in_picture - > interlaced_frame ;
enc - > coded_frame - > top_field_first = in_picture - > top_field_first ;
pkt . data = ( uint8_t * ) in_picture ;
pkt . size = sizeof ( AVPicture ) ;
2012-05-20 12:29:33 +02:00
pkt . pts = av_rescale_q ( in_picture - > pts , enc - > time_base , ost - > st - > time_base ) ;
2012-05-20 12:04:09 +02:00
pkt . flags | = AV_PKT_FLAG_KEY ;
write_frame ( s , & pkt , ost ) ;
2012-06-08 16:24:09 +02:00
video_size + = pkt . size ;
2012-05-20 12:04:09 +02:00
} else {
int got_packet ;
AVFrame big_picture ;
big_picture = * in_picture ;
/* better than nothing: use input picture interlaced
settings */
big_picture . interlaced_frame = in_picture - > interlaced_frame ;
if ( ost - > st - > codec - > flags & ( CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME ) ) {
if ( ost - > top_field_first = = - 1 )
big_picture . top_field_first = in_picture - > top_field_first ;
else
big_picture . top_field_first = ! ! ost - > top_field_first ;
}
/* handles same_quant here. This is not correct because it may
not be a global option */
big_picture . quality = quality ;
if ( ! enc - > me_threshold )
big_picture . pict_type = 0 ;
if ( ost - > forced_kf_index < ost - > forced_kf_count & &
big_picture . pts > = ost - > forced_kf_pts [ ost - > forced_kf_index ] ) {
big_picture . pict_type = AV_PICTURE_TYPE_I ;
ost - > forced_kf_index + + ;
}
update_benchmark ( NULL ) ;
ret = avcodec_encode_video2 ( enc , & pkt , & big_picture , & got_packet ) ;
update_benchmark ( " encode_video %d.%d " , ost - > file_index , ost - > index ) ;
if ( ret < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Video encoding failed \n " ) ;
exit_program ( 1 ) ;
}
if ( got_packet ) {
if ( pkt . pts = = AV_NOPTS_VALUE & & ! ( enc - > codec - > capabilities & CODEC_CAP_DELAY ) )
pkt . pts = ost - > sync_opts ;
if ( pkt . pts ! = AV_NOPTS_VALUE )
pkt . pts = av_rescale_q ( pkt . pts , enc - > time_base , ost - > st - > time_base ) ;
if ( pkt . dts ! = AV_NOPTS_VALUE )
pkt . dts = av_rescale_q ( pkt . dts , enc - > time_base , ost - > st - > time_base ) ;
if ( debug_ts ) {
av_log ( NULL , AV_LOG_INFO , " encoder -> type:video "
" pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s \n " ,
av_ts2str ( pkt . pts ) , av_ts2timestr ( pkt . pts , & ost - > st - > time_base ) ,
av_ts2str ( pkt . dts ) , av_ts2timestr ( pkt . dts , & ost - > st - > time_base ) ) ;
2006-09-26 16:04:36 +02:00
}
2009-05-30 04:48:47 +02:00
2012-05-20 12:04:09 +02:00
write_frame ( s , & pkt , ost ) ;
frame_size = pkt . size ;
video_size + = pkt . size ;
av_free_packet ( & pkt ) ;
/* if two pass, output log */
if ( ost - > logfile & & enc - > stats_out ) {
fprintf ( ost - > logfile , " %s " , enc - > stats_out ) ;
2002-10-10 19:09:01 +02:00
}
2001-07-22 16:37:44 +02:00
}
}
2012-05-20 12:04:09 +02:00
ost - > sync_opts + + ;
/*
* For video , number of frames in = = number of packets out .
* But there may be reordering , so we can ' t throw away frames on encoder
* flush , we need to limit them here , before they go into encoder .
*/
ost - > frame_number + + ;
2012-07-18 16:35:01 +02:00
}
2012-05-20 12:04:09 +02:00
2012-02-07 13:22:20 +01:00
if ( vstats_filename & & frame_size )
2012-04-17 04:01:17 +02:00
do_video_stats ( output_files [ ost - > file_index ] - > ctx , ost , frame_size ) ;
2001-07-22 16:37:44 +02:00
}
2012-05-20 12:06:56 +02:00
static double psnr ( double d )
{
return - 10.0 * log ( d ) / log ( 10.0 ) ;
}
static void do_video_stats ( AVFormatContext * os , OutputStream * ost ,
int frame_size )
{
AVCodecContext * enc ;
int frame_number ;
double ti1 , bitrate , avg_bitrate ;
/* this is executed just the first time do_video_stats is called */
if ( ! vstats_file ) {
vstats_file = fopen ( vstats_filename , " w " ) ;
if ( ! vstats_file ) {
perror ( " fopen " ) ;
exit_program ( 1 ) ;
}
}
enc = ost - > st - > codec ;
if ( enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
frame_number = ost - > frame_number ;
fprintf ( vstats_file , " frame= %5d q= %2.1f " , frame_number , enc - > coded_frame - > quality / ( float ) FF_QP2LAMBDA ) ;
if ( enc - > flags & CODEC_FLAG_PSNR )
fprintf ( vstats_file , " PSNR= %6.2f " , psnr ( enc - > coded_frame - > error [ 0 ] / ( enc - > width * enc - > height * 255.0 * 255.0 ) ) ) ;
fprintf ( vstats_file , " f_size= %6d " , frame_size ) ;
/* compute pts value */
ti1 = ost - > sync_opts * av_q2d ( enc - > time_base ) ;
if ( ti1 < 0.01 )
ti1 = 0.01 ;
bitrate = ( frame_size * 8 ) / av_q2d ( enc - > time_base ) / 1000.0 ;
avg_bitrate = ( double ) ( video_size * 8 ) / ti1 / 1000.0 ;
fprintf ( vstats_file , " s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s " ,
( double ) video_size / 1024 , ti1 , bitrate , avg_bitrate ) ;
fprintf ( vstats_file , " type= %c \n " , av_get_picture_type_char ( enc - > coded_frame - > pict_type ) ) ;
}
}
2012-03-29 08:51:17 +02:00
/* check for new output on any of the filtergraphs */
static int poll_filters ( void )
{
AVFilterBufferRef * picref ;
AVFrame * filtered_frame = NULL ;
2012-04-19 18:44:55 +02:00
int i , ret , ret_all ;
2012-07-17 18:02:33 +02:00
unsigned nb_success = 1 , av_uninit ( nb_eof ) ;
2012-05-14 15:10:23 +02:00
int64_t frame_pts ;
2012-03-29 08:51:17 +02:00
2012-04-19 18:44:55 +02:00
while ( 1 ) {
/* Reap all buffers present in the buffer sinks */
2012-05-03 20:01:23 +02:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
OutputStream * ost = output_streams [ i ] ;
OutputFile * of = output_files [ ost - > file_index ] ;
2012-05-05 18:22:46 +02:00
int ret = 0 ;
2012-05-03 20:01:23 +02:00
2012-06-04 22:54:15 +02:00
if ( ! ost - > filter )
2012-05-03 20:01:23 +02:00
continue ;
if ( ! ost - > filtered_frame & & ! ( ost - > filtered_frame = avcodec_alloc_frame ( ) ) ) {
return AVERROR ( ENOMEM ) ;
} else
avcodec_get_frame_defaults ( ost - > filtered_frame ) ;
filtered_frame = ost - > filtered_frame ;
2012-07-05 21:00:00 +02:00
while ( 1 ) {
2012-06-25 00:32:49 +02:00
ret = av_buffersink_get_buffer_ref ( ost - > filter - > filter , & picref ,
AV_BUFFERSINK_FLAG_NO_REQUEST ) ;
2012-05-03 20:01:23 +02:00
if ( ret < 0 ) {
2012-05-17 16:28:19 +02:00
if ( ret ! = AVERROR ( EAGAIN ) & & ret ! = AVERROR_EOF ) {
2012-05-03 20:01:23 +02:00
char buf [ 256 ] ;
av_strerror ( ret , buf , sizeof ( buf ) ) ;
av_log ( NULL , AV_LOG_WARNING ,
" Error in av_buffersink_get_buffer_ref(): %s \n " , buf ) ;
}
break ;
}
2012-05-20 11:30:51 +02:00
frame_pts = AV_NOPTS_VALUE ;
2012-05-20 14:12:48 +02:00
if ( picref - > pts ! = AV_NOPTS_VALUE ) {
2012-05-05 18:22:46 +02:00
filtered_frame - > pts = frame_pts = av_rescale_q ( picref - > pts ,
ost - > filter - > filter - > inputs [ 0 ] - > time_base ,
ost - > st - > codec - > time_base ) -
av_rescale_q ( of - > start_time ,
AV_TIME_BASE_Q ,
ost - > st - > codec - > time_base ) ;
2012-05-20 14:12:48 +02:00
if ( of - > start_time & & filtered_frame - > pts < 0 ) {
avfilter_unref_buffer ( picref ) ;
continue ;
}
}
2012-05-03 20:01:23 +02:00
//if (ost->source_index >= 0)
// *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
switch ( ost - > filter - > filter - > inputs [ 0 ] - > type ) {
case AVMEDIA_TYPE_VIDEO :
2012-06-22 11:56:55 +02:00
avfilter_copy_buf_props ( filtered_frame , picref ) ;
2012-05-14 15:10:23 +02:00
filtered_frame - > pts = frame_pts ;
2012-05-03 20:01:23 +02:00
if ( ! ost - > frame_aspect_ratio )
ost - > st - > codec - > sample_aspect_ratio = picref - > video - > sample_aspect_ratio ;
do_video_out ( of - > ctx , ost , filtered_frame ,
same_quant ? ost - > last_quality :
ost - > st - > codec - > global_quality ) ;
break ;
2012-05-05 18:22:46 +02:00
case AVMEDIA_TYPE_AUDIO :
avfilter_copy_buf_props ( filtered_frame , picref ) ;
filtered_frame - > pts = frame_pts ;
do_audio_out ( of - > ctx , ost , filtered_frame ) ;
break ;
2012-05-03 20:01:23 +02:00
default :
2012-05-05 18:22:46 +02:00
// TODO support subtitle filters
2012-05-03 20:01:23 +02:00
av_assert0 ( 0 ) ;
2012-04-19 18:44:55 +02:00
}
2012-03-29 08:51:17 +02:00
2012-05-03 20:01:23 +02:00
avfilter_unref_buffer ( picref ) ;
}
2012-03-29 08:51:17 +02:00
}
2012-07-17 18:02:33 +02:00
if ( ! nb_success ) /* from last round */
break ;
2012-04-19 18:44:55 +02:00
/* Request frames through all the graphs */
ret_all = nb_success = nb_eof = 0 ;
for ( i = 0 ; i < nb_filtergraphs ; i + + ) {
ret = avfilter_graph_request_oldest ( filtergraphs [ i ] - > graph ) ;
if ( ! ret ) {
nb_success + + ;
} else if ( ret = = AVERROR_EOF ) {
nb_eof + + ;
} else if ( ret ! = AVERROR ( EAGAIN ) ) {
char buf [ 256 ] ;
av_strerror ( ret , buf , sizeof ( buf ) ) ;
av_log ( NULL , AV_LOG_WARNING ,
" Error in request_frame(): %s \n " , buf ) ;
ret_all = ret ;
}
}
/* Try again if anything succeeded */
}
return nb_eof = = nb_filtergraphs ? AVERROR_EOF : ret_all ;
2012-03-29 08:51:17 +02:00
}
2012-04-17 04:01:17 +02:00
static void print_report ( int is_last_report , int64_t timer_start , int64_t cur_time )
2002-10-21 19:42:47 +02:00
{
char buf [ 1024 ] ;
2012-07-08 13:03:39 +02:00
AVBPrint buf_script ;
2011-06-23 19:14:08 +02:00
OutputStream * ost ;
2009-04-17 17:15:25 +02:00
AVFormatContext * oc ;
2003-02-11 17:35:48 +01:00
int64_t total_size ;
2002-10-21 19:42:47 +02:00
AVCodecContext * enc ;
int frame_number , vid , i ;
2011-06-03 00:28:52 +02:00
double bitrate ;
int64_t pts = INT64_MAX ;
2003-02-11 17:35:48 +01:00
static int64_t last_time = - 1 ;
2005-12-18 21:01:02 +01:00
static int qp_histogram [ 52 ] ;
2011-09-27 02:14:37 +02:00
int hours , mins , secs , us ;
2005-12-17 19:14:38 +01:00
2012-07-08 13:03:39 +02:00
if ( ! print_stats & & ! is_last_report & & ! progress_avio )
2011-10-10 03:41:49 +02:00
return ;
2005-12-17 19:14:38 +01:00
2002-10-21 19:42:47 +02:00
if ( ! is_last_report ) {
if ( last_time = = - 1 ) {
last_time = cur_time ;
return ;
2005-12-17 19:14:38 +01:00
}
2002-10-21 19:42:47 +02:00
if ( ( cur_time - last_time ) < 500000 )
return ;
last_time = cur_time ;
}
2002-03-19 07:30:41 +01:00
2012-04-15 15:28:30 +02:00
oc = output_files [ 0 ] - > ctx ;
2002-10-21 19:42:47 +02:00
2011-03-04 19:57:36 +01:00
total_size = avio_size ( oc - > pb ) ;
2011-11-29 17:59:40 +01:00
if ( total_size < 0 ) { // FIXME improve avio_size() so it works with non seekable output too
2011-12-30 03:46:24 +01:00
total_size = avio_tell ( oc - > pb ) ;
2011-11-29 17:59:40 +01:00
if ( total_size < 0 )
total_size = 0 ;
}
2005-12-17 19:14:38 +01:00
2002-10-21 19:42:47 +02:00
buf [ 0 ] = ' \0 ' ;
vid = 0 ;
2012-07-08 13:03:39 +02:00
av_bprint_init ( & buf_script , 0 , 1 ) ;
2012-04-15 15:03:07 +02:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2011-04-06 21:17:32 +02:00
float q = - 1 ;
2012-04-15 15:28:30 +02:00
ost = output_streams [ i ] ;
2005-07-18 00:24:36 +02:00
enc = ost - > st - > codec ;
2011-10-26 02:09:31 +02:00
if ( ! ost - > stream_copy & & enc - > coded_frame )
2011-12-30 03:46:24 +01:00
q = enc - > coded_frame - > quality / ( float ) FF_QP2LAMBDA ;
2010-03-31 01:30:55 +02:00
if ( vid & & enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2011-04-06 21:17:32 +02:00
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " q=%2.1f " , q ) ;
2012-07-08 13:03:39 +02:00
av_bprintf ( & buf_script , " stream_%d_%d_q=%.1f \n " ,
ost - > file_index , ost - > index , q ) ;
2002-11-20 04:06:12 +01:00
}
2010-03-31 01:30:55 +02:00
if ( ! vid & & enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2012-03-07 23:26:29 +01:00
float fps , t = ( cur_time - timer_start ) / 1000000.0 ;
2007-03-16 17:13:54 +01:00
2002-10-21 19:42:47 +02:00
frame_number = ost - > frame_number ;
2012-03-07 23:26:29 +01:00
fps = t > 1 ? frame_number / t : 0 ;
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " frame=%5d fps=%3.*f q=%3.1f " ,
frame_number , fps < 9.95 , fps , q ) ;
2012-07-08 13:03:39 +02:00
av_bprintf ( & buf_script , " frame=%d \n " , frame_number ) ;
av_bprintf ( & buf_script , " fps=%.1f \n " , fps ) ;
av_bprintf ( & buf_script , " stream_%d_%d_q=%.1f \n " ,
ost - > file_index , ost - > index , q ) ;
2011-12-30 03:46:24 +01:00
if ( is_last_report )
2005-01-12 01:16:25 +01:00
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " L " ) ;
2011-12-30 03:46:24 +01:00
if ( qp_hist ) {
2005-12-18 21:01:02 +01:00
int j ;
2011-04-06 21:17:32 +02:00
int qp = lrintf ( q ) ;
2011-12-30 03:46:24 +01:00
if ( qp > = 0 & & qp < FF_ARRAY_ELEMS ( qp_histogram ) )
2005-12-18 21:01:02 +01:00
qp_histogram [ qp ] + + ;
2011-12-30 03:46:24 +01:00
for ( j = 0 ; j < 32 ; j + + )
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " %X " , ( int ) lrintf ( log ( qp_histogram [ j ] + 1 ) / log ( 2 ) ) ) ;
2005-12-18 21:01:02 +01:00
}
2011-12-30 03:46:24 +01:00
if ( enc - > flags & CODEC_FLAG_PSNR ) {
2003-12-30 00:08:30 +01:00
int j ;
2011-12-30 03:46:24 +01:00
double error , error_sum = 0 ;
double scale , scale_sum = 0 ;
2012-07-08 13:03:39 +02:00
double p ;
2011-12-30 03:46:24 +01:00
char type [ 3 ] = { ' Y ' , ' U ' , ' V ' } ;
2005-01-12 01:16:25 +01:00
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " PSNR= " ) ;
2011-12-30 03:46:24 +01:00
for ( j = 0 ; j < 3 ; j + + ) {
if ( is_last_report ) {
error = enc - > error [ j ] ;
scale = enc - > width * enc - > height * 255.0 * 255.0 * frame_number ;
} else {
error = enc - > coded_frame - > error [ j ] ;
scale = enc - > width * enc - > height * 255.0 * 255.0 ;
2003-12-30 00:08:30 +01:00
}
2011-12-30 03:46:24 +01:00
if ( j )
scale / = 4 ;
2003-12-30 00:08:30 +01:00
error_sum + = error ;
scale_sum + = scale ;
2012-07-08 13:03:39 +02:00
p = psnr ( error / scale ) ;
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " %c:%2.2f " , type [ j ] , p ) ;
av_bprintf ( & buf_script , " stream_%d_%d_psnr_%c=%2.2f \n " ,
ost - > file_index , ost - > index , type [ i ] | 32 , p ) ;
2003-12-30 00:08:30 +01:00
}
2012-07-08 13:03:39 +02:00
p = psnr ( error_sum / scale_sum ) ;
2011-12-30 03:46:24 +01:00
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " *:%2.2f " , psnr ( error_sum / scale_sum ) ) ;
2012-07-08 13:03:39 +02:00
av_bprintf ( & buf_script , " stream_%d_%d_psnr_all=%2.2f \n " ,
ost - > file_index , ost - > index , p ) ;
2003-12-30 00:08:30 +01:00
}
2002-10-21 19:42:47 +02:00
vid = 1 ;
}
/* compute min output value */
2011-06-03 00:28:52 +02:00
pts = FFMIN ( pts , av_rescale_q ( ost - > st - > pts . val ,
ost - > st - > time_base , AV_TIME_BASE_Q ) ) ;
2002-10-21 19:42:47 +02:00
}
2005-12-17 19:14:38 +01:00
2011-09-27 02:14:37 +02:00
secs = pts / AV_TIME_BASE ;
us = pts % AV_TIME_BASE ;
mins = secs / 60 ;
secs % = 60 ;
hours = mins / 60 ;
mins % = 60 ;
2005-12-17 19:14:38 +01:00
2011-09-27 02:14:37 +02:00
bitrate = pts ? total_size * 8 / ( pts / 1000.0 ) : 0 ;
2004-06-12 00:03:16 +02:00
2011-09-27 02:14:37 +02:00
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) ,
" size=%8.0fkB time= " , total_size / 1024.0 ) ;
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) ,
" %02d:%02d:%02d.%02d " , hours , mins , secs ,
( 100 * us ) / AV_TIME_BASE ) ;
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) ,
" bitrate=%6.1fkbits/s " , bitrate ) ;
2012-07-08 13:03:39 +02:00
av_bprintf ( & buf_script , " total_size=% " PRId64 " \n " , total_size ) ;
av_bprintf ( & buf_script , " out_time_ms=% " PRId64 " \n " , pts ) ;
av_bprintf ( & buf_script , " out_time=%02d:%02d:%02d.%06d \n " ,
hours , mins , secs , us ) ;
2005-12-17 19:14:38 +01:00
2011-09-27 02:14:37 +02:00
if ( nb_frames_dup | | nb_frames_drop )
snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , " dup=%d drop=%d " ,
nb_frames_dup , nb_frames_drop ) ;
2012-07-08 13:03:39 +02:00
av_bprintf ( & buf_script , " dup_frames=%d \n " , nb_frames_dup ) ;
av_bprintf ( & buf_script , " drop_frames=%d \n " , nb_frames_drop ) ;
2005-12-17 19:14:38 +01:00
2012-07-08 13:03:39 +02:00
if ( print_stats | | is_last_report ) {
2011-10-10 03:41:49 +02:00
av_log ( NULL , AV_LOG_INFO , " %s \r " , buf ) ;
2011-09-27 02:14:37 +02:00
fflush ( stderr ) ;
2012-07-08 13:03:39 +02:00
}
if ( progress_avio ) {
av_bprintf ( & buf_script , " progress=%s \n " ,
is_last_report ? " end " : " continue " ) ;
avio_write ( progress_avio , buf_script . str ,
FFMIN ( buf_script . len , buf_script . size - 1 ) ) ;
avio_flush ( progress_avio ) ;
av_bprint_finalize ( & buf_script , NULL ) ;
if ( is_last_report ) {
avio_close ( progress_avio ) ;
progress_avio = NULL ;
}
}
2005-12-17 19:14:38 +01:00
2011-09-27 02:14:37 +02:00
if ( is_last_report ) {
2012-06-17 19:50:36 +02:00
int64_t raw = audio_size + video_size + subtitle_size + extra_size ;
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
2012-06-17 19:50:36 +02:00
av_log ( NULL , AV_LOG_INFO , " video:%1.0fkB audio:%1.0fkB subtitle:%1.0f global headers:%1.0fkB muxing overhead %f%% \n " ,
2011-12-30 03:46:24 +01:00
video_size / 1024.0 ,
audio_size / 1024.0 ,
2012-06-17 19:50:36 +02:00
subtitle_size / 1024.0 ,
2011-12-30 03:46:24 +01:00
extra_size / 1024.0 ,
100.0 * ( total_size - raw ) / raw
2004-04-15 15:57:55 +02:00
) ;
2012-06-17 19:50:36 +02:00
if ( video_size + audio_size + subtitle_size + extra_size = = 0 ) {
2011-11-25 16:17:06 +01:00
av_log ( NULL , AV_LOG_WARNING , " Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used) \n " ) ;
}
2004-04-15 15:57:55 +02:00
}
2002-03-19 07:30:41 +01:00
}
2012-04-15 15:03:07 +02:00
static void flush_encoders ( void )
2011-08-30 15:55:25 +02:00
{
int i , ret ;
2012-04-15 15:03:07 +02:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
OutputStream * ost = output_streams [ i ] ;
2011-08-30 15:56:03 +02:00
AVCodecContext * enc = ost - > st - > codec ;
2012-04-15 15:28:30 +02:00
AVFormatContext * os = output_files [ ost - > file_index ] - > ctx ;
2012-01-17 01:40:45 +01:00
int stop_encoding = 0 ;
2011-08-30 15:56:03 +02:00
2011-08-30 16:00:47 +02:00
if ( ! ost - > encoding_needed )
2011-08-30 15:56:03 +02:00
continue ;
2011-12-30 03:46:24 +01:00
if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO & & enc - > frame_size < = 1 )
2011-08-30 15:56:03 +02:00
continue ;
2011-12-03 02:08:55 +01:00
if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & & ( os - > oformat - > flags & AVFMT_RAWPICTURE ) & & enc - > codec - > id = = CODEC_ID_RAWVIDEO )
2011-08-30 15:56:03 +02:00
continue ;
2011-12-30 03:46:24 +01:00
for ( ; ; ) {
2012-05-05 18:22:46 +02:00
int ( * encode ) ( AVCodecContext * , AVPacket * , const AVFrame * , int * ) = NULL ;
const char * desc ;
int64_t * size ;
2011-08-30 15:56:03 +02:00
switch ( ost - > st - > codec - > codec_type ) {
case AVMEDIA_TYPE_AUDIO :
2012-05-05 18:22:46 +02:00
encode = avcodec_encode_audio2 ;
desc = " Audio " ;
size = & audio_size ;
2011-08-30 15:56:03 +02:00
break ;
case AVMEDIA_TYPE_VIDEO :
2012-05-05 18:22:46 +02:00
encode = avcodec_encode_video2 ;
desc = " Video " ;
size = & video_size ;
break ;
default :
stop_encoding = 1 ;
}
if ( encode ) {
AVPacket pkt ;
int got_packet ;
av_init_packet ( & pkt ) ;
pkt . data = NULL ;
pkt . size = 0 ;
2012-04-11 19:26:09 +02:00
update_benchmark ( NULL ) ;
2012-05-05 18:22:46 +02:00
ret = encode ( enc , & pkt , NULL , & got_packet ) ;
update_benchmark ( " flush %s %d.%d " , desc , ost - > file_index , ost - > index ) ;
2011-08-30 15:56:03 +02:00
if ( ret < 0 ) {
2012-05-05 18:22:46 +02:00
av_log ( NULL , AV_LOG_FATAL , " %s encoding failed \n " , desc ) ;
2011-08-30 15:56:03 +02:00
exit_program ( 1 ) ;
}
2012-05-05 18:22:46 +02:00
* size + = pkt . size ;
2011-08-30 15:56:03 +02:00
if ( ost - > logfile & & enc - > stats_out ) {
fprintf ( ost - > logfile , " %s " , enc - > stats_out ) ;
}
2012-02-01 10:51:36 +01:00
if ( ! got_packet ) {
2012-01-17 01:40:45 +01:00
stop_encoding = 1 ;
break ;
2005-03-23 02:59:17 +01:00
}
2012-02-01 10:51:36 +01:00
if ( pkt . pts ! = AV_NOPTS_VALUE )
pkt . pts = av_rescale_q ( pkt . pts , enc - > time_base , ost - > st - > time_base ) ;
if ( pkt . dts ! = AV_NOPTS_VALUE )
pkt . dts = av_rescale_q ( pkt . dts , enc - > time_base , ost - > st - > time_base ) ;
2012-01-17 01:40:45 +01:00
write_frame ( os , & pkt , ost ) ;
2011-08-30 15:55:25 +02:00
}
2012-05-05 18:22:46 +02:00
2012-01-17 01:40:45 +01:00
if ( stop_encoding )
2011-08-30 15:56:03 +02:00
break ;
2011-08-30 15:55:25 +02:00
}
}
}
2011-11-23 04:02:17 +01:00
/*
* Check whether a packet from ist should be written into ost at this time
*/
static int check_output_constraints ( InputStream * ist , OutputStream * ost )
{
2012-04-15 15:28:30 +02:00
OutputFile * of = output_files [ ost - > file_index ] ;
int ist_index = input_files [ ist - > file_index ] - > ist_index + ist - > st - > index ;
2011-11-23 04:02:17 +01:00
if ( ost - > source_index ! = ist_index )
return 0 ;
if ( of - > start_time & & ist - > pts < of - > start_time )
return 0 ;
return 1 ;
}
static void do_streamcopy ( InputStream * ist , OutputStream * ost , const AVPacket * pkt )
{
2012-04-15 15:28:30 +02:00
OutputFile * of = output_files [ ost - > file_index ] ;
2011-11-23 04:02:17 +01:00
int64_t ost_tb_start_time = av_rescale_q ( of - > start_time , AV_TIME_BASE_Q , ost - > st - > time_base ) ;
AVPicture pict ;
AVPacket opkt ;
av_init_packet ( & opkt ) ;
if ( ( ! ost - > frame_number & & ! ( pkt - > flags & AV_PKT_FLAG_KEY ) ) & &
! ost - > copy_initial_nonkeyframes )
return ;
2012-07-03 20:34:27 +02:00
if ( of - > recording_time ! = INT64_MAX & &
ist - > pts > = of - > recording_time + of - > start_time ) {
ost - > is_past_recording_time = 1 ;
return ;
}
2011-11-23 04:02:17 +01:00
/* force the input stream PTS */
if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO )
audio_size + = pkt - > size ;
else if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
video_size + = pkt - > size ;
ost - > sync_opts + + ;
2012-06-17 19:50:36 +02:00
} else if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
subtitle_size + = pkt - > size ;
2011-11-23 04:02:17 +01:00
}
if ( pkt - > pts ! = AV_NOPTS_VALUE )
opkt . pts = av_rescale_q ( pkt - > pts , ist - > st - > time_base , ost - > st - > time_base ) - ost_tb_start_time ;
else
opkt . pts = AV_NOPTS_VALUE ;
if ( pkt - > dts = = AV_NOPTS_VALUE )
2012-02-08 17:25:01 +01:00
opkt . dts = av_rescale_q ( ist - > dts , AV_TIME_BASE_Q , ost - > st - > time_base ) ;
2011-11-23 04:02:17 +01:00
else
opkt . dts = av_rescale_q ( pkt - > dts , ist - > st - > time_base , ost - > st - > time_base ) ;
opkt . dts - = ost_tb_start_time ;
opkt . duration = av_rescale_q ( pkt - > duration , ist - > st - > time_base , ost - > st - > time_base ) ;
opkt . flags = pkt - > flags ;
2011-12-30 03:46:24 +01:00
// FIXME remove the following 2 lines they shall be replaced by the bitstream filters
if ( ost - > st - > codec - > codec_id ! = CODEC_ID_H264
2011-11-23 04:02:17 +01:00
& & ost - > st - > codec - > codec_id ! = CODEC_ID_MPEG1VIDEO
& & ost - > st - > codec - > codec_id ! = CODEC_ID_MPEG2VIDEO
2012-01-23 12:06:07 +01:00
& & ost - > st - > codec - > codec_id ! = CODEC_ID_VC1
2011-11-23 04:02:17 +01:00
) {
if ( av_parser_change ( ist - > st - > parser , ost - > st - > codec , & opkt . data , & opkt . size , pkt - > data , pkt - > size , pkt - > flags & AV_PKT_FLAG_KEY ) )
opkt . destruct = av_destruct_packet ;
} else {
opkt . data = pkt - > data ;
opkt . size = pkt - > size ;
}
if ( of - > ctx - > oformat - > flags & AVFMT_RAWPICTURE ) {
/* store AVPicture in AVPacket, as expected by the output format */
avpicture_fill ( & pict , opkt . data , ost - > st - > codec - > pix_fmt , ost - > st - > codec - > width , ost - > st - > codec - > height ) ;
opkt . data = ( uint8_t * ) & pict ;
opkt . size = sizeof ( AVPicture ) ;
opkt . flags | = AV_PKT_FLAG_KEY ;
}
2012-01-02 02:48:34 +01:00
write_frame ( of - > ctx , & opkt , ost ) ;
2011-11-23 04:02:17 +01:00
ost - > st - > codec - > frame_number + + ;
av_free_packet ( & opkt ) ;
}
static void rate_emu_sleep ( InputStream * ist )
{
2012-04-15 15:28:30 +02:00
if ( input_files [ ist - > file_index ] - > rate_emu ) {
2012-02-08 17:25:40 +01:00
int64_t pts = av_rescale ( ist - > dts , 1000000 , AV_TIME_BASE ) ;
2011-11-23 04:02:17 +01:00
int64_t now = av_gettime ( ) - ist - > start ;
if ( pts > now )
2012-06-21 21:31:44 +02:00
av_usleep ( pts - now ) ;
2011-11-23 04:02:17 +01:00
}
}
2012-05-05 18:22:46 +02:00
static int guess_input_channel_layout ( InputStream * ist )
{
AVCodecContext * dec = ist - > st - > codec ;
if ( ! dec - > channel_layout ) {
char layout_name [ 256 ] ;
dec - > channel_layout = av_get_default_channel_layout ( dec - > channels ) ;
if ( ! dec - > channel_layout )
return 0 ;
av_get_channel_layout_string ( layout_name , sizeof ( layout_name ) ,
dec - > channels , dec - > channel_layout ) ;
av_log ( NULL , AV_LOG_WARNING , " Guessed Channel Layout for Input Stream "
" #%d.%d : %s \n " , ist - > file_index , ist - > st - > index , layout_name ) ;
}
return 1 ;
}
2012-05-18 12:46:11 +02:00
static int decode_audio ( InputStream * ist , AVPacket * pkt , int * got_output )
2011-11-23 04:02:17 +01:00
{
2011-12-06 01:37:27 +01:00
AVFrame * decoded_frame ;
AVCodecContext * avctx = ist - > st - > codec ;
2012-05-05 18:22:46 +02:00
int i , ret , resample_changed ;
2012-07-26 17:56:52 +02:00
AVRational decoded_frame_tb ;
2011-11-23 04:02:17 +01:00
2011-12-06 01:37:27 +01:00
if ( ! ist - > decoded_frame & & ! ( ist - > decoded_frame = avcodec_alloc_frame ( ) ) )
return AVERROR ( ENOMEM ) ;
else
avcodec_get_frame_defaults ( ist - > decoded_frame ) ;
decoded_frame = ist - > decoded_frame ;
2011-11-23 04:02:17 +01:00
2012-04-11 19:26:09 +02:00
update_benchmark ( NULL ) ;
2011-12-06 01:37:27 +01:00
ret = avcodec_decode_audio4 ( avctx , decoded_frame , got_output , pkt ) ;
2012-04-11 19:26:09 +02:00
update_benchmark ( " decode_audio %d.%d " , ist - > file_index , ist - > st - > index ) ;
2011-12-06 01:37:27 +01:00
if ( ret < 0 ) {
2011-11-23 04:02:17 +01:00
return ret ;
2011-12-06 01:37:27 +01:00
}
2012-03-23 10:59:03 +01:00
if ( avctx - > sample_rate < = 0 ) {
av_log ( avctx , AV_LOG_ERROR , " Sample rate %d invalid \n " , avctx - > sample_rate ) ;
return AVERROR_INVALIDDATA ;
}
2011-11-23 04:02:17 +01:00
if ( ! * got_output ) {
/* no audio frame */
2012-05-05 18:22:46 +02:00
if ( ! pkt - > size )
for ( i = 0 ; i < ist - > nb_filters ; i + + )
2012-05-18 13:59:48 +02:00
av_buffersrc_add_ref ( ist - > filters [ i ] - > filter , NULL ,
AV_BUFFERSRC_FLAG_NO_COPY ) ;
2011-11-24 02:08:21 +01:00
return ret ;
2011-11-23 04:02:17 +01:00
}
2012-05-05 18:22:46 +02:00
# if 1
2012-02-08 16:28:56 +01:00
/* increment next_dts to use for the case where the input stream does not
2011-12-06 01:37:27 +01:00
have timestamps or there are multiple frames in the packet */
ist - > next_pts + = ( ( int64_t ) AV_TIME_BASE * decoded_frame - > nb_samples ) /
avctx - > sample_rate ;
2012-02-08 16:28:56 +01:00
ist - > next_dts + = ( ( int64_t ) AV_TIME_BASE * decoded_frame - > nb_samples ) /
avctx - > sample_rate ;
2012-05-05 18:22:46 +02:00
# endif
2011-11-23 04:02:17 +01:00
rate_emu_sleep ( ist ) ;
2012-05-05 18:22:46 +02:00
resample_changed = ist - > resample_sample_fmt ! = decoded_frame - > format | |
ist - > resample_channels ! = avctx - > channels | |
ist - > resample_channel_layout ! = decoded_frame - > channel_layout | |
ist - > resample_sample_rate ! = decoded_frame - > sample_rate ;
if ( resample_changed ) {
char layout1 [ 64 ] , layout2 [ 64 ] ;
2011-11-23 04:02:17 +01:00
2012-05-05 18:22:46 +02:00
if ( ! guess_input_channel_layout ( ist ) ) {
av_log ( NULL , AV_LOG_FATAL , " Unable to find default channel "
" layout for Input Stream #%d.%d \n " , ist - > file_index ,
ist - > st - > index ) ;
exit_program ( 1 ) ;
}
decoded_frame - > channel_layout = avctx - > channel_layout ;
av_get_channel_layout_string ( layout1 , sizeof ( layout1 ) , ist - > resample_channels ,
ist - > resample_channel_layout ) ;
av_get_channel_layout_string ( layout2 , sizeof ( layout2 ) , avctx - > channels ,
decoded_frame - > channel_layout ) ;
av_log ( NULL , AV_LOG_INFO ,
" Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s \n " ,
ist - > file_index , ist - > st - > index ,
ist - > resample_sample_rate , av_get_sample_fmt_name ( ist - > resample_sample_fmt ) ,
ist - > resample_channels , layout1 ,
decoded_frame - > sample_rate , av_get_sample_fmt_name ( decoded_frame - > format ) ,
avctx - > channels , layout2 ) ;
ist - > resample_sample_fmt = decoded_frame - > format ;
ist - > resample_sample_rate = decoded_frame - > sample_rate ;
ist - > resample_channel_layout = decoded_frame - > channel_layout ;
ist - > resample_channels = avctx - > channels ;
for ( i = 0 ; i < nb_filtergraphs ; i + + )
2012-06-30 21:33:48 +02:00
if ( ist_in_filtergraph ( filtergraphs [ i ] , ist ) ) {
FilterGraph * fg = filtergraphs [ i ] ;
int j ;
if ( configure_filtergraph ( fg ) < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Error reinitializing filters! \n " ) ;
exit_program ( 1 ) ;
}
for ( j = 0 ; j < fg - > nb_outputs ; j + + ) {
OutputStream * ost = fg - > outputs [ j ] - > ost ;
if ( ost - > enc - > type = = AVMEDIA_TYPE_AUDIO & &
! ( ost - > enc - > capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE ) )
av_buffersink_set_frame_size ( ost - > filter - > filter ,
ost - > st - > codec - > frame_size ) ;
}
2012-05-05 18:22:46 +02:00
}
}
2012-07-26 17:57:36 +02:00
/* if the decoder provides a pts, use it instead of the last packet pts.
the decoder could be delaying output by a packet or more . */
if ( decoded_frame - > pts ! = AV_NOPTS_VALUE ) {
ist - > dts = ist - > next_dts = ist - > pts = ist - > next_pts = av_rescale_q ( decoded_frame - > pts , avctx - > time_base , AV_TIME_BASE_Q ) ;
decoded_frame_tb = avctx - > time_base ;
} else if ( decoded_frame - > pkt_pts ! = AV_NOPTS_VALUE ) {
decoded_frame - > pts = decoded_frame - > pkt_pts ;
pkt - > pts = AV_NOPTS_VALUE ;
decoded_frame_tb = ist - > st - > time_base ;
} else if ( pkt - > pts ! = AV_NOPTS_VALUE ) {
decoded_frame - > pts = pkt - > pts ;
pkt - > pts = AV_NOPTS_VALUE ;
decoded_frame_tb = ist - > st - > time_base ;
} else {
decoded_frame - > pts = ist - > dts ;
decoded_frame_tb = AV_TIME_BASE_Q ;
}
avconv: Set audio filter time base to the sample rate
If the output frame size is smaller than the input sample rate,
and the input stream time base corresponds exactly to the input
frame size (getting input packet timestamps like 0, 1, 2, 3, 4 etc),
the output timestamps from the filter will be like
0, 1, 2, 3, 4, 4, 5 ..., leadning to non-monotone timestamps later.
A concrete example is input mp3 data having frame sizes of 1152
samples, transcoded to aac with 1024 sample frames.
By setting the audio filter time base to the sample rate, we will
get sensible timestamps for all output packets, regardless of
the ratio between the input and output frame sizes.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-06-30 10:26:11 +02:00
if ( decoded_frame - > pts ! = AV_NOPTS_VALUE )
decoded_frame - > pts = av_rescale_q ( decoded_frame - > pts ,
2012-07-26 17:56:52 +02:00
decoded_frame_tb ,
avconv: Set audio filter time base to the sample rate
If the output frame size is smaller than the input sample rate,
and the input stream time base corresponds exactly to the input
frame size (getting input packet timestamps like 0, 1, 2, 3, 4 etc),
the output timestamps from the filter will be like
0, 1, 2, 3, 4, 4, 5 ..., leadning to non-monotone timestamps later.
A concrete example is input mp3 data having frame sizes of 1152
samples, transcoded to aac with 1024 sample frames.
By setting the audio filter time base to the sample rate, we will
get sensible timestamps for all output packets, regardless of
the ratio between the input and output frame sizes.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-06-30 10:26:11 +02:00
( AVRational ) { 1 , ist - > st - > codec - > sample_rate } ) ;
2012-05-18 13:59:48 +02:00
for ( i = 0 ; i < ist - > nb_filters ; i + + )
2012-05-17 17:15:47 +02:00
av_buffersrc_add_frame ( ist - > filters [ i ] - > filter , decoded_frame , 0 ) ;
2011-12-06 01:37:27 +01:00
2012-07-26 17:51:56 +02:00
decoded_frame - > pts = AV_NOPTS_VALUE ;
2011-11-24 02:08:21 +01:00
return ret ;
2011-11-23 04:02:17 +01:00
}
2012-05-18 12:46:11 +02:00
static int decode_video ( InputStream * ist , AVPacket * pkt , int * got_output )
2011-11-23 04:02:17 +01:00
{
2012-02-07 11:49:53 +01:00
AVFrame * decoded_frame ;
2011-11-23 04:02:17 +01:00
void * buffer_to_free = NULL ;
2012-03-29 07:40:26 +02:00
int i , ret = 0 , resample_changed ;
2012-04-29 11:16:03 +02:00
int64_t best_effort_timestamp ;
2011-12-03 21:20:50 +01:00
AVRational * frame_sample_aspect ;
2011-11-21 14:39:22 +01:00
float quality ;
2009-04-09 02:13:59 +02:00
2011-12-06 01:37:27 +01:00
if ( ! ist - > decoded_frame & & ! ( ist - > decoded_frame = avcodec_alloc_frame ( ) ) )
2011-11-23 04:02:17 +01:00
return AVERROR ( ENOMEM ) ;
2011-12-06 01:37:27 +01:00
else
avcodec_get_frame_defaults ( ist - > decoded_frame ) ;
decoded_frame = ist - > decoded_frame ;
2012-05-20 10:57:23 +02:00
pkt - > dts = av_rescale_q ( ist - > dts , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
2011-11-23 04:02:17 +01:00
2012-04-11 19:26:09 +02:00
update_benchmark ( NULL ) ;
2011-11-23 04:02:17 +01:00
ret = avcodec_decode_video2 ( ist - > st - > codec ,
decoded_frame , got_output , pkt ) ;
2012-04-11 19:26:09 +02:00
update_benchmark ( " decode_video %d.%d " , ist - > file_index , ist - > st - > index ) ;
2011-11-23 04:02:17 +01:00
if ( ret < 0 )
2011-12-06 01:37:27 +01:00
return ret ;
2007-08-04 01:25:03 +02:00
2011-11-21 14:39:22 +01:00
quality = same_quant ? decoded_frame - > quality : 0 ;
2011-11-23 04:02:17 +01:00
if ( ! * got_output ) {
/* no picture yet */
2012-04-01 19:01:37 +02:00
if ( ! pkt - > size )
for ( i = 0 ; i < ist - > nb_filters ; i + + )
2012-05-18 13:59:48 +02:00
av_buffersrc_add_ref ( ist - > filters [ i ] - > filter , NULL , AV_BUFFERSRC_FLAG_NO_COPY ) ;
2011-11-24 02:08:21 +01:00
return ret ;
2011-11-23 04:02:17 +01:00
}
2007-03-12 15:35:36 +01:00
2012-05-31 12:29:07 +02:00
if ( ist - > top_field_first > = 0 )
decoded_frame - > top_field_first = ist - > top_field_first ;
2012-04-29 11:16:03 +02:00
best_effort_timestamp = av_frame_get_best_effort_timestamp ( decoded_frame ) ;
if ( best_effort_timestamp ! = AV_NOPTS_VALUE )
2012-05-20 10:57:23 +02:00
ist - > next_pts = ist - > pts = av_rescale_q ( decoded_frame - > pts = best_effort_timestamp , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
2007-03-12 15:35:36 +01:00
2012-07-12 10:24:59 +02:00
if ( debug_ts ) {
av_log ( NULL , AV_LOG_INFO , " decoder -> ist_index:%d type:video "
2012-07-13 16:24:32 +02:00
" frame_pts:%s frame_pts_time:%s best_effort_ts:% " PRId64 " best_effort_ts_time:%s keyframe:%d frame_type:%d \n " ,
2012-07-12 10:24:59 +02:00
ist - > st - > index , av_ts2str ( decoded_frame - > pts ) ,
av_ts2timestr ( decoded_frame - > pts , & ist - > st - > time_base ) ,
best_effort_timestamp ,
av_ts2timestr ( best_effort_timestamp , & ist - > st - > time_base ) ,
decoded_frame - > key_frame , decoded_frame - > pict_type ) ;
}
2011-11-23 04:02:17 +01:00
pkt - > size = 0 ;
pre_process_video_frame ( ist , ( AVPicture * ) decoded_frame , & buffer_to_free ) ;
2007-03-12 15:35:36 +01:00
2011-11-23 04:02:17 +01:00
rate_emu_sleep ( ist ) ;
2005-12-17 19:14:38 +01:00
2012-03-22 09:37:33 +01:00
if ( ist - > st - > sample_aspect_ratio . num )
decoded_frame - > sample_aspect_ratio = ist - > st - > sample_aspect_ratio ;
2012-03-29 07:40:26 +02:00
resample_changed = ist - > resample_width ! = decoded_frame - > width | |
ist - > resample_height ! = decoded_frame - > height | |
ist - > resample_pix_fmt ! = decoded_frame - > format ;
if ( resample_changed ) {
av_log ( NULL , AV_LOG_INFO ,
" Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s \n " ,
ist - > file_index , ist - > st - > index ,
ist - > resample_width , ist - > resample_height , av_get_pix_fmt_name ( ist - > resample_pix_fmt ) ,
decoded_frame - > width , decoded_frame - > height , av_get_pix_fmt_name ( decoded_frame - > format ) ) ;
ist - > resample_width = decoded_frame - > width ;
ist - > resample_height = decoded_frame - > height ;
ist - > resample_pix_fmt = decoded_frame - > format ;
2012-04-01 15:08:33 +02:00
for ( i = 0 ; i < nb_filtergraphs ; i + + )
if ( ist_in_filtergraph ( filtergraphs [ i ] , ist ) & &
configure_filtergraph ( filtergraphs [ i ] ) < 0 ) {
2012-01-02 15:02:46 +01:00
av_log ( NULL , AV_LOG_FATAL , " Error reinitializing filters! \n " ) ;
exit_program ( 1 ) ;
2012-02-08 17:28:02 +01:00
}
2012-04-01 15:08:33 +02:00
}
2012-01-02 15:02:46 +01:00
2012-04-17 04:01:17 +02:00
frame_sample_aspect = av_opt_ptr ( avcodec_get_frame_class ( ) , decoded_frame , " sample_aspect_ratio " ) ;
2012-04-01 15:08:33 +02:00
for ( i = 0 ; i < ist - > nb_filters ; i + + ) {
2012-04-17 04:01:17 +02:00
int changed = ist - > st - > codec - > width ! = ist - > filters [ i ] - > filter - > outputs [ 0 ] - > w
| | ist - > st - > codec - > height ! = ist - > filters [ i ] - > filter - > outputs [ 0 ] - > h
| | ist - > st - > codec - > pix_fmt ! = ist - > filters [ i ] - > filter - > outputs [ 0 ] - > format ;
2012-03-29 08:51:17 +02:00
// XXX what an ugly hack
if ( ist - > filters [ i ] - > graph - > nb_outputs = = 1 )
ist - > filters [ i ] - > graph - > outputs [ 0 ] - > ost - > last_quality = quality ;
2012-04-17 04:01:17 +02:00
if ( ! frame_sample_aspect - > num )
* frame_sample_aspect = ist - > st - > sample_aspect_ratio ;
if ( ist - > dr1 & & decoded_frame - > type = = FF_BUFFER_TYPE_USER & & ! changed ) {
2011-12-21 21:04:05 +01:00
FrameBuffer * buf = decoded_frame - > opaque ;
AVFilterBufferRef * fb = avfilter_get_video_buffer_ref_from_arrays (
decoded_frame - > data , decoded_frame - > linesize ,
AV_PERM_READ | AV_PERM_PRESERVE ,
ist - > st - > codec - > width , ist - > st - > codec - > height ,
ist - > st - > codec - > pix_fmt ) ;
avfilter_copy_frame_props ( fb , decoded_frame ) ;
fb - > buf - > priv = buf ;
fb - > buf - > free = filter_release_buffer ;
2012-04-22 20:10:00 +02:00
av_assert0 ( buf - > refcount > 0 ) ;
2011-12-21 21:04:05 +01:00
buf - > refcount + + ;
2012-05-05 09:22:24 +02:00
av_buffersrc_add_ref ( ist - > filters [ i ] - > filter , fb ,
AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
AV_BUFFERSRC_FLAG_NO_COPY ) ;
2011-12-21 21:04:05 +01:00
} else
2012-05-05 09:33:55 +02:00
if ( av_buffersrc_add_frame ( ist - > filters [ i ] - > filter , decoded_frame , 0 ) < 0 ) {
2012-04-17 04:01:17 +02:00
av_log ( NULL , AV_LOG_FATAL , " Failed to inject frame into filter network \n " ) ;
exit_program ( 1 ) ;
2004-06-22 23:14:01 +02:00
}
2012-04-17 04:01:17 +02:00
2004-06-22 23:14:01 +02:00
}
2005-12-17 19:14:38 +01:00
2011-11-23 04:02:17 +01:00
av_free ( buffer_to_free ) ;
return ret ;
2003-12-15 15:43:44 +01:00
}
2011-11-23 04:02:17 +01:00
static int transcode_subtitles ( InputStream * ist , AVPacket * pkt , int * got_output )
2007-08-20 10:12:08 +02:00
{
2011-11-23 04:02:17 +01:00
AVSubtitle subtitle ;
int i , ret = avcodec_decode_subtitle2 ( ist - > st - > codec ,
& subtitle , got_output , pkt ) ;
if ( ret < 0 )
return ret ;
if ( ! * got_output )
2011-11-24 02:08:21 +01:00
return ret ;
2011-11-23 04:02:17 +01:00
rate_emu_sleep ( ist ) ;
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
OutputStream * ost = output_streams [ i ] ;
2011-11-23 04:02:17 +01:00
if ( ! check_output_constraints ( ist , ost ) | | ! ost - > encoding_needed )
continue ;
2012-04-15 15:28:30 +02:00
do_subtitle_out ( output_files [ ost - > file_index ] - > ctx , ost , ist , & subtitle , pkt - > pts ) ;
2011-11-23 04:02:17 +01:00
}
avsubtitle_free ( & subtitle ) ;
2011-11-24 02:08:21 +01:00
return ret ;
2007-08-20 10:12:08 +02:00
}
2003-12-15 15:43:44 +01:00
/* pkt = NULL means EOF (needed to flush decoder buffers) */
2012-04-15 15:03:07 +02:00
static int output_packet ( InputStream * ist , const AVPacket * pkt )
2003-12-15 15:43:44 +01:00
{
2011-09-29 01:03:02 +02:00
int ret = 0 , i ;
2011-05-10 07:53:46 +02:00
int got_output ;
2010-05-07 11:43:21 +02:00
2009-04-10 14:53:22 +02:00
AVPacket avpkt ;
2012-04-24 18:44:51 +02:00
if ( ! ist - > saw_first_ts ) {
ist - > dts = ist - > st - > avg_frame_rate . num ? - ist - > st - > codec - > has_b_frames * AV_TIME_BASE / av_q2d ( ist - > st - > avg_frame_rate ) : 0 ;
ist - > pts = 0 ;
if ( pkt ! = NULL & & pkt - > pts ! = AV_NOPTS_VALUE & & ! ist - > decoding_needed ) {
ist - > dts + = av_rescale_q ( pkt - > pts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
ist - > pts = ist - > dts ; //unused but better to set it to a value thats not totally wrong
}
ist - > saw_first_ts = 1 ;
}
2009-04-10 14:53:22 +02:00
2012-02-08 06:19:43 +01:00
if ( ist - > next_dts = = AV_NOPTS_VALUE )
ist - > next_dts = ist - > dts ;
2011-11-24 02:08:21 +01:00
if ( ist - > next_pts = = AV_NOPTS_VALUE )
ist - > next_pts = ist - > pts ;
2008-02-17 20:08:15 +01:00
2003-12-15 15:43:44 +01:00
if ( pkt = = NULL ) {
/* EOF handling */
2009-04-12 00:04:52 +02:00
av_init_packet ( & avpkt ) ;
2009-04-10 14:53:22 +02:00
avpkt . data = NULL ;
avpkt . size = 0 ;
2003-12-15 15:43:44 +01:00
goto handle_eof ;
2009-04-12 00:04:52 +02:00
} else {
avpkt = * pkt ;
2003-12-15 15:43:44 +01:00
}
2011-12-30 03:46:24 +01:00
if ( pkt - > dts ! = AV_NOPTS_VALUE ) {
2012-02-08 06:19:43 +01:00
ist - > next_dts = ist - > dts = av_rescale_q ( pkt - > dts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
2011-12-30 03:46:24 +01:00
if ( ist - > st - > codec - > codec_type ! = AVMEDIA_TYPE_VIDEO | | ! ist - > decoding_needed )
2011-11-10 14:59:00 +01:00
ist - > next_pts = ist - > pts = av_rescale_q ( pkt - > dts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
}
2008-02-17 18:55:53 +01:00
2011-12-30 03:46:24 +01:00
// while we have more to decode or while the decoder did output something on EOF
2011-11-23 04:02:17 +01:00
while ( ist - > decoding_needed & & ( avpkt . size > 0 | | ( ! pkt & & got_output ) ) ) {
2012-02-08 16:16:42 +01:00
int duration ;
2003-12-15 15:43:44 +01:00
handle_eof :
2008-02-15 22:45:12 +01:00
2011-11-24 02:08:21 +01:00
ist - > pts = ist - > next_pts ;
2012-02-08 06:19:43 +01:00
ist - > dts = ist - > next_dts ;
2011-11-24 02:08:21 +01:00
if ( avpkt . size & & avpkt . size ! = pkt - > size ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , ist - > showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING ,
" Multiple frames in a packet from stream %d \n " , pkt - > stream_index ) ;
2011-11-24 02:08:21 +01:00
ist - > showed_multi_packet_warning = 1 ;
}
2008-02-17 20:38:47 +01:00
2011-12-30 03:46:24 +01:00
switch ( ist - > st - > codec - > codec_type ) {
2011-11-23 04:02:17 +01:00
case AVMEDIA_TYPE_AUDIO :
2012-05-18 12:46:11 +02:00
ret = decode_audio ( ist , & avpkt , & got_output ) ;
2011-11-23 04:02:17 +01:00
break ;
case AVMEDIA_TYPE_VIDEO :
2012-05-18 12:46:11 +02:00
ret = decode_video ( ist , & avpkt , & got_output ) ;
2012-02-08 16:16:42 +01:00
if ( avpkt . duration ) {
duration = av_rescale_q ( avpkt . duration , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
2012-02-28 18:41:01 +01:00
} else if ( ist - > st - > codec - > time_base . num ! = 0 & & ist - > st - > codec - > time_base . den ! = 0 ) {
2012-02-08 16:16:42 +01:00
int ticks = ist - > st - > parser ? ist - > st - > parser - > repeat_pict + 1 : ist - > st - > codec - > ticks_per_frame ;
duration = ( ( int64_t ) AV_TIME_BASE *
ist - > st - > codec - > time_base . num * ticks ) /
ist - > st - > codec - > time_base . den ;
} else
duration = 0 ;
if ( ist - > dts ! = AV_NOPTS_VALUE & & duration ) {
ist - > next_dts + = duration ;
} else
ist - > next_dts = AV_NOPTS_VALUE ;
if ( got_output )
ist - > next_pts + = duration ; //FIXME the duration is not correct in some cases
2011-11-23 04:02:17 +01:00
break ;
case AVMEDIA_TYPE_SUBTITLE :
ret = transcode_subtitles ( ist , & avpkt , & got_output ) ;
2010-03-19 08:44:38 +01:00
break ;
2011-11-23 04:02:17 +01:00
default :
return - 1 ;
2007-03-12 15:35:36 +01:00
}
2003-12-15 15:43:44 +01:00
2011-11-23 04:02:17 +01:00
if ( ret < 0 )
return ret ;
2011-12-13 19:46:29 +01:00
avpkt . dts =
avpkt . pts = AV_NOPTS_VALUE ;
2011-11-24 02:08:21 +01:00
// touch data and size only if not EOF
if ( pkt ) {
if ( ist - > st - > codec - > codec_type ! = AVMEDIA_TYPE_AUDIO )
ret = avpkt . size ;
avpkt . data + = ret ;
avpkt . size - = ret ;
}
2011-11-23 04:02:17 +01:00
if ( ! got_output ) {
2011-11-24 02:08:21 +01:00
continue ;
2011-06-06 04:03:09 +02:00
}
2011-11-23 04:02:17 +01:00
}
2011-06-06 04:03:09 +02:00
2011-11-23 04:02:17 +01:00
/* handle stream copy */
if ( ! ist - > decoding_needed ) {
rate_emu_sleep ( ist ) ;
2012-02-08 07:56:53 +01:00
ist - > dts = ist - > next_dts ;
2011-11-23 04:02:17 +01:00
switch ( ist - > st - > codec - > codec_type ) {
case AVMEDIA_TYPE_AUDIO :
2012-02-08 07:56:53 +01:00
ist - > next_dts + = ( ( int64_t ) AV_TIME_BASE * ist - > st - > codec - > frame_size ) /
2011-11-23 04:02:17 +01:00
ist - > st - > codec - > sample_rate ;
break ;
case AVMEDIA_TYPE_VIDEO :
2011-12-03 15:03:49 +01:00
if ( pkt - > duration ) {
2012-02-08 07:56:53 +01:00
ist - > next_dts + = av_rescale_q ( pkt - > duration , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
2011-12-03 15:03:49 +01:00
} else if ( ist - > st - > codec - > time_base . num ! = 0 ) {
2011-12-30 03:46:24 +01:00
int ticks = ist - > st - > parser ? ist - > st - > parser - > repeat_pict + 1 : ist - > st - > codec - > ticks_per_frame ;
2012-02-08 07:56:53 +01:00
ist - > next_dts + = ( ( int64_t ) AV_TIME_BASE *
2011-11-23 04:02:17 +01:00
ist - > st - > codec - > time_base . num * ticks ) /
ist - > st - > codec - > time_base . den ;
2005-03-23 02:59:17 +01:00
}
2011-11-23 04:02:17 +01:00
break ;
2007-03-12 15:35:36 +01:00
}
2012-02-08 17:26:06 +01:00
ist - > pts = ist - > dts ;
ist - > next_pts = ist - > next_dts ;
2011-11-23 04:02:17 +01:00
}
2012-04-15 15:03:07 +02:00
for ( i = 0 ; pkt & & i < nb_output_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
OutputStream * ost = output_streams [ i ] ;
2005-03-23 02:59:17 +01:00
2011-11-23 04:02:17 +01:00
if ( ! check_output_constraints ( ist , ost ) | | ost - > encoding_needed )
continue ;
2010-05-07 11:43:21 +02:00
2011-11-23 04:02:17 +01:00
do_streamcopy ( ist , ost , pkt ) ;
2007-03-12 15:35:36 +01:00
}
2005-12-17 19:14:38 +01:00
2003-12-15 15:43:44 +01:00
return 0 ;
}
2012-04-15 15:03:07 +02:00
static void print_sdp ( void )
2007-08-20 10:12:08 +02:00
{
char sdp [ 2048 ] ;
2011-08-30 14:19:39 +02:00
int i ;
2012-04-15 15:03:07 +02:00
AVFormatContext * * avc = av_malloc ( sizeof ( * avc ) * nb_output_files ) ;
2011-08-30 14:19:39 +02:00
if ( ! avc )
exit_program ( 1 ) ;
2012-04-15 15:03:07 +02:00
for ( i = 0 ; i < nb_output_files ; i + + )
2012-04-15 15:28:30 +02:00
avc [ i ] = output_files [ i ] - > ctx ;
2007-08-20 10:12:08 +02:00
2012-04-15 15:03:07 +02:00
av_sdp_create ( avc , nb_output_files , sdp , sizeof ( sdp ) ) ;
2007-08-20 10:12:08 +02:00
printf ( " SDP: \n %s \n " , sdp ) ;
2008-11-15 13:32:38 +01:00
fflush ( stdout ) ;
2011-08-30 14:19:39 +02:00
av_freep ( & avc ) ;
2007-08-20 10:12:08 +02:00
}
2003-12-15 15:43:44 +01:00
2012-04-15 15:03:07 +02:00
static int init_input_stream ( int ist_index , char * error , int error_len )
2011-08-30 15:53:55 +02:00
{
2012-04-15 15:28:30 +02:00
InputStream * ist = input_streams [ ist_index ] ;
2012-04-10 22:06:53 +02:00
2011-08-30 15:53:55 +02:00
if ( ist - > decoding_needed ) {
AVCodec * codec = ist - > dec ;
if ( ! codec ) {
2011-11-07 02:41:01 +01:00
snprintf ( error , error_len , " Decoder (codec %s) not found for input stream #%d:%d " ,
2011-08-30 15:53:55 +02:00
avcodec_get_name ( ist - > st - > codec - > codec_id ) , ist - > file_index , ist - > st - > index ) ;
return AVERROR ( EINVAL ) ;
}
2011-12-26 05:50:25 +01:00
2012-05-11 02:45:34 +02:00
ist - > dr1 = ( codec - > capabilities & CODEC_CAP_DR1 ) & & ! do_deinterlace ;
2011-12-27 05:22:44 +01:00
if ( codec - > type = = AVMEDIA_TYPE_VIDEO & & ist - > dr1 ) {
2011-12-26 05:50:25 +01:00
ist - > st - > codec - > get_buffer = codec_get_buffer ;
ist - > st - > codec - > release_buffer = codec_release_buffer ;
2012-05-30 07:32:43 +02:00
ist - > st - > codec - > opaque = & ist - > buffer_pool ;
2011-12-26 05:50:25 +01:00
}
2012-01-21 23:23:23 +01:00
if ( ! av_dict_get ( ist - > opts , " threads " , NULL , 0 ) )
av_dict_set ( & ist - > opts , " threads " , " auto " , 0 ) ;
2011-08-30 15:53:55 +02:00
if ( avcodec_open2 ( ist - > st - > codec , codec , & ist - > opts ) < 0 ) {
2011-11-07 02:41:01 +01:00
snprintf ( error , error_len , " Error while opening decoder for input stream #%d:%d " ,
2011-08-30 15:53:55 +02:00
ist - > file_index , ist - > st - > index ) ;
return AVERROR ( EINVAL ) ;
}
assert_codec_experimental ( ist - > st - > codec , 0 ) ;
assert_avoptions ( ist - > opts ) ;
}
ist - > next_pts = AV_NOPTS_VALUE ;
2012-02-08 07:56:17 +01:00
ist - > next_dts = AV_NOPTS_VALUE ;
2011-08-30 15:53:55 +02:00
ist - > is_start = 1 ;
return 0 ;
}
2012-04-01 15:08:33 +02:00
static InputStream * get_input_stream ( OutputStream * ost )
{
if ( ost - > source_index > = 0 )
return input_streams [ ost - > source_index ] ;
return NULL ;
}
2012-06-22 14:36:27 +02:00
static void parse_forced_key_frames ( char * kf , OutputStream * ost ,
AVCodecContext * avctx )
{
char * p ;
int n = 1 , i ;
int64_t t ;
for ( p = kf ; * p ; p + + )
if ( * p = = ' , ' )
n + + ;
ost - > forced_kf_count = n ;
ost - > forced_kf_pts = av_malloc ( sizeof ( * ost - > forced_kf_pts ) * n ) ;
if ( ! ost - > forced_kf_pts ) {
av_log ( NULL , AV_LOG_FATAL , " Could not allocate forced key frames array. \n " ) ;
exit_program ( 1 ) ;
}
2012-04-30 22:48:42 +02:00
2012-06-30 12:09:24 +02:00
p = kf ;
2012-06-22 14:36:27 +02:00
for ( i = 0 ; i < n ; i + + ) {
2012-06-30 12:09:24 +02:00
char * next = strchr ( p , ' , ' ) ;
2012-04-30 22:48:42 +02:00
if ( next )
* next + + = 0 ;
2012-06-22 14:36:27 +02:00
t = parse_time_or_die ( " force_key_frames " , p , 1 ) ;
ost - > forced_kf_pts [ i ] = av_rescale_q ( t , AV_TIME_BASE_Q , avctx - > time_base ) ;
2012-04-30 22:48:42 +02:00
2012-06-30 12:09:24 +02:00
p = next ;
2012-06-22 14:36:27 +02:00
}
}
2012-07-25 17:46:00 +02:00
static void report_new_stream ( int input_index , AVPacket * pkt )
{
InputFile * file = input_files [ input_index ] ;
AVStream * st = file - > ctx - > streams [ pkt - > stream_index ] ;
if ( pkt - > stream_index < file - > nb_streams_warn )
return ;
av_log ( file - > ctx , AV_LOG_WARNING ,
" New %s stream %d:%d at pos:% " PRId64 " and DTS:%ss \n " ,
av_get_media_type_string ( st - > codec - > codec_type ) ,
input_index , pkt - > stream_index ,
pkt - > pos , av_ts2timestr ( pkt - > dts , & st - > time_base ) ) ;
file - > nb_streams_warn = pkt - > stream_index + 1 ;
}
2012-04-15 15:03:07 +02:00
static int transcode_init ( void )
2001-07-22 16:37:44 +02:00
{
2011-09-11 23:35:35 +02:00
int ret = 0 , i , j , k ;
2011-11-22 02:54:50 +01:00
AVFormatContext * oc ;
2012-06-07 20:49:24 +02:00
AVCodecContext * codec , * icodec = NULL ;
2011-08-30 15:03:53 +02:00
OutputStream * ost ;
2011-06-23 19:14:08 +02:00
InputStream * ist ;
2009-03-11 07:06:18 +01:00
char error [ 1024 ] ;
2007-08-20 10:12:08 +02:00
int want_sdp = 1 ;
2011-08-30 15:08:02 +02:00
2011-09-05 22:10:26 +02:00
/* init framerate emulation */
for ( i = 0 ; i < nb_input_files ; i + + ) {
2012-04-15 15:28:30 +02:00
InputFile * ifile = input_files [ i ] ;
2011-09-05 22:10:26 +02:00
if ( ifile - > rate_emu )
for ( j = 0 ; j < ifile - > nb_streams ; j + + )
2012-04-15 15:28:30 +02:00
input_streams [ j + ifile - > ist_index ] - > start = av_gettime ( ) ;
2011-09-05 22:10:26 +02:00
}
2001-07-22 16:37:44 +02:00
/* output stream init */
2011-11-22 02:54:50 +01:00
for ( i = 0 ; i < nb_output_files ; i + + ) {
2012-04-15 15:28:30 +02:00
oc = output_files [ i ] - > ctx ;
2011-11-22 02:54:50 +01:00
if ( ! oc - > nb_streams & & ! ( oc - > oformat - > flags & AVFMT_NOSTREAMS ) ) {
av_dump_format ( oc , i , oc - > filename , 1 ) ;
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_ERROR , " Output file #%d does not contain any stream \n " , i ) ;
2011-08-30 16:03:51 +02:00
return AVERROR ( EINVAL ) ;
2006-11-05 21:08:26 +01:00
}
2001-07-22 16:37:44 +02:00
}
2012-04-01 15:08:33 +02:00
/* init complex filtergraphs */
for ( i = 0 ; i < nb_filtergraphs ; i + + )
if ( ( ret = avfilter_graph_config ( filtergraphs [ i ] - > graph , NULL ) ) < 0 )
return ret ;
2001-07-22 16:37:44 +02:00
/* for each output stream, we compute the right encoding parameters */
2011-08-30 15:03:53 +02:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
ost = output_streams [ i ] ;
oc = output_files [ ost - > file_index ] - > ctx ;
2012-04-01 15:08:33 +02:00
ist = get_input_stream ( ost ) ;
2001-07-22 16:37:44 +02:00
2011-11-04 01:44:06 +01:00
if ( ost - > attachment_filename )
continue ;
2011-11-22 02:54:50 +01:00
codec = ost - > st - > codec ;
2001-07-22 16:37:44 +02:00
2012-04-01 15:08:33 +02:00
if ( ist ) {
icodec = ist - > st - > codec ;
ost - > st - > disposition = ist - > st - > disposition ;
codec - > bits_per_raw_sample = icodec - > bits_per_raw_sample ;
codec - > chroma_sample_location = icodec - > chroma_sample_location ;
}
2008-03-07 20:25:09 +01:00
2011-10-26 02:09:31 +02:00
if ( ost - > stream_copy ) {
2012-04-21 07:03:06 +02:00
uint64_t extra_size ;
av_assert0 ( ist & & ! ost - > filter ) ;
extra_size = ( uint64_t ) icodec - > extradata_size + FF_INPUT_BUFFER_PADDING_SIZE ;
2010-06-08 21:27:29 +02:00
2011-08-30 15:57:50 +02:00
if ( extra_size > INT_MAX ) {
2011-08-30 16:03:51 +02:00
return AVERROR ( EINVAL ) ;
2011-08-30 15:57:50 +02:00
}
2010-06-08 21:27:29 +02:00
2002-10-11 11:19:34 +02:00
/* if stream_copy is selected, no need to decode or encode */
2011-11-22 02:54:50 +01:00
codec - > codec_id = icodec - > codec_id ;
2002-10-11 11:19:34 +02:00
codec - > codec_type = icodec - > codec_type ;
2007-08-04 18:03:39 +02:00
2011-11-22 02:54:50 +01:00
if ( ! codec - > codec_tag ) {
if ( ! oc - > oformat - > codec_tag | |
av_codec_get_id ( oc - > oformat - > codec_tag , icodec - > codec_tag ) = = codec - > codec_id | |
av_codec_get_tag ( oc - > oformat - > codec_tag , icodec - > codec_id ) < = 0 )
2007-08-04 18:03:39 +02:00
codec - > codec_tag = icodec - > codec_tag ;
}
2011-11-22 02:54:50 +01:00
codec - > bit_rate = icodec - > bit_rate ;
2010-10-07 03:57:35 +02:00
codec - > rc_max_rate = icodec - > rc_max_rate ;
codec - > rc_buffer_size = icodec - > rc_buffer_size ;
2011-12-23 03:00:12 +01:00
codec - > field_order = icodec - > field_order ;
2011-11-22 02:54:50 +01:00
codec - > extradata = av_mallocz ( extra_size ) ;
2011-08-30 15:57:50 +02:00
if ( ! codec - > extradata ) {
2011-08-30 16:03:51 +02:00
return AVERROR ( ENOMEM ) ;
2011-08-30 15:57:50 +02:00
}
2010-06-08 21:27:29 +02:00
memcpy ( codec - > extradata , icodec - > extradata , icodec - > extradata_size ) ;
2005-03-24 02:47:45 +01:00
codec - > extradata_size = icodec - > extradata_size ;
2012-05-12 21:09:32 +02:00
codec - > bits_per_coded_sample = icodec - > bits_per_coded_sample ;
2011-07-25 20:48:55 +02:00
codec - > time_base = ist - > st - > time_base ;
2012-02-05 05:14:26 +01:00
/*
* Avi is a special case here because it supports variable fps but
* having the fps and timebase differe significantly adds quite some
* overhead
*/
2011-11-22 02:54:50 +01:00
if ( ! strcmp ( oc - > oformat - > name , " avi " ) ) {
2011-12-01 03:06:16 +01:00
if ( copy_tb < 0 & & av_q2d ( icodec - > time_base ) * icodec - > ticks_per_frame > 2 * av_q2d ( ist - > st - > time_base )
& & av_q2d ( ist - > st - > time_base ) < 1.0 / 500
| | copy_tb = = 0 ) {
2011-07-25 20:48:55 +02:00
codec - > time_base = icodec - > time_base ;
codec - > time_base . num * = icodec - > ticks_per_frame ;
codec - > time_base . den * = 2 ;
2012-04-12 12:57:22 +02:00
codec - > ticks_per_frame = 2 ;
2011-07-25 20:48:55 +02:00
}
2011-12-05 03:19:28 +01:00
} else if ( ! ( oc - > oformat - > flags & AVFMT_VARIABLE_FPS )
& & strcmp ( oc - > oformat - > name , " mov " ) & & strcmp ( oc - > oformat - > name , " mp4 " ) & & strcmp ( oc - > oformat - > name , " 3gp " )
& & strcmp ( oc - > oformat - > name , " 3g2 " ) & & strcmp ( oc - > oformat - > name , " psp " ) & & strcmp ( oc - > oformat - > name , " ipod " )
) {
2011-12-01 03:06:16 +01:00
if ( copy_tb < 0 & & av_q2d ( icodec - > time_base ) * icodec - > ticks_per_frame > av_q2d ( ist - > st - > time_base )
& & av_q2d ( ist - > st - > time_base ) < 1.0 / 500
| | copy_tb = = 0 ) {
2011-07-25 20:48:55 +02:00
codec - > time_base = icodec - > time_base ;
codec - > time_base . num * = icodec - > ticks_per_frame ;
}
}
2012-06-11 03:00:28 +02:00
if ( ost - > frame_rate . num )
codec - > time_base = ( AVRational ) { ost - > frame_rate . den , ost - > frame_rate . num } ;
2011-07-25 20:48:55 +02:00
av_reduce ( & codec - > time_base . num , & codec - > time_base . den ,
codec - > time_base . num , codec - > time_base . den , INT_MAX ) ;
2011-12-30 03:46:24 +01:00
switch ( codec - > codec_type ) {
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_AUDIO :
2011-12-30 03:46:24 +01:00
if ( audio_volume ! = 256 ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " -acodec copy and -vol are incompatible (frames are not decoded) \n " ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2008-07-12 13:43:21 +02:00
}
2011-11-22 02:54:50 +01:00
codec - > channel_layout = icodec - > channel_layout ;
codec - > sample_rate = icodec - > sample_rate ;
codec - > channels = icodec - > channels ;
codec - > frame_size = icodec - > frame_size ;
2011-03-24 17:00:21 +01:00
codec - > audio_service_type = icodec - > audio_service_type ;
2011-11-22 02:54:50 +01:00
codec - > block_align = icodec - > block_align ;
2012-07-13 16:24:54 +02:00
if ( ( codec - > block_align = = 1 | | codec - > block_align = = 1152 ) & & codec - > codec_id = = CODEC_ID_MP3 )
2012-05-14 15:15:11 +02:00
codec - > block_align = 0 ;
if ( codec - > codec_id = = CODEC_ID_AC3 )
codec - > block_align = 0 ;
2002-10-11 11:19:34 +02:00
break ;
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_VIDEO :
2011-11-22 02:54:50 +01:00
codec - > pix_fmt = icodec - > pix_fmt ;
codec - > width = icodec - > width ;
codec - > height = icodec - > height ;
codec - > has_b_frames = icodec - > has_b_frames ;
2011-04-17 01:47:24 +02:00
if ( ! codec - > sample_aspect_ratio . num ) {
2011-11-22 02:54:50 +01:00
codec - > sample_aspect_ratio =
2011-04-17 01:47:24 +02:00
ost - > st - > sample_aspect_ratio =
ist - > st - > sample_aspect_ratio . num ? ist - > st - > sample_aspect_ratio :
ist - > st - > codec - > sample_aspect_ratio . num ?
ist - > st - > codec - > sample_aspect_ratio : ( AVRational ) { 0 , 1 } ;
}
2011-11-05 23:43:01 +01:00
ost - > st - > avg_frame_rate = ist - > st - > avg_frame_rate ;
2002-10-11 11:19:34 +02:00
break ;
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_SUBTITLE :
2011-11-22 02:54:50 +01:00
codec - > width = icodec - > width ;
2009-01-18 00:54:27 +01:00
codec - > height = icodec - > height ;
2005-06-03 16:31:45 +02:00
break ;
2011-04-14 13:32:36 +02:00
case AVMEDIA_TYPE_DATA :
2011-09-28 01:31:38 +02:00
case AVMEDIA_TYPE_ATTACHMENT :
2011-04-14 13:32:36 +02:00
break ;
2002-10-11 11:19:34 +02:00
default :
2007-07-02 09:43:23 +02:00
abort ( ) ;
2002-10-11 11:19:34 +02:00
}
} else {
2011-06-16 06:24:54 +02:00
if ( ! ost - > enc )
2012-02-12 11:50:01 +01:00
ost - > enc = avcodec_find_encoder ( codec - > codec_id ) ;
2012-04-20 15:17:38 +02:00
if ( ! ost - > enc ) {
2012-04-18 06:53:11 +02:00
/* should only happen when a default codec is not present. */
2012-04-20 15:17:38 +02:00
snprintf ( error , sizeof ( error ) , " Encoder (codec %s) not found for output stream #%d:%d " ,
avcodec_get_name ( ost - > st - > codec - > codec_id ) , ost - > file_index , ost - > index ) ;
ret = AVERROR ( EINVAL ) ;
goto dump_format ;
}
2011-11-22 02:54:50 +01:00
2012-04-01 15:08:33 +02:00
if ( ist )
ist - > decoding_needed = 1 ;
2011-10-10 03:41:49 +02:00
ost - > encoding_needed = 1 ;
2011-11-22 02:54:50 +01:00
2012-05-20 11:55:25 +02:00
if ( codec - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2012-06-05 12:43:33 +02:00
if ( ost - > filter & & ! ost - > frame_rate . num )
ost - > frame_rate = av_buffersink_get_frame_rate ( ost - > filter - > filter ) ;
2012-05-20 11:55:25 +02:00
if ( ist & & ! ost - > frame_rate . num )
ost - > frame_rate = ist - > st - > r_frame_rate . num ? ist - > st - > r_frame_rate : ( AVRational ) { 25 , 1 } ;
if ( ost - > enc & & ost - > enc - > supported_framerates & & ! ost - > force_fps ) {
int idx = av_find_nearest_q_idx ( ost - > frame_rate , ost - > enc - > supported_framerates ) ;
ost - > frame_rate = ost - > enc - > supported_framerates [ idx ] ;
}
}
2012-05-05 18:22:46 +02:00
if ( ! ost - > filter & &
( codec - > codec_type = = AVMEDIA_TYPE_VIDEO | |
codec - > codec_type = = AVMEDIA_TYPE_AUDIO ) ) {
2012-04-01 15:08:33 +02:00
FilterGraph * fg ;
fg = init_simple_filtergraph ( ist , ost ) ;
2012-05-26 12:47:47 +02:00
if ( configure_filtergraph ( fg ) ) {
2012-04-01 15:08:33 +02:00
av_log ( NULL , AV_LOG_FATAL , " Error opening filters! \n " ) ;
exit ( 1 ) ;
}
2012-05-05 18:22:46 +02:00
}
2011-07-17 16:27:14 +02:00
2012-05-05 18:22:46 +02:00
switch ( codec - > codec_type ) {
case AVMEDIA_TYPE_AUDIO :
codec - > sample_fmt = ost - > filter - > filter - > inputs [ 0 ] - > format ;
codec - > sample_rate = ost - > filter - > filter - > inputs [ 0 ] - > sample_rate ;
codec - > channel_layout = ost - > filter - > filter - > inputs [ 0 ] - > channel_layout ;
codec - > channels = av_get_channel_layout_nb_channels ( codec - > channel_layout ) ;
codec - > time_base = ( AVRational ) { 1 , codec - > sample_rate } ;
break ;
case AVMEDIA_TYPE_VIDEO :
2011-06-15 08:00:03 +02:00
codec - > time_base = ( AVRational ) { ost - > frame_rate . den , ost - > frame_rate . num } ;
2012-05-23 14:31:30 +02:00
if ( ost - > filter & & ! ( codec - > time_base . num & & codec - > time_base . den ) )
codec - > time_base = ost - > filter - > filter - > inputs [ 0 ] - > time_base ;
2012-01-28 19:48:17 +01:00
if ( av_q2d ( codec - > time_base ) < 0.001 & & video_sync_method ! = VSYNC_PASSTHROUGH
& & ( video_sync_method = = VSYNC_CFR | | ( video_sync_method = = VSYNC_AUTO & & ! ( oc - > oformat - > flags & AVFMT_VARIABLE_FPS ) ) ) ) {
2012-04-04 11:50:16 +02:00
av_log ( oc , AV_LOG_WARNING , " Frame rate very high for a muxer not efficiently supporting it. \n "
" Please consider specifying a lower framerate, a different muxer or -vsync 2 \n " ) ;
2011-06-20 20:13:26 +02:00
}
2011-10-05 14:01:46 +02:00
for ( j = 0 ; j < ost - > forced_kf_count ; j + + )
ost - > forced_kf_pts [ j ] = av_rescale_q ( ost - > forced_kf_pts [ j ] ,
AV_TIME_BASE_Q ,
codec - > time_base ) ;
2011-06-15 08:00:03 +02:00
2012-04-01 15:08:33 +02:00
codec - > width = ost - > filter - > filter - > inputs [ 0 ] - > w ;
codec - > height = ost - > filter - > filter - > inputs [ 0 ] - > h ;
codec - > sample_aspect_ratio = ost - > st - > sample_aspect_ratio =
ost - > frame_aspect_ratio ? // overridden by the -aspect cli option
av_d2q ( ost - > frame_aspect_ratio * codec - > height / codec - > width , 255 ) :
ost - > filter - > filter - > inputs [ 0 ] - > sample_aspect_ratio ;
codec - > pix_fmt = ost - > filter - > filter - > inputs [ 0 ] - > format ;
2012-03-23 15:46:30 +01:00
2012-05-23 21:19:16 +02:00
if ( ! icodec | |
codec - > width ! = icodec - > width | |
2012-03-23 20:59:09 +01:00
codec - > height ! = icodec - > height | |
codec - > pix_fmt ! = icodec - > pix_fmt ) {
2012-04-17 04:01:17 +02:00
codec - > bits_per_raw_sample = frame_bits_per_raw_sample ;
2010-05-07 11:43:21 +02:00
}
2012-03-23 15:46:30 +01:00
2012-06-22 14:36:27 +02:00
if ( ost - > forced_keyframes )
parse_forced_key_frames ( ost - > forced_keyframes , ost ,
ost - > st - > codec ) ;
2002-10-11 11:19:34 +02:00
break ;
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_SUBTITLE :
2012-02-05 14:28:19 +01:00
codec - > time_base = ( AVRational ) { 1 , 1000 } ;
2005-06-03 16:31:45 +02:00
break ;
2002-10-11 11:19:34 +02:00
default :
2007-07-02 09:43:23 +02:00
abort ( ) ;
2005-06-03 16:31:45 +02:00
break ;
2001-07-22 16:37:44 +02:00
}
2002-10-11 11:19:34 +02:00
/* two pass mode */
2012-03-14 02:04:18 +01:00
if ( codec - > flags & ( CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2 ) ) {
2002-10-11 11:19:34 +02:00
char logfilename [ 1024 ] ;
FILE * f ;
2005-12-17 19:14:38 +01:00
snprintf ( logfilename , sizeof ( logfilename ) , " %s-%d.log " ,
2008-12-26 20:28:42 +01:00
pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX ,
i ) ;
2012-03-12 17:42:57 +01:00
if ( ! strcmp ( ost - > enc - > name , " libx264 " ) ) {
av_dict_set ( & ost - > opts , " stats " , logfilename , AV_DICT_DONT_OVERWRITE ) ;
} else {
2012-03-14 02:04:18 +01:00
if ( codec - > flags & CODEC_FLAG_PASS2 ) {
2012-03-12 17:43:48 +01:00
char * logbuffer ;
size_t logbuffer_size ;
if ( cmdutils_read_file ( logfilename , & logbuffer , & logbuffer_size ) < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Error reading log file '%s' for pass-2 encoding \n " ,
2012-05-19 12:05:02 +02:00
logfilename ) ;
2012-03-12 17:43:48 +01:00
exit_program ( 1 ) ;
}
codec - > stats_in = logbuffer ;
2002-10-11 11:19:34 +02:00
}
2012-03-14 02:04:18 +01:00
if ( codec - > flags & CODEC_FLAG_PASS1 ) {
f = fopen ( logfilename , " wb " ) ;
if ( ! f ) {
av_log ( NULL , AV_LOG_FATAL , " Cannot write log file '%s' for pass-1 encoding: %s \n " ,
logfilename , strerror ( errno ) ) ;
exit_program ( 1 ) ;
}
ost - > logfile = f ;
2011-10-30 02:26:48 +01:00
}
}
2002-10-10 19:09:01 +02:00
}
}
2002-10-11 11:19:34 +02:00
}
2001-07-22 16:37:44 +02:00
/* open each encoder */
2011-08-30 15:03:53 +02:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
ost = output_streams [ i ] ;
2001-07-22 16:37:44 +02:00
if ( ost - > encoding_needed ) {
2011-11-22 02:54:50 +01:00
AVCodec * codec = ost - > enc ;
2012-04-01 15:08:33 +02:00
AVCodecContext * dec = NULL ;
if ( ( ist = get_input_stream ( ost ) ) )
dec = ist - > st - > codec ;
if ( dec & & dec - > subtitle_header ) {
2010-11-13 14:57:49 +01:00
ost - > st - > codec - > subtitle_header = av_malloc ( dec - > subtitle_header_size ) ;
if ( ! ost - > st - > codec - > subtitle_header ) {
ret = AVERROR ( ENOMEM ) ;
goto dump_format ;
}
memcpy ( ost - > st - > codec - > subtitle_header , dec - > subtitle_header , dec - > subtitle_header_size ) ;
ost - > st - > codec - > subtitle_header_size = dec - > subtitle_header_size ;
}
2012-01-21 23:23:23 +01:00
if ( ! av_dict_get ( ost - > opts , " threads " , NULL , 0 ) )
av_dict_set ( & ost - > opts , " threads " , " auto " , 0 ) ;
2011-05-25 17:29:25 +02:00
if ( avcodec_open2 ( ost - > st - > codec , codec , & ost - > opts ) < 0 ) {
2011-11-07 02:41:01 +01:00
snprintf ( error , sizeof ( error ) , " Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height " ,
2001-07-22 16:37:44 +02:00
ost - > file_index , ost - > index ) ;
2009-03-11 07:06:18 +01:00
ret = AVERROR ( EINVAL ) ;
goto dump_format ;
2001-07-22 16:37:44 +02:00
}
2012-06-25 00:32:49 +02:00
if ( ost - > enc - > type = = AVMEDIA_TYPE_AUDIO & &
! ( ost - > enc - > capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE ) )
av_buffersink_set_frame_size ( ost - > filter - > filter ,
ost - > st - > codec - > frame_size ) ;
2011-07-12 17:18:42 +02:00
assert_codec_experimental ( ost - > st - > codec , 1 ) ;
2011-05-25 17:29:25 +02:00
assert_avoptions ( ost - > opts ) ;
2011-07-14 09:38:36 +02:00
if ( ost - > st - > codec - > bit_rate & & ost - > st - > codec - > bit_rate < 1000 )
av_log ( NULL , AV_LOG_WARNING , " The bitrate parameter is set too low. "
2011-10-08 21:39:36 +02:00
" It takes bits/s as argument, not kbits/s \n " ) ;
2005-07-18 00:24:36 +02:00
extra_size + = ost - > st - > codec - > extradata_size ;
2011-09-11 23:35:35 +02:00
if ( ost - > st - > codec - > me_threshold )
2012-04-15 15:28:30 +02:00
input_streams [ ost - > source_index ] - > st - > codec - > debug | = FF_DEBUG_MV ;
2001-07-22 16:37:44 +02:00
}
}
2011-08-30 15:53:55 +02:00
/* init input streams */
for ( i = 0 ; i < nb_input_streams ; i + + )
2012-04-15 15:03:07 +02:00
if ( ( ret = init_input_stream ( i , error , sizeof ( error ) ) ) < 0 )
2011-08-30 15:53:55 +02:00
goto dump_format ;
2010-02-02 23:23:09 +01:00
2011-09-11 23:35:35 +02:00
/* discard unused programs */
for ( i = 0 ; i < nb_input_files ; i + + ) {
2012-04-15 15:28:30 +02:00
InputFile * ifile = input_files [ i ] ;
2011-09-11 23:35:35 +02:00
for ( j = 0 ; j < ifile - > ctx - > nb_programs ; j + + ) {
AVProgram * p = ifile - > ctx - > programs [ j ] ;
int discard = AVDISCARD_ALL ;
for ( k = 0 ; k < p - > nb_stream_indexes ; k + + )
2012-04-15 15:28:30 +02:00
if ( ! input_streams [ ifile - > ist_index + p - > stream_index [ k ] ] - > discard ) {
2011-09-11 23:35:35 +02:00
discard = AVDISCARD_DEFAULT ;
2011-04-24 22:48:42 +02:00
break ;
}
2011-09-11 23:35:35 +02:00
p - > discard = discard ;
2001-07-22 16:37:44 +02:00
}
}
/* open files and write file headers */
2011-08-30 14:19:39 +02:00
for ( i = 0 ; i < nb_output_files ; i + + ) {
2012-04-15 15:28:30 +02:00
oc = output_files [ i ] - > ctx ;
2011-11-22 02:54:50 +01:00
oc - > interrupt_callback = int_cb ;
2012-05-25 23:55:56 +02:00
if ( ( ret = avformat_write_header ( oc , & output_files [ i ] - > opts ) ) < 0 ) {
char errbuf [ 128 ] ;
const char * errbuf_ptr = errbuf ;
if ( av_strerror ( ret , errbuf , sizeof ( errbuf ) ) < 0 )
errbuf_ptr = strerror ( AVUNERROR ( ret ) ) ;
snprintf ( error , sizeof ( error ) , " Could not write header for output file #%d (incorrect codec parameters ?): %s " , i , errbuf_ptr ) ;
2007-02-13 19:26:14 +01:00
ret = AVERROR ( EINVAL ) ;
2009-03-11 07:06:18 +01:00
goto dump_format ;
2001-09-25 01:22:25 +02:00
}
2012-04-17 04:01:17 +02:00
// assert_avoptions(output_files[i]->opts);
2011-11-22 02:54:50 +01:00
if ( strcmp ( oc - > oformat - > name , " rtp " ) ) {
2007-08-20 10:12:08 +02:00
want_sdp = 0 ;
}
}
2009-03-11 07:06:18 +01:00
dump_format :
/* dump the file output parameters - cannot be done before in case
of stream copy */
2011-11-22 02:54:50 +01:00
for ( i = 0 ; i < nb_output_files ; i + + ) {
2012-04-15 15:28:30 +02:00
av_dump_format ( output_files [ i ] - > ctx , i , output_files [ i ] - > ctx - > filename , 1 ) ;
2009-03-11 07:06:18 +01:00
}
/* dump the stream mapping */
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_INFO , " Stream mapping: \n " ) ;
2012-04-01 15:08:33 +02:00
for ( i = 0 ; i < nb_input_streams ; i + + ) {
ist = input_streams [ i ] ;
for ( j = 0 ; j < ist - > nb_filters ; j + + ) {
if ( ist - > filters [ j ] - > graph - > graph_desc ) {
av_log ( NULL , AV_LOG_INFO , " Stream #%d:%d (%s) -> %s " ,
ist - > file_index , ist - > st - > index , ist - > dec ? ist - > dec - > name : " ? " ,
2012-05-26 13:31:54 +02:00
ist - > filters [ j ] - > name ) ;
2012-04-01 15:08:33 +02:00
if ( nb_filtergraphs > 1 )
av_log ( NULL , AV_LOG_INFO , " (graph %d) " , ist - > filters [ j ] - > graph - > index ) ;
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
}
}
}
2011-09-27 02:14:37 +02:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
ost = output_streams [ i ] ;
2011-11-04 01:44:06 +01:00
if ( ost - > attachment_filename ) {
/* an attached file */
av_log ( NULL , AV_LOG_INFO , " File %s -> Stream #%d:%d \n " ,
ost - > attachment_filename , ost - > file_index , ost - > index ) ;
continue ;
2009-03-11 07:06:18 +01:00
}
2012-04-01 15:08:33 +02:00
if ( ost - > filter & & ost - > filter - > graph - > graph_desc ) {
/* output from a complex graph */
2012-05-26 13:31:54 +02:00
av_log ( NULL , AV_LOG_INFO , " %s " , ost - > filter - > name ) ;
2012-04-01 15:08:33 +02:00
if ( nb_filtergraphs > 1 )
av_log ( NULL , AV_LOG_INFO , " (graph %d) " , ost - > filter - > graph - > index ) ;
av_log ( NULL , AV_LOG_INFO , " -> Stream #%d:%d (%s) \n " , ost - > file_index ,
ost - > index , ost - > enc ? ost - > enc - > name : " ? " ) ;
continue ;
}
2011-11-07 02:41:01 +01:00
av_log ( NULL , AV_LOG_INFO , " Stream #%d:%d -> #%d:%d " ,
2012-04-15 15:28:30 +02:00
input_streams [ ost - > source_index ] - > file_index ,
input_streams [ ost - > source_index ] - > st - > index ,
2011-09-27 02:14:37 +02:00
ost - > file_index ,
ost - > index ) ;
2012-04-15 15:28:30 +02:00
if ( ost - > sync_ist ! = input_streams [ ost - > source_index ] )
2011-11-07 02:41:01 +01:00
av_log ( NULL , AV_LOG_INFO , " [sync #%d:%d] " ,
2011-09-27 02:14:37 +02:00
ost - > sync_ist - > file_index ,
ost - > sync_ist - > st - > index ) ;
2011-10-26 02:09:31 +02:00
if ( ost - > stream_copy )
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_INFO , " (copy) " ) ;
else
2012-04-15 15:28:30 +02:00
av_log ( NULL , AV_LOG_INFO , " (%s -> %s) " , input_streams [ ost - > source_index ] - > dec ?
input_streams [ ost - > source_index ] - > dec - > name : " ? " ,
2011-09-27 02:14:37 +02:00
ost - > enc ? ost - > enc - > name : " ? " ) ;
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
2009-03-11 07:06:18 +01:00
}
if ( ret ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_ERROR , " %s \n " , error ) ;
2011-08-30 16:03:51 +02:00
return ret ;
2009-03-11 07:06:18 +01:00
}
2007-08-20 10:12:08 +02:00
if ( want_sdp ) {
2012-04-15 15:03:07 +02:00
print_sdp ( ) ;
2001-07-22 16:37:44 +02:00
}
2011-08-30 16:03:51 +02:00
return 0 ;
}
2012-06-01 10:44:11 +02:00
/**
* @ return 1 if there are still streams where more output is wanted ,
* 0 otherwise
*/
static int need_output ( void )
{
int i ;
for ( i = 0 ; i < nb_output_streams ; i + + ) {
OutputStream * ost = output_streams [ i ] ;
OutputFile * of = output_files [ ost - > file_index ] ;
AVFormatContext * os = output_files [ ost - > file_index ] - > ctx ;
if ( ost - > is_past_recording_time | |
( os - > pb & & avio_tell ( os - > pb ) > = of - > limit_filesize ) )
continue ;
2012-06-04 22:54:15 +02:00
if ( ost - > frame_number > = ost - > max_frames ) {
2012-06-01 10:44:11 +02:00
int j ;
for ( j = 0 ; j < of - > ctx - > nb_streams ; j + + )
output_streams [ of - > ost_index + j ] - > is_past_recording_time = 1 ;
continue ;
}
return 1 ;
}
return 0 ;
}
2012-07-23 16:58:22 +02:00
static int input_acceptable ( InputStream * ist )
2012-06-01 11:00:27 +02:00
{
2012-07-21 22:54:08 +02:00
av_assert1 ( ! ist - > discard ) ;
2012-07-23 16:58:22 +02:00
return ! input_files [ ist - > file_index ] - > unavailable & &
2012-07-21 22:54:08 +02:00
! input_files [ ist - > file_index ] - > eof_reached ;
}
2012-06-01 11:00:27 +02:00
2012-07-23 16:58:22 +02:00
static int find_graph_input ( FilterGraph * graph )
2012-07-21 22:54:08 +02:00
{
int i , nb_req_max = 0 , file_index = - 1 ;
for ( i = 0 ; i < graph - > nb_inputs ; i + + ) {
int nb_req = av_buffersrc_get_nb_failed_requests ( graph - > inputs [ i ] - > filter ) ;
if ( nb_req > nb_req_max ) {
InputStream * ist = graph - > inputs [ i ] - > ist ;
2012-07-23 16:58:22 +02:00
if ( input_acceptable ( ist ) ) {
2012-07-21 22:54:08 +02:00
nb_req_max = nb_req ;
2012-06-01 11:00:27 +02:00
file_index = ist - > file_index ;
}
}
}
return file_index ;
}
2012-07-21 22:54:08 +02:00
/**
* Select the input file to read from .
*
* @ return > = 0 index of the input file to use ;
* - 1 if no file is acceptable ;
* - 2 to read from filters without reading from a file
*/
2012-07-23 16:58:22 +02:00
static int select_input_file ( void )
2012-07-21 22:54:08 +02:00
{
int i , ret , nb_active_out = nb_output_streams , ost_index = - 1 ;
int64_t opts_min ;
OutputStream * ost ;
AVFilterBufferRef * dummy ;
2012-07-23 16:58:22 +02:00
for ( i = 0 ; i < nb_output_streams ; i + + )
nb_active_out - = output_streams [ i ] - > unavailable =
output_streams [ i ] - > is_past_recording_time ;
2012-07-21 22:54:08 +02:00
while ( nb_active_out ) {
opts_min = INT64_MAX ;
ost_index = - 1 ;
for ( i = 0 ; i < nb_output_streams ; i + + ) {
OutputStream * ost = output_streams [ i ] ;
int64_t opts = av_rescale_q ( ost - > st - > cur_dts , ost - > st - > time_base ,
AV_TIME_BASE_Q ) ;
2012-07-23 16:58:22 +02:00
if ( ! ost - > unavailable & & opts < opts_min ) {
2012-07-21 22:54:08 +02:00
opts_min = opts ;
ost_index = i ;
}
}
if ( ost_index < 0 )
return - 1 ;
ost = output_streams [ ost_index ] ;
if ( ost - > source_index > = 0 ) {
/* ost is directly connected to an input */
InputStream * ist = input_streams [ ost - > source_index ] ;
2012-07-23 16:58:22 +02:00
if ( input_acceptable ( ist ) )
2012-07-21 22:54:08 +02:00
return ist - > file_index ;
} else {
/* ost is connected to a complex filtergraph */
av_assert1 ( ost - > filter ) ;
ret = av_buffersink_get_buffer_ref ( ost - > filter - > filter , & dummy ,
AV_BUFFERSINK_FLAG_PEEK ) ;
if ( ret > = 0 )
return - 2 ;
2012-07-23 16:58:22 +02:00
ret = find_graph_input ( ost - > filter - > graph ) ;
2012-07-21 22:54:08 +02:00
if ( ret > = 0 )
return ret ;
}
2012-07-23 16:58:22 +02:00
ost - > unavailable = 1 ;
2012-07-21 22:54:08 +02:00
nb_active_out - - ;
}
return - 1 ;
}
2012-06-06 15:56:34 +02:00
static int check_keyboard_interaction ( int64_t cur_time )
{
int i , ret , key ;
static int64_t last_time ;
if ( received_nb_signals )
return AVERROR_EXIT ;
/* read_key() returns 0 on EOF */
if ( cur_time - last_time > = 100000 & & ! run_as_daemon ) {
key = read_key ( ) ;
last_time = cur_time ;
} else
key = - 1 ;
if ( key = = ' q ' )
return AVERROR_EXIT ;
if ( key = = ' + ' ) av_log_set_level ( av_log_get_level ( ) + 10 ) ;
if ( key = = ' - ' ) av_log_set_level ( av_log_get_level ( ) - 10 ) ;
if ( key = = ' s ' ) qp_hist ^ = 1 ;
if ( key = = ' h ' ) {
if ( do_hex_dump ) {
do_hex_dump = do_pkt_dump = 0 ;
} else if ( do_pkt_dump ) {
do_hex_dump = 1 ;
} else
do_pkt_dump = 1 ;
av_log_set_level ( AV_LOG_DEBUG ) ;
}
if ( key = = ' c ' | | key = = ' C ' ) {
char buf [ 4096 ] , target [ 64 ] , command [ 256 ] , arg [ 256 ] = { 0 } ;
double time ;
int k , n = 0 ;
fprintf ( stderr , " \n Enter command: <target> <time> <command>[ <argument>] \n " ) ;
i = 0 ;
while ( ( k = read_key ( ) ) ! = ' \n ' & & k ! = ' \r ' & & i < sizeof ( buf ) - 1 )
if ( k > 0 )
buf [ i + + ] = k ;
buf [ i ] = 0 ;
if ( k > 0 & &
( n = sscanf ( buf , " %63[^ ] %lf %255[^ ] %255[^ \n ] " , target , & time , command , arg ) ) > = 3 ) {
av_log ( NULL , AV_LOG_DEBUG , " Processing command target:%s time:%f command:%s arg:%s " ,
target , time , command , arg ) ;
for ( i = 0 ; i < nb_filtergraphs ; i + + ) {
FilterGraph * fg = filtergraphs [ i ] ;
if ( fg - > graph ) {
if ( time < 0 ) {
ret = avfilter_graph_send_command ( fg - > graph , target , command , arg , buf , sizeof ( buf ) ,
key = = ' c ' ? AVFILTER_CMD_FLAG_ONE : 0 ) ;
fprintf ( stderr , " Command reply for stream %d: ret:%d res:%s \n " , i , ret , buf ) ;
} else {
ret = avfilter_graph_queue_command ( fg - > graph , target , command , arg , 0 , time ) ;
}
}
}
} else {
av_log ( NULL , AV_LOG_ERROR ,
" Parse error, at least 3 arguments were expected, "
" only %d given in string '%s' \n " , n , buf ) ;
}
}
if ( key = = ' d ' | | key = = ' D ' ) {
int debug = 0 ;
if ( key = = ' D ' ) {
debug = input_streams [ 0 ] - > st - > codec - > debug < < 1 ;
if ( ! debug ) debug = 1 ;
while ( debug & ( FF_DEBUG_DCT_COEFF | FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE ) ) //unsupported, would just crash
debug + = debug ;
} else
if ( scanf ( " %d " , & debug ) ! = 1 )
fprintf ( stderr , " error parsing debug value \n " ) ;
for ( i = 0 ; i < nb_input_streams ; i + + ) {
input_streams [ i ] - > st - > codec - > debug = debug ;
}
for ( i = 0 ; i < nb_output_streams ; i + + ) {
OutputStream * ost = output_streams [ i ] ;
ost - > st - > codec - > debug = debug ;
}
if ( debug ) av_log_set_level ( AV_LOG_DEBUG ) ;
fprintf ( stderr , " debug=%d \n " , debug ) ;
}
if ( key = = ' ? ' ) {
fprintf ( stderr , " key function \n "
" ? show this help \n "
" + increase verbosity \n "
" - decrease verbosity \n "
" c Send command to filtergraph \n "
" D cycle through available debug modes \n "
" h dump packets/hex press to cycle through the 3 states \n "
" q quit \n "
" s Show QP histogram \n "
) ;
}
return 0 ;
}
2012-06-11 15:34:12 +02:00
# if HAVE_PTHREADS
2012-06-02 07:26:41 +02:00
static void * input_thread ( void * arg )
{
InputFile * f = arg ;
int ret = 0 ;
while ( ! transcoding_finished & & ret > = 0 ) {
AVPacket pkt ;
ret = av_read_frame ( f - > ctx , & pkt ) ;
if ( ret = = AVERROR ( EAGAIN ) ) {
2012-06-21 21:31:44 +02:00
av_usleep ( 10000 ) ;
2012-06-02 07:26:41 +02:00
ret = 0 ;
continue ;
} else if ( ret < 0 )
break ;
pthread_mutex_lock ( & f - > fifo_lock ) ;
while ( ! av_fifo_space ( f - > fifo ) )
pthread_cond_wait ( & f - > fifo_cond , & f - > fifo_lock ) ;
av_dup_packet ( & pkt ) ;
av_fifo_generic_write ( f - > fifo , & pkt , sizeof ( pkt ) , NULL ) ;
pthread_mutex_unlock ( & f - > fifo_lock ) ;
}
f - > finished = 1 ;
return NULL ;
}
static void free_input_threads ( void )
{
int i ;
if ( nb_input_files = = 1 )
return ;
transcoding_finished = 1 ;
for ( i = 0 ; i < nb_input_files ; i + + ) {
InputFile * f = input_files [ i ] ;
AVPacket pkt ;
2012-06-13 13:33:42 +02:00
if ( ! f - > fifo | | f - > joined )
2012-06-02 07:26:41 +02:00
continue ;
pthread_mutex_lock ( & f - > fifo_lock ) ;
while ( av_fifo_size ( f - > fifo ) ) {
av_fifo_generic_read ( f - > fifo , & pkt , sizeof ( pkt ) , NULL ) ;
av_free_packet ( & pkt ) ;
}
pthread_cond_signal ( & f - > fifo_cond ) ;
pthread_mutex_unlock ( & f - > fifo_lock ) ;
pthread_join ( f - > thread , NULL ) ;
f - > joined = 1 ;
while ( av_fifo_size ( f - > fifo ) ) {
av_fifo_generic_read ( f - > fifo , & pkt , sizeof ( pkt ) , NULL ) ;
av_free_packet ( & pkt ) ;
}
av_fifo_free ( f - > fifo ) ;
}
}
static int init_input_threads ( void )
{
int i , ret ;
if ( nb_input_files = = 1 )
return 0 ;
for ( i = 0 ; i < nb_input_files ; i + + ) {
InputFile * f = input_files [ i ] ;
if ( ! ( f - > fifo = av_fifo_alloc ( 8 * sizeof ( AVPacket ) ) ) )
return AVERROR ( ENOMEM ) ;
pthread_mutex_init ( & f - > fifo_lock , NULL ) ;
pthread_cond_init ( & f - > fifo_cond , NULL ) ;
if ( ( ret = pthread_create ( & f - > thread , NULL , input_thread , f ) ) )
return AVERROR ( ret ) ;
}
return 0 ;
}
static int get_input_packet_mt ( InputFile * f , AVPacket * pkt )
{
int ret = 0 ;
pthread_mutex_lock ( & f - > fifo_lock ) ;
if ( av_fifo_size ( f - > fifo ) ) {
av_fifo_generic_read ( f - > fifo , pkt , sizeof ( * pkt ) , NULL ) ;
pthread_cond_signal ( & f - > fifo_cond ) ;
} else {
if ( f - > finished )
ret = AVERROR_EOF ;
else
ret = AVERROR ( EAGAIN ) ;
}
pthread_mutex_unlock ( & f - > fifo_lock ) ;
return ret ;
}
# endif
static int get_input_packet ( InputFile * f , AVPacket * pkt )
{
2012-06-11 15:34:12 +02:00
# if HAVE_PTHREADS
2012-06-02 07:26:41 +02:00
if ( nb_input_files > 1 )
return get_input_packet_mt ( f , pkt ) ;
# endif
return av_read_frame ( f - > ctx , pkt ) ;
}
2011-08-30 16:03:51 +02:00
/*
* The following code is the main loop of the file converter
*/
2012-04-15 15:03:07 +02:00
static int transcode ( void )
2011-08-30 16:03:51 +02:00
{
int ret , i ;
AVFormatContext * is , * os ;
OutputStream * ost ;
InputStream * ist ;
2011-12-30 03:46:24 +01:00
int no_packet_count = 0 ;
2011-08-30 16:03:51 +02:00
int64_t timer_start ;
2012-04-15 15:03:07 +02:00
ret = transcode_init ( ) ;
2011-08-30 16:03:51 +02:00
if ( ret < 0 )
goto fail ;
2012-07-14 17:52:51 +02:00
if ( stdin_interaction ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_INFO , " Press [q] to stop, [?] for help \n " ) ;
2004-03-14 20:40:43 +01:00
}
2001-09-25 01:22:25 +02:00
2007-03-16 17:13:54 +01:00
timer_start = av_gettime ( ) ;
2002-05-09 03:06:59 +02:00
2012-06-11 15:34:12 +02:00
# if HAVE_PTHREADS
2012-06-02 07:26:41 +02:00
if ( ( ret = init_input_threads ( ) ) < 0 )
goto fail ;
# endif
2011-12-30 03:46:24 +01:00
for ( ; received_sigterm = = 0 ; ) {
2012-06-01 10:44:11 +02:00
int file_index , ist_index ;
2001-07-22 16:37:44 +02:00
AVPacket pkt ;
2011-10-08 17:32:06 +02:00
int64_t cur_time = av_gettime ( ) ;
2004-06-30 00:56:54 +02:00
2001-09-25 01:22:25 +02:00
/* if 'q' pressed, exits */
2012-07-14 17:52:51 +02:00
if ( stdin_interaction )
2012-06-06 15:56:34 +02:00
if ( check_keyboard_interaction ( cur_time ) < 0 )
2002-05-30 04:38:57 +02:00
break ;
2001-09-25 01:22:25 +02:00
2012-04-01 15:08:33 +02:00
/* check if there's any stream where output is still needed */
2012-06-01 10:44:11 +02:00
if ( ! need_output ( ) ) {
av_log ( NULL , AV_LOG_VERBOSE , " No more output streams to write to, finishing. \n " ) ;
2012-04-01 15:08:33 +02:00
break ;
2001-07-22 16:37:44 +02:00
}
2012-04-01 15:08:33 +02:00
2012-06-01 11:00:27 +02:00
/* select the stream that we must read now */
2012-07-23 16:58:22 +02:00
file_index = select_input_file ( ) ;
2001-07-22 16:37:44 +02:00
/* if none, if is finished */
2012-07-21 22:54:08 +02:00
if ( file_index = = - 2 ) {
poll_filters ( ) ;
continue ;
}
2002-05-09 03:06:59 +02:00
if ( file_index < 0 ) {
2011-12-30 03:46:24 +01:00
if ( no_packet_count ) {
no_packet_count = 0 ;
2012-07-23 16:58:22 +02:00
for ( i = 0 ; i < nb_input_files ; i + + )
input_files [ i ] - > unavailable = 0 ;
2012-06-21 21:31:44 +02:00
av_usleep ( 10000 ) ;
2009-03-03 20:50:04 +01:00
continue ;
}
2012-06-02 07:26:41 +02:00
av_log ( NULL , AV_LOG_VERBOSE , " No more inputs to read from, finishing. \n " ) ;
2001-07-22 16:37:44 +02:00
break ;
2002-10-21 19:42:47 +02:00
}
2012-04-15 15:28:30 +02:00
is = input_files [ file_index ] - > ctx ;
2012-06-02 07:26:41 +02:00
ret = get_input_packet ( input_files [ file_index ] , & pkt ) ;
2011-12-30 03:46:24 +01:00
if ( ret = = AVERROR ( EAGAIN ) ) {
2012-07-23 16:58:22 +02:00
input_files [ file_index ] - > unavailable = 1 ;
2009-03-03 20:50:04 +01:00
no_packet_count + + ;
2009-01-22 13:04:01 +01:00
continue ;
2009-03-03 20:50:04 +01:00
}
2009-01-22 13:04:01 +01:00
if ( ret < 0 ) {
2012-07-16 00:22:05 +02:00
if ( ret ! = AVERROR_EOF ) {
print_error ( is - > filename , ret ) ;
if ( exit_on_error )
exit_program ( 1 ) ;
}
2012-04-15 15:28:30 +02:00
input_files [ file_index ] - > eof_reached = 1 ;
2012-04-02 20:13:29 +02:00
for ( i = 0 ; i < input_files [ file_index ] - > nb_streams ; i + + ) {
ist = input_streams [ input_files [ file_index ] - > ist_index + i ] ;
if ( ist - > decoding_needed )
output_packet ( ist , NULL ) ;
2012-07-21 22:54:08 +02:00
poll_filters ( ) ;
2012-04-02 20:13:29 +02:00
}
2007-07-19 02:44:47 +02:00
if ( opt_shortest )
break ;
else
continue ;
2001-07-22 16:37:44 +02:00
}
2004-01-22 20:48:28 +01:00
2011-12-30 03:46:24 +01:00
no_packet_count = 0 ;
2012-07-23 16:58:22 +02:00
for ( i = 0 ; i < nb_input_files ; i + + )
input_files [ i ] - > unavailable = 0 ;
2009-03-03 20:50:04 +01:00
2003-11-10 19:54:17 +01:00
if ( do_pkt_dump ) {
2011-02-24 09:08:07 +01:00
av_pkt_dump_log2 ( NULL , AV_LOG_DEBUG , & pkt , do_hex_dump ,
is - > streams [ pkt . stream_index ] ) ;
2003-01-11 06:05:47 +01:00
}
2002-05-20 18:32:49 +02:00
/* the following test is needed in case new streams appear
dynamically in stream : we ignore them */
2012-07-25 17:46:00 +02:00
if ( pkt . stream_index > = input_files [ file_index ] - > nb_streams ) {
report_new_stream ( file_index , & pkt ) ;
2002-05-26 00:25:13 +02:00
goto discard_packet ;
2012-07-25 17:46:00 +02:00
}
2012-04-15 15:28:30 +02:00
ist_index = input_files [ file_index ] - > ist_index + pkt . stream_index ;
ist = input_streams [ ist_index ] ;
2002-05-26 00:25:13 +02:00
if ( ist - > discard )
goto discard_packet ;
2001-07-22 16:37:44 +02:00
2007-08-03 21:21:50 +02:00
if ( pkt . dts ! = AV_NOPTS_VALUE )
2012-04-15 15:28:30 +02:00
pkt . dts + = av_rescale_q ( input_files [ ist - > file_index ] - > ts_offset , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
2007-08-03 21:21:50 +02:00
if ( pkt . pts ! = AV_NOPTS_VALUE )
2012-04-15 15:28:30 +02:00
pkt . pts + = av_rescale_q ( input_files [ ist - > file_index ] - > ts_offset , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
2007-08-03 21:21:50 +02:00
2011-12-30 03:46:24 +01:00
if ( pkt . pts ! = AV_NOPTS_VALUE )
2011-09-05 22:10:26 +02:00
pkt . pts * = ist - > ts_scale ;
2011-12-30 03:46:24 +01:00
if ( pkt . dts ! = AV_NOPTS_VALUE )
2011-09-05 22:10:26 +02:00
pkt . dts * = ist - > ts_scale ;
2008-07-14 00:55:52 +02:00
2012-01-20 17:06:26 +01:00
if ( debug_ts ) {
av_log ( NULL , AV_LOG_INFO , " demuxer -> ist_index:%d type:%s "
2012-05-07 18:30:26 +02:00
" next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:% " PRId64 " \n " ,
2012-01-20 17:06:26 +01:00
ist_index , av_get_media_type_string ( ist - > st - > codec - > codec_type ) ,
2012-07-26 17:12:07 +02:00
av_ts2str ( ist - > next_dts ) , av_ts2timestr ( ist - > next_dts , & AV_TIME_BASE_Q ) ,
av_ts2str ( ist - > next_pts ) , av_ts2timestr ( ist - > next_pts , & AV_TIME_BASE_Q ) ,
2012-01-20 17:06:26 +01:00
av_ts2str ( pkt . pts ) , av_ts2timestr ( pkt . pts , & ist - > st - > time_base ) ,
av_ts2str ( pkt . dts ) , av_ts2timestr ( pkt . dts , & ist - > st - > time_base ) ,
2012-04-17 04:01:17 +02:00
input_files [ ist - > file_index ] - > ts_offset ) ;
2012-01-20 17:06:26 +01:00
}
2012-02-07 23:43:10 +01:00
if ( pkt . dts ! = AV_NOPTS_VALUE & & ist - > next_dts ! = AV_NOPTS_VALUE & & ! copy_ts ) {
2011-12-30 03:46:24 +01:00
int64_t pkt_dts = av_rescale_q ( pkt . dts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
2012-02-08 08:21:58 +01:00
int64_t delta = pkt_dts - ist - > next_dts ;
2012-02-07 23:43:10 +01:00
if ( is - > iformat - > flags & AVFMT_TS_DISCONT ) {
if ( delta < - 1LL * dts_delta_threshold * AV_TIME_BASE | |
2011-08-16 15:49:17 +02:00
( delta > 1LL * dts_delta_threshold * AV_TIME_BASE & &
ist - > st - > codec - > codec_type ! = AVMEDIA_TYPE_SUBTITLE ) | |
2012-02-07 23:43:10 +01:00
pkt_dts + 1 < ist - > pts ) {
2012-04-15 15:28:30 +02:00
input_files [ ist - > file_index ] - > ts_offset - = delta ;
2011-12-30 03:46:24 +01:00
av_log ( NULL , AV_LOG_DEBUG ,
" timestamp discontinuity % " PRId64 " , new offset= % " PRId64 " \n " ,
2012-04-15 15:28:30 +02:00
delta , input_files [ ist - > file_index ] - > ts_offset ) ;
2007-08-03 21:21:50 +02:00
pkt . dts - = av_rescale_q ( delta , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
2011-12-30 03:46:24 +01:00
if ( pkt . pts ! = AV_NOPTS_VALUE )
2007-08-03 21:21:50 +02:00
pkt . pts - = av_rescale_q ( delta , AV_TIME_BASE_Q , ist - > st - > time_base ) ;
2004-06-12 05:41:36 +02:00
}
2012-02-07 23:43:10 +01:00
} else {
if ( delta < - 1LL * dts_error_threshold * AV_TIME_BASE | |
( delta > 1LL * dts_error_threshold * AV_TIME_BASE & & ist - > st - > codec - > codec_type ! = AVMEDIA_TYPE_SUBTITLE ) | |
pkt_dts + 1 < ist - > pts ) {
2012-04-04 11:50:16 +02:00
av_log ( NULL , AV_LOG_WARNING , " DTS % " PRId64 " , next:% " PRId64 " st:%d invalid dropping \n " , pkt . dts , ist - > next_dts , pkt . stream_index ) ;
2012-02-07 23:43:10 +01:00
pkt . dts = AV_NOPTS_VALUE ;
}
if ( pkt . pts ! = AV_NOPTS_VALUE ) {
int64_t pkt_pts = av_rescale_q ( pkt . pts , ist - > st - > time_base , AV_TIME_BASE_Q ) ;
delta = pkt_pts - ist - > next_dts ;
if ( delta < - 1LL * dts_error_threshold * AV_TIME_BASE | |
2012-03-29 22:32:53 +02:00
( delta > 1LL * dts_error_threshold * AV_TIME_BASE & & ist - > st - > codec - > codec_type ! = AVMEDIA_TYPE_SUBTITLE ) | |
pkt_pts + 1 < ist - > pts ) {
2012-04-04 11:50:16 +02:00
av_log ( NULL , AV_LOG_WARNING , " PTS % " PRId64 " , next:% " PRId64 " invalid dropping st:%d \n " , pkt . pts , ist - > next_dts , pkt . stream_index ) ;
2012-02-07 23:43:10 +01:00
pkt . pts = AV_NOPTS_VALUE ;
}
}
}
2004-06-12 05:41:36 +02:00
}
2011-12-30 03:46:24 +01:00
// fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2012-06-01 18:24:02 +02:00
if ( ( ret = output_packet ( ist , & pkt ) ) < 0 | |
2012-04-24 10:52:55 +02:00
( ( ret = poll_filters ( ) ) < 0 & & ret ! = AVERROR_EOF ) ) {
2012-06-01 18:24:02 +02:00
char buf [ 128 ] ;
av_strerror ( ret , buf , sizeof ( buf ) ) ;
av_log ( NULL , AV_LOG_ERROR , " Error while decoding stream #%d:%d: %s \n " ,
ist - > file_index , ist - > st - > index , buf ) ;
2008-09-05 01:23:44 +02:00
if ( exit_on_error )
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2003-12-15 15:43:44 +01:00
av_free_packet ( & pkt ) ;
2011-08-30 16:39:05 +02:00
continue ;
2003-10-14 16:36:58 +02:00
}
2005-06-03 16:31:45 +02:00
2002-05-26 00:25:13 +02:00
discard_packet :
2001-07-22 16:37:44 +02:00
av_free_packet ( & pkt ) ;
2005-12-17 19:14:38 +01:00
2002-10-21 19:42:47 +02:00
/* dump report by using the output first video and audio streams */
2012-04-17 04:01:17 +02:00
print_report ( 0 , timer_start , cur_time ) ;
2001-07-22 16:37:44 +02:00
}
2012-06-11 15:34:12 +02:00
# if HAVE_PTHREADS
2012-06-02 07:26:41 +02:00
free_input_threads ( ) ;
# endif
2003-12-15 15:43:44 +01:00
/* at the end of stream, we must flush the decoder buffers */
2011-05-22 22:12:35 +02:00
for ( i = 0 ; i < nb_input_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
ist = input_streams [ i ] ;
2012-04-02 20:13:29 +02:00
if ( ! input_files [ ist - > file_index ] - > eof_reached & & ist - > decoding_needed ) {
2012-04-15 15:03:07 +02:00
output_packet ( ist , NULL ) ;
2003-12-15 15:43:44 +01:00
}
}
2012-03-29 08:51:17 +02:00
poll_filters ( ) ;
2012-04-15 15:03:07 +02:00
flush_encoders ( ) ;
2003-12-15 15:43:44 +01:00
2001-09-25 01:22:25 +02:00
term_exit ( ) ;
2001-07-22 16:37:44 +02:00
2004-03-05 23:51:22 +01:00
/* write the trailer if needed and close file */
2011-12-30 03:46:24 +01:00
for ( i = 0 ; i < nb_output_files ; i + + ) {
2012-04-15 15:28:30 +02:00
os = output_files [ i ] - > ctx ;
2004-03-05 23:51:22 +01:00
av_write_trailer ( os ) ;
}
2004-04-15 18:34:38 +02:00
/* dump report by using the first video and audio streams */
2012-04-17 04:01:17 +02:00
print_report ( 1 , timer_start , av_gettime ( ) ) ;
2004-04-15 18:34:38 +02:00
2001-07-22 16:37:44 +02:00
/* close each encoder */
2011-08-30 15:03:53 +02:00
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
ost = output_streams [ i ] ;
2001-07-22 16:37:44 +02:00
if ( ost - > encoding_needed ) {
2005-07-18 00:24:36 +02:00
av_freep ( & ost - > st - > codec - > stats_in ) ;
avcodec_close ( ost - > st - > codec ) ;
2001-07-22 16:37:44 +02:00
}
}
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
/* close each decoder */
2011-05-22 22:12:35 +02:00
for ( i = 0 ; i < nb_input_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
ist = input_streams [ i ] ;
2001-07-22 16:37:44 +02:00
if ( ist - > decoding_needed ) {
2005-07-18 00:24:36 +02:00
avcodec_close ( ist - > st - > codec ) ;
2001-07-22 16:37:44 +02:00
}
}
/* finished ! */
2009-03-11 07:13:14 +01:00
ret = 0 ;
2005-12-17 19:14:38 +01:00
2009-03-11 07:06:18 +01:00
fail :
2012-06-11 15:34:12 +02:00
# if HAVE_PTHREADS
2012-06-02 07:26:41 +02:00
free_input_threads ( ) ;
# endif
2001-08-13 23:43:02 +02:00
2011-08-30 15:03:53 +02:00
if ( output_streams ) {
for ( i = 0 ; i < nb_output_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
ost = output_streams [ i ] ;
2001-07-22 16:37:44 +02:00
if ( ost ) {
2011-10-26 02:09:31 +02:00
if ( ost - > stream_copy )
2010-06-08 21:27:29 +02:00
av_freep ( & ost - > st - > codec - > extradata ) ;
2002-10-10 19:09:01 +02:00
if ( ost - > logfile ) {
fclose ( ost - > logfile ) ;
ost - > logfile = NULL ;
}
2010-11-13 14:57:49 +01:00
av_freep ( & ost - > st - > codec - > subtitle_header ) ;
2010-10-18 23:47:15 +02:00
av_free ( ost - > forced_kf_pts ) ;
2011-05-25 17:29:25 +02:00
av_dict_free ( & ost - > opts ) ;
2001-07-22 16:37:44 +02:00
}
}
}
return ret ;
}
2010-10-18 15:34:46 +02:00
static int opt_frame_crop ( const char * opt , const char * arg )
2002-09-01 09:19:38 +02:00
{
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Option '%s' has been removed, use the crop filter instead \n " , opt ) ;
2010-10-18 15:34:46 +02:00
return AVERROR ( EINVAL ) ;
2002-09-01 09:19:38 +02:00
}
2011-09-12 11:44:14 +02:00
static int opt_pad ( const char * opt , const char * arg )
{
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Option '%s' has been removed, use the pad filter instead \n " , opt ) ;
2010-07-04 22:59:02 +02:00
return - 1 ;
2004-04-08 20:54:40 +02:00
}
2011-04-11 13:16:07 +02:00
static int opt_video_channel ( const char * opt , const char * arg )
2003-01-23 19:44:26 +01:00
{
2011-06-15 07:34:12 +02:00
av_log ( NULL , AV_LOG_WARNING , " This option is deprecated, use -channel. \n " ) ;
2011-08-01 00:36:52 +02:00
return opt_default ( " channel " , arg ) ;
2003-01-23 19:44:26 +01:00
}
2011-05-24 18:14:42 +02:00
static int opt_video_standard ( const char * opt , const char * arg )
2003-06-25 12:21:45 +02:00
{
2011-06-15 07:34:12 +02:00
av_log ( NULL , AV_LOG_WARNING , " This option is deprecated, use -standard. \n " ) ;
2011-08-01 00:36:52 +02:00
return opt_default ( " standard " , arg ) ;
2003-06-25 12:21:45 +02:00
}
2011-09-05 22:10:26 +02:00
static int opt_audio_codec ( OptionsContext * o , const char * opt , const char * arg )
2001-07-22 16:37:44 +02:00
{
2011-09-05 22:10:26 +02:00
audio_codec_name = arg ;
return parse_option ( o , " codec:a " , arg , options ) ;
2001-07-22 16:37:44 +02:00
}
2011-09-05 22:10:26 +02:00
static int opt_video_codec ( OptionsContext * o , const char * opt , const char * arg )
2011-08-30 04:06:57 +02:00
{
2011-09-05 22:10:26 +02:00
video_codec_name = arg ;
return parse_option ( o , " codec:v " , arg , options ) ;
2011-08-30 04:06:57 +02:00
}
2011-09-05 22:10:26 +02:00
static int opt_subtitle_codec ( OptionsContext * o , const char * opt , const char * arg )
2011-08-30 04:06:57 +02:00
{
2011-09-05 22:10:26 +02:00
subtitle_codec_name = arg ;
return parse_option ( o , " codec:s " , arg , options ) ;
2011-08-30 04:06:57 +02:00
}
2011-09-05 22:10:26 +02:00
static int opt_data_codec ( OptionsContext * o , const char * opt , const char * arg )
2011-08-30 04:06:57 +02:00
{
2011-09-05 22:10:26 +02:00
return parse_option ( o , " codec:d " , arg , options ) ;
2011-08-30 04:06:57 +02:00
}
2011-09-05 02:04:27 +02:00
static int opt_map ( OptionsContext * o , const char * opt , const char * arg )
2001-07-22 16:37:44 +02:00
{
2011-08-30 04:06:24 +02:00
StreamMap * m = NULL ;
int i , negative = 0 , file_idx ;
2012-01-03 00:28:06 +01:00
int sync_file_idx = - 1 , sync_stream_idx = 0 ;
2011-08-30 04:06:24 +02:00
char * p , * sync ;
char * map ;
2001-07-22 16:37:44 +02:00
2011-08-30 04:06:24 +02:00
if ( * arg = = ' - ' ) {
negative = 1 ;
arg + + ;
}
map = av_strdup ( arg ) ;
2001-07-22 16:37:44 +02:00
2011-08-30 04:06:24 +02:00
/* parse sync stream first, just pick first matching stream */
if ( sync = strchr ( map , ' , ' ) ) {
* sync = 0 ;
sync_file_idx = strtol ( sync + 1 , & sync , 0 ) ;
if ( sync_file_idx > = nb_input_files | | sync_file_idx < 0 ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Invalid sync file index: %d. \n " , sync_file_idx ) ;
2011-08-30 04:06:24 +02:00
exit_program ( 1 ) ;
}
if ( * sync )
sync + + ;
2012-04-15 15:28:30 +02:00
for ( i = 0 ; i < input_files [ sync_file_idx ] - > nb_streams ; i + + )
if ( check_stream_specifier ( input_files [ sync_file_idx ] - > ctx ,
input_files [ sync_file_idx ] - > ctx - > streams [ i ] , sync ) = = 1 ) {
2011-08-30 04:06:24 +02:00
sync_stream_idx = i ;
break ;
}
2012-04-15 15:28:30 +02:00
if ( i = = input_files [ sync_file_idx ] - > nb_streams ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Sync stream specification in map %s does not "
2011-08-30 04:06:24 +02:00
" match any streams. \n " , arg ) ;
exit_program ( 1 ) ;
}
}
2002-05-12 01:27:14 +02:00
2011-08-30 04:06:24 +02:00
2012-04-01 15:08:33 +02:00
if ( map [ 0 ] = = ' [ ' ) {
/* this mapping refers to lavfi output */
const char * c = map + 1 ;
o - > stream_maps = grow_array ( o - > stream_maps , sizeof ( * o - > stream_maps ) ,
& o - > nb_stream_maps , o - > nb_stream_maps + 1 ) ;
m = & o - > stream_maps [ o - > nb_stream_maps - 1 ] ;
m - > linklabel = av_get_token ( & c , " ] " ) ;
if ( ! m - > linklabel ) {
av_log ( NULL , AV_LOG_ERROR , " Invalid output link label: %s. \n " , map ) ;
exit_program ( 1 ) ;
}
} else {
2012-03-30 22:07:56 +02:00
file_idx = strtol ( map , & p , 0 ) ;
if ( file_idx > = nb_input_files | | file_idx < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Invalid input file index: %d. \n " , file_idx ) ;
exit_program ( 1 ) ;
2011-08-30 04:06:24 +02:00
}
2012-03-30 22:07:56 +02:00
if ( negative )
/* disable some already defined maps */
for ( i = 0 ; i < o - > nb_stream_maps ; i + + ) {
m = & o - > stream_maps [ i ] ;
if ( file_idx = = m - > file_index & &
check_stream_specifier ( input_files [ m - > file_index ] - > ctx ,
input_files [ m - > file_index ] - > ctx - > streams [ m - > stream_index ] ,
* p = = ' : ' ? p + 1 : p ) > 0 )
m - > disabled = 1 ;
}
else
for ( i = 0 ; i < input_files [ file_idx ] - > nb_streams ; i + + ) {
if ( check_stream_specifier ( input_files [ file_idx ] - > ctx , input_files [ file_idx ] - > ctx - > streams [ i ] ,
* p = = ' : ' ? p + 1 : p ) < = 0 )
continue ;
o - > stream_maps = grow_array ( o - > stream_maps , sizeof ( * o - > stream_maps ) ,
& o - > nb_stream_maps , o - > nb_stream_maps + 1 ) ;
m = & o - > stream_maps [ o - > nb_stream_maps - 1 ] ;
m - > file_index = file_idx ;
m - > stream_index = i ;
if ( sync_file_idx > = 0 ) {
m - > sync_file_index = sync_file_idx ;
m - > sync_stream_index = sync_stream_idx ;
} else {
m - > sync_file_index = file_idx ;
m - > sync_stream_index = i ;
}
2011-08-30 04:06:24 +02:00
}
2012-04-01 15:08:33 +02:00
}
2011-08-30 04:06:24 +02:00
if ( ! m ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Stream map '%s' matches no streams. \n " , arg ) ;
2011-08-30 04:06:24 +02:00
exit_program ( 1 ) ;
}
av_freep ( & map ) ;
2011-05-24 18:14:42 +02:00
return 0 ;
2001-07-22 16:37:44 +02:00
}
2011-11-04 01:44:06 +01:00
static int opt_attach ( OptionsContext * o , const char * opt , const char * arg )
2011-04-14 13:32:36 +02:00
{
2011-11-04 01:44:06 +01:00
o - > attachments = grow_array ( o - > attachments , sizeof ( * o - > attachments ) ,
& o - > nb_attachments , o - > nb_attachments + 1 ) ;
o - > attachments [ o - > nb_attachments - 1 ] = arg ;
return 0 ;
2011-04-14 13:32:36 +02:00
}
2011-11-04 18:54:01 +01:00
static int opt_map_channel ( OptionsContext * o , const char * opt , const char * arg )
{
int n ;
AVStream * st ;
AudioChannelMap * m ;
o - > audio_channel_maps =
grow_array ( o - > audio_channel_maps , sizeof ( * o - > audio_channel_maps ) ,
& o - > nb_audio_channel_maps , o - > nb_audio_channel_maps + 1 ) ;
m = & o - > audio_channel_maps [ o - > nb_audio_channel_maps - 1 ] ;
/* muted channel syntax */
n = sscanf ( arg , " %d:%d.%d " , & m - > channel_idx , & m - > ofile_idx , & m - > ostream_idx ) ;
if ( ( n = = 1 | | n = = 3 ) & & m - > channel_idx = = - 1 ) {
m - > file_idx = m - > stream_idx = - 1 ;
if ( n = = 1 )
m - > ofile_idx = m - > ostream_idx = - 1 ;
return 0 ;
}
/* normal syntax */
n = sscanf ( arg , " %d.%d.%d:%d.%d " ,
& m - > file_idx , & m - > stream_idx , & m - > channel_idx ,
& m - > ofile_idx , & m - > ostream_idx ) ;
if ( n ! = 3 & & n ! = 5 ) {
av_log ( NULL , AV_LOG_FATAL , " Syntax error, mapchan usage: "
" [file.stream.channel|-1][:syncfile:syncstream] \n " ) ;
exit_program ( 1 ) ;
}
if ( n ! = 5 ) // only file.stream.channel specified
m - > ofile_idx = m - > ostream_idx = - 1 ;
/* check input */
if ( m - > file_idx < 0 | | m - > file_idx > = nb_input_files ) {
av_log ( NULL , AV_LOG_FATAL , " mapchan: invalid input file index: %d \n " ,
m - > file_idx ) ;
exit_program ( 1 ) ;
}
if ( m - > stream_idx < 0 | |
2012-04-17 04:01:17 +02:00
m - > stream_idx > = input_files [ m - > file_idx ] - > nb_streams ) {
2011-11-04 18:54:01 +01:00
av_log ( NULL , AV_LOG_FATAL , " mapchan: invalid input file stream index #%d.%d \n " ,
m - > file_idx , m - > stream_idx ) ;
exit_program ( 1 ) ;
}
2012-04-17 04:01:17 +02:00
st = input_files [ m - > file_idx ] - > ctx - > streams [ m - > stream_idx ] ;
2011-11-04 18:54:01 +01:00
if ( st - > codec - > codec_type ! = AVMEDIA_TYPE_AUDIO ) {
av_log ( NULL , AV_LOG_FATAL , " mapchan: stream #%d.%d is not an audio stream. \n " ,
m - > file_idx , m - > stream_idx ) ;
exit_program ( 1 ) ;
}
if ( m - > channel_idx < 0 | | m - > channel_idx > = st - > codec - > channels ) {
av_log ( NULL , AV_LOG_FATAL , " mapchan: invalid audio channel #%d.%d.%d \n " ,
m - > file_idx , m - > stream_idx , m - > channel_idx ) ;
exit_program ( 1 ) ;
}
return 0 ;
}
2011-12-17 01:36:59 +01:00
/**
* Parse a metadata specifier in arg .
* @ param type metadata type is written here - - g ( lobal ) / s ( tream ) / c ( hapter ) / p ( rogram )
* @ param index for type c / p , chapter / program index is written here
* @ param stream_spec for type s , the stream specifier is written here
*/
static void parse_meta_type ( char * arg , char * type , int * index , const char * * stream_spec )
2010-11-02 07:01:28 +01:00
{
2011-09-05 22:10:26 +02:00
if ( * arg ) {
* type = * arg ;
2010-11-02 07:01:28 +01:00
switch ( * arg ) {
case ' g ' :
break ;
case ' s ' :
2011-12-17 01:36:59 +01:00
if ( * ( + + arg ) & & * arg ! = ' : ' ) {
av_log ( NULL , AV_LOG_FATAL , " Invalid metadata specifier %s. \n " , arg ) ;
exit_program ( 1 ) ;
}
* stream_spec = * arg = = ' : ' ? arg + 1 : " " ;
break ;
2010-11-02 07:01:28 +01:00
case ' c ' :
case ' p ' :
2011-08-30 01:30:11 +02:00
if ( * ( + + arg ) = = ' : ' )
* index = strtol ( + + arg , NULL , 0 ) ;
2010-11-02 07:01:28 +01:00
break ;
default :
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Invalid metadata type %c. \n " , * arg ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2010-11-02 07:01:28 +01:00
}
} else
* type = ' g ' ;
}
2011-12-17 01:36:59 +01:00
static int copy_metadata ( char * outspec , char * inspec , AVFormatContext * oc , AVFormatContext * ic , OptionsContext * o )
2004-07-21 03:35:32 +02:00
{
2011-12-17 01:36:59 +01:00
AVDictionary * * meta_in = NULL ;
2012-01-03 00:28:06 +01:00
AVDictionary * * meta_out = NULL ;
2011-12-17 01:36:59 +01:00
int i , ret = 0 ;
char type_in , type_out ;
const char * istream_spec = NULL , * ostream_spec = NULL ;
int idx_in = 0 , idx_out = 0 ;
2004-07-21 03:35:32 +02:00
2011-12-17 01:36:59 +01:00
parse_meta_type ( inspec , & type_in , & idx_in , & istream_spec ) ;
parse_meta_type ( outspec , & type_out , & idx_out , & ostream_spec ) ;
2010-11-02 07:12:54 +01:00
2012-03-16 04:07:59 +01:00
if ( ! ic ) {
if ( type_out = = ' g ' | | ! * outspec )
o - > metadata_global_manual = 1 ;
if ( type_out = = ' s ' | | ! * outspec )
o - > metadata_streams_manual = 1 ;
if ( type_out = = ' c ' | | ! * outspec )
o - > metadata_chapters_manual = 1 ;
return 0 ;
}
2011-12-17 01:36:59 +01:00
if ( type_in = = ' g ' | | type_out = = ' g ' )
2011-09-05 22:10:26 +02:00
o - > metadata_global_manual = 1 ;
2011-12-17 01:36:59 +01:00
if ( type_in = = ' s ' | | type_out = = ' s ' )
2011-09-05 22:10:26 +02:00
o - > metadata_streams_manual = 1 ;
2011-12-17 01:36:59 +01:00
if ( type_in = = ' c ' | | type_out = = ' c ' )
2011-09-05 22:10:26 +02:00
o - > metadata_chapters_manual = 1 ;
2011-05-24 18:14:42 +02:00
2011-12-17 01:36:59 +01:00
# define METADATA_CHECK_INDEX(index, nb_elems, desc)\
if ( ( index ) < 0 | | ( index ) > = ( nb_elems ) ) { \
av_log ( NULL , AV_LOG_FATAL , " Invalid %s index %d while processing metadata maps. \n " , \
( desc ) , ( index ) ) ; \
exit_program ( 1 ) ; \
}
2004-07-21 03:35:32 +02:00
2011-12-17 01:36:59 +01:00
# define SET_DICT(type, meta, context, index)\
switch ( type ) { \
case ' g ' : \
meta = & context - > metadata ; \
break ; \
case ' c ' : \
METADATA_CHECK_INDEX ( index , context - > nb_chapters , " chapter " ) \
meta = & context - > chapters [ index ] - > metadata ; \
break ; \
case ' p ' : \
METADATA_CHECK_INDEX ( index , context - > nb_programs , " program " ) \
meta = & context - > programs [ index ] - > metadata ; \
break ; \
2012-06-25 13:19:51 +02:00
default : av_assert0 ( 0 ) ; \
2011-12-17 01:36:59 +01:00
} \
SET_DICT ( type_in , meta_in , ic , idx_in ) ;
SET_DICT ( type_out , meta_out , oc , idx_out ) ;
/* for input streams choose first matching stream */
if ( type_in = = ' s ' ) {
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
if ( ( ret = check_stream_specifier ( ic , ic - > streams [ i ] , istream_spec ) ) > 0 ) {
meta_in = & ic - > streams [ i ] - > metadata ;
break ;
} else if ( ret < 0 )
exit_program ( 1 ) ;
}
if ( ! meta_in ) {
av_log ( NULL , AV_LOG_FATAL , " Stream specifier %s does not match any streams. \n " , istream_spec ) ;
exit_program ( 1 ) ;
}
}
2004-07-21 03:35:32 +02:00
2011-12-17 01:36:59 +01:00
if ( type_out = = ' s ' ) {
for ( i = 0 ; i < oc - > nb_streams ; i + + ) {
if ( ( ret = check_stream_specifier ( oc , oc - > streams [ i ] , ostream_spec ) ) > 0 ) {
meta_out = & oc - > streams [ i ] - > metadata ;
av_dict_copy ( meta_out , * meta_in , AV_DICT_DONT_OVERWRITE ) ;
} else if ( ret < 0 )
exit_program ( 1 ) ;
}
} else
av_dict_copy ( meta_out , * meta_in , AV_DICT_DONT_OVERWRITE ) ;
2011-05-28 01:53:00 +02:00
return 0 ;
2008-07-14 00:55:52 +02:00
}
2011-09-05 22:10:26 +02:00
static int opt_recording_timestamp ( OptionsContext * o , const char * opt , const char * arg )
2004-04-06 08:31:12 +02:00
{
2011-07-07 11:25:03 +02:00
char buf [ 128 ] ;
int64_t recording_timestamp = parse_time_or_die ( opt , arg , 0 ) / 1E6 ;
struct tm time = * gmtime ( ( time_t * ) & recording_timestamp ) ;
strftime ( buf , sizeof ( buf ) , " creation_time=%FT%T%z " , & time ) ;
2011-09-05 22:10:26 +02:00
parse_option ( o , " metadata " , buf , options ) ;
2011-07-07 11:25:03 +02:00
av_log ( NULL , AV_LOG_WARNING , " %s is deprecated, set the 'creation_time' metadata "
" tag instead. \n " , opt ) ;
2008-03-22 16:12:04 +01:00
return 0 ;
2004-04-06 08:31:12 +02:00
}
2011-10-26 02:09:31 +02:00
static AVCodec * find_codec_or_die ( const char * name , enum AVMediaType type , int encoder )
2011-08-30 04:19:26 +02:00
{
const char * codec_string = encoder ? " encoder " : " decoder " ;
AVCodec * codec ;
codec = encoder ?
avcodec_find_encoder_by_name ( name ) :
avcodec_find_decoder_by_name ( name ) ;
2011-12-30 03:46:24 +01:00
if ( ! codec ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Unknown %s '%s' \n " , codec_string , name ) ;
2011-08-30 04:19:26 +02:00
exit_program ( 1 ) ;
}
2011-12-30 03:46:24 +01:00
if ( codec - > type ! = type ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Invalid %s type '%s' \n " , codec_string , name ) ;
2011-08-30 04:19:26 +02:00
exit_program ( 1 ) ;
}
2011-10-26 02:09:31 +02:00
return codec ;
2011-08-30 04:19:26 +02:00
}
2011-10-26 02:09:31 +02:00
static AVCodec * choose_decoder ( OptionsContext * o , AVFormatContext * s , AVStream * st )
2011-08-30 04:19:26 +02:00
{
char * codec_name = NULL ;
2011-09-05 22:10:26 +02:00
MATCH_PER_STREAM_OPT ( codec_names , str , codec_name , s , st ) ;
2011-10-26 02:09:31 +02:00
if ( codec_name ) {
AVCodec * codec = find_codec_or_die ( codec_name , st - > codec - > codec_type , 0 ) ;
st - > codec - > codec_id = codec - > id ;
return codec ;
} else
return avcodec_find_decoder ( st - > codec - > codec_id ) ;
2011-08-30 04:19:26 +02:00
}
2007-08-08 16:34:51 +02:00
2011-08-30 14:07:49 +02:00
/**
* Add all the streams from the given input file to the global
* list of input streams .
*/
2011-09-05 22:10:26 +02:00
static void add_input_streams ( OptionsContext * o , AVFormatContext * ic )
2011-08-30 14:07:49 +02:00
{
2012-01-03 02:25:56 +01:00
int i ;
2011-10-16 19:05:11 +02:00
char * next , * codec_tag = NULL ;
2011-08-30 14:07:49 +02:00
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
AVStream * st = ic - > streams [ i ] ;
AVCodecContext * dec = st - > codec ;
2012-04-15 15:28:30 +02:00
InputStream * ist = av_mallocz ( sizeof ( * ist ) ) ;
2012-05-26 16:52:58 +02:00
char * framerate = NULL ;
2012-04-15 15:28:30 +02:00
if ( ! ist )
exit_program ( 1 ) ;
2011-08-30 14:07:49 +02:00
input_streams = grow_array ( input_streams , sizeof ( * input_streams ) , & nb_input_streams , nb_input_streams + 1 ) ;
2012-04-15 15:28:30 +02:00
input_streams [ nb_input_streams - 1 ] = ist ;
2011-08-30 14:07:49 +02:00
ist - > st = st ;
ist - > file_index = nb_input_files ;
ist - > discard = 1 ;
2012-02-24 14:14:24 +01:00
st - > discard = AVDISCARD_ALL ;
2012-06-30 22:44:18 +02:00
ist - > opts = filter_codec_opts ( codec_opts , ist - > st - > codec - > codec_id , ic , st , choose_decoder ( o , ic , st ) ) ;
2011-08-30 14:07:49 +02:00
2011-11-07 02:41:01 +01:00
ist - > ts_scale = 1.0 ;
MATCH_PER_STREAM_OPT ( ts_scale , dbl , ist - > ts_scale , ic , st ) ;
2011-08-30 14:07:49 +02:00
2011-10-16 19:05:11 +02:00
MATCH_PER_STREAM_OPT ( codec_tags , str , codec_tag , ic , st ) ;
if ( codec_tag ) {
uint32_t tag = strtol ( codec_tag , & next , 0 ) ;
if ( * next )
tag = AV_RL32 ( codec_tag ) ;
st - > codec - > codec_tag = tag ;
}
2011-10-26 02:09:31 +02:00
ist - > dec = choose_decoder ( o , ic , st ) ;
2011-08-30 14:07:49 +02:00
switch ( dec - > codec_type ) {
case AVMEDIA_TYPE_VIDEO :
if ( ! ist - > dec )
ist - > dec = avcodec_find_decoder ( dec - > codec_id ) ;
if ( dec - > lowres ) {
dec - > flags | = CODEC_FLAG_EMU_EDGE ;
}
2012-03-29 07:40:26 +02:00
ist - > resample_height = dec - > height ;
ist - > resample_width = dec - > width ;
ist - > resample_pix_fmt = dec - > pix_fmt ;
2012-05-26 16:52:58 +02:00
MATCH_PER_STREAM_OPT ( frame_rates , str , framerate , ic , st ) ;
if ( framerate & & av_parse_video_rate ( & ist - > framerate ,
framerate ) < 0 ) {
av_log ( NULL , AV_LOG_ERROR , " Error parsing framerate %s. \n " ,
framerate ) ;
exit_program ( 1 ) ;
}
2012-05-31 12:29:07 +02:00
ist - > top_field_first = - 1 ;
MATCH_PER_STREAM_OPT ( top_field_first , i , ist - > top_field_first , ic , st ) ;
2011-08-30 14:07:49 +02:00
break ;
2012-02-24 14:14:24 +01:00
case AVMEDIA_TYPE_AUDIO :
2012-05-05 18:22:46 +02:00
guess_input_channel_layout ( ist ) ;
ist - > resample_sample_fmt = dec - > sample_fmt ;
ist - > resample_sample_rate = dec - > sample_rate ;
ist - > resample_channels = dec - > channels ;
ist - > resample_channel_layout = dec - > channel_layout ;
break ;
2011-08-30 14:07:49 +02:00
case AVMEDIA_TYPE_DATA :
case AVMEDIA_TYPE_SUBTITLE :
if ( ! ist - > dec )
ist - > dec = avcodec_find_decoder ( dec - > codec_id ) ;
break ;
case AVMEDIA_TYPE_ATTACHMENT :
case AVMEDIA_TYPE_UNKNOWN :
break ;
default :
abort ( ) ;
}
}
}
2011-11-04 01:44:06 +01:00
static void assert_file_overwrite ( const char * filename )
2004-06-12 00:03:16 +02:00
{
2011-11-24 21:42:42 +01:00
if ( ( ! file_overwrite | | no_file_overwrite ) & &
2011-11-04 01:44:06 +01:00
( strchr ( filename , ' : ' ) = = NULL | | filename [ 1 ] = = ' : ' | |
av_strstart ( filename , " file: " , NULL ) ) ) {
if ( avio_check ( filename , 0 ) = = 0 ) {
2012-07-14 17:52:51 +02:00
if ( stdin_interaction & & ( ! no_file_overwrite | | file_overwrite ) ) {
2011-11-04 01:44:06 +01:00
fprintf ( stderr , " File '%s' already exists. Overwrite ? [y/N] " , filename ) ;
fflush ( stderr ) ;
term_exit ( ) ;
2011-12-16 19:43:54 +01:00
signal ( SIGINT , SIG_DFL ) ;
2011-11-04 01:44:06 +01:00
if ( ! read_yesno ( ) ) {
2012-02-10 20:47:42 +01:00
av_log ( NULL , AV_LOG_FATAL , " Not overwriting - exiting \n " ) ;
2011-11-04 01:44:06 +01:00
exit_program ( 1 ) ;
}
term_init ( ) ;
}
else {
2012-02-10 20:47:42 +01:00
av_log ( NULL , AV_LOG_FATAL , " File '%s' already exists. Exiting. \n " , filename ) ;
2011-11-04 01:44:06 +01:00
exit_program ( 1 ) ;
}
}
}
2004-06-12 00:03:16 +02:00
}
2011-11-04 01:44:06 +01:00
static void dump_attachment ( AVStream * st , const char * filename )
2007-08-08 16:34:51 +02:00
{
2011-11-04 01:44:06 +01:00
int ret ;
AVIOContext * out = NULL ;
AVDictionaryEntry * e ;
2007-08-08 16:34:51 +02:00
2011-11-04 01:44:06 +01:00
if ( ! st - > codec - > extradata_size ) {
av_log ( NULL , AV_LOG_WARNING , " No extradata to dump in stream #%d:%d. \n " ,
nb_input_files - 1 , st - > index ) ;
return ;
}
if ( ! * filename & & ( e = av_dict_get ( st - > metadata , " filename " , NULL , 0 ) ) )
filename = e - > value ;
if ( ! * filename ) {
av_log ( NULL , AV_LOG_FATAL , " No filename specified and no 'filename' tag "
" in stream #%d:%d. \n " , nb_input_files - 1 , st - > index ) ;
2011-08-29 07:03:24 +02:00
exit_program ( 1 ) ;
2007-08-08 16:34:51 +02:00
}
2011-11-04 01:44:06 +01:00
assert_file_overwrite ( filename ) ;
2011-11-19 01:55:55 +01:00
if ( ( ret = avio_open2 ( & out , filename , AVIO_FLAG_WRITE , & int_cb , NULL ) ) < 0 ) {
2011-11-04 01:44:06 +01:00
av_log ( NULL , AV_LOG_FATAL , " Could not open file %s for writing. \n " ,
filename ) ;
2011-08-29 07:03:24 +02:00
exit_program ( 1 ) ;
2007-08-08 16:34:51 +02:00
}
2011-11-04 01:44:06 +01:00
avio_write ( out , st - > codec - > extradata , st - > codec - > extradata_size ) ;
avio_flush ( out ) ;
avio_close ( out ) ;
2007-08-08 16:34:51 +02:00
}
2011-09-05 02:04:27 +02:00
static int opt_input_file ( OptionsContext * o , const char * opt , const char * filename )
2001-07-22 16:37:44 +02:00
{
AVFormatContext * ic ;
2009-10-30 10:57:34 +01:00
AVInputFormat * file_iformat = NULL ;
2011-08-30 14:07:49 +02:00
int err , i , ret ;
2004-09-20 17:49:24 +02:00
int64_t timestamp ;
2011-06-09 10:58:23 +02:00
uint8_t buf [ 128 ] ;
2011-05-25 17:29:25 +02:00
AVDictionary * * opts ;
int orig_nb_streams ; // number of streams before avformat_find_stream_info
2001-07-22 16:37:44 +02:00
2011-09-05 02:04:27 +02:00
if ( o - > format ) {
if ( ! ( file_iformat = av_find_input_format ( o - > format ) ) ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Unknown input format: '%s' \n " , o - > format ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2010-03-02 01:01:16 +01:00
}
2009-10-30 10:57:34 +01:00
}
2002-11-19 20:08:56 +01:00
if ( ! strcmp ( filename , " - " ) )
filename = " pipe: " ;
2012-07-14 17:52:51 +02:00
stdin_interaction & = strncmp ( filename , " pipe: " , 5 ) & &
strcmp ( filename , " /dev/stdin " ) ;
2003-08-29 22:51:10 +02:00
2001-07-22 16:37:44 +02:00
/* get default parameters from command line */
2009-02-08 09:27:26 +01:00
ic = avformat_alloc_context ( ) ;
2009-09-12 19:22:56 +02:00
if ( ! ic ) {
print_error ( filename , AVERROR ( ENOMEM ) ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2009-09-12 19:22:56 +02:00
}
2011-09-11 23:35:35 +02:00
if ( o - > nb_audio_sample_rate ) {
snprintf ( buf , sizeof ( buf ) , " %d " , o - > audio_sample_rate [ o - > nb_audio_sample_rate - 1 ] . u . i ) ;
2011-06-09 10:58:23 +02:00
av_dict_set ( & format_opts , " sample_rate " , buf , 0 ) ;
}
2011-09-10 20:52:48 +02:00
if ( o - > nb_audio_channels ) {
2012-04-16 18:51:24 +02:00
/* because we set audio_channels based on both the "ac" and
* " channel_layout " options , we need to check that the specified
* demuxer actually has the " channels " option before setting it */
if ( file_iformat & & file_iformat - > priv_class & &
av_opt_find ( & file_iformat - > priv_class , " channels " , NULL , 0 ,
AV_OPT_SEARCH_FAKE_OBJ ) ) {
snprintf ( buf , sizeof ( buf ) , " %d " ,
o - > audio_channels [ o - > nb_audio_channels - 1 ] . u . i ) ;
av_dict_set ( & format_opts , " channels " , buf , 0 ) ;
}
2011-06-09 10:58:23 +02:00
}
2011-09-11 23:35:35 +02:00
if ( o - > nb_frame_rates ) {
2012-05-26 16:52:58 +02:00
/* set the format-level framerate option;
* this is important for video grabbers , e . g . x11 */
if ( file_iformat & & file_iformat - > priv_class & &
av_opt_find ( & file_iformat - > priv_class , " framerate " , NULL , 0 ,
AV_OPT_SEARCH_FAKE_OBJ ) ) {
av_dict_set ( & format_opts , " framerate " ,
o - > frame_rates [ o - > nb_frame_rates - 1 ] . u . str , 0 ) ;
}
2011-06-09 10:58:23 +02:00
}
2011-09-11 23:35:35 +02:00
if ( o - > nb_frame_sizes ) {
av_dict_set ( & format_opts , " video_size " , o - > frame_sizes [ o - > nb_frame_sizes - 1 ] . u . str , 0 ) ;
2011-06-09 10:58:23 +02:00
}
2011-09-11 23:35:35 +02:00
if ( o - > nb_frame_pix_fmts )
av_dict_set ( & format_opts , " pixel_format " , o - > frame_pix_fmts [ o - > nb_frame_pix_fmts - 1 ] . u . str , 0 ) ;
2007-12-19 11:56:17 +01:00
2011-10-26 02:09:31 +02:00
ic - > video_codec_id = video_codec_name ?
find_codec_or_die ( video_codec_name , AVMEDIA_TYPE_VIDEO , 0 ) - > id : CODEC_ID_NONE ;
ic - > audio_codec_id = audio_codec_name ?
find_codec_or_die ( audio_codec_name , AVMEDIA_TYPE_AUDIO , 0 ) - > id : CODEC_ID_NONE ;
ic - > subtitle_codec_id = subtitle_codec_name ?
find_codec_or_die ( subtitle_codec_name , AVMEDIA_TYPE_SUBTITLE , 0 ) - > id : CODEC_ID_NONE ;
2011-06-09 10:58:23 +02:00
ic - > flags | = AVFMT_FLAG_NONBLOCK ;
2011-11-19 01:55:55 +01:00
ic - > interrupt_callback = int_cb ;
2007-12-19 11:56:17 +01:00
2011-12-08 19:34:53 +01:00
/* open the input file with generic avformat function */
2011-06-09 10:58:23 +02:00
err = avformat_open_input ( & ic , filename , file_iformat , & format_opts ) ;
2001-07-22 16:37:44 +02:00
if ( err < 0 ) {
2002-05-20 18:32:49 +02:00
print_error ( filename , err ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2001-07-22 16:37:44 +02:00
}
2011-06-09 10:58:23 +02:00
assert_avoptions ( format_opts ) ;
2011-08-30 04:10:54 +02:00
/* apply forced codec ids */
for ( i = 0 ; i < ic - > nb_streams ; i + + )
2011-10-26 02:09:31 +02:00
choose_decoder ( o , ic , ic - > streams [ i ] ) ;
2011-08-30 04:10:54 +02:00
2011-05-25 17:29:25 +02:00
/* Set AVCodecContext options for avformat_find_stream_info */
2011-07-17 16:19:28 +02:00
opts = setup_find_stream_info_opts ( ic , codec_opts ) ;
2011-05-25 17:29:25 +02:00
orig_nb_streams = ic - > nb_streams ;
2011-04-24 22:48:42 +02:00
2002-05-20 18:32:49 +02:00
/* If not enough info to get the stream parameters, we decode the
first frames to get it . ( used in mpeg case for example ) */
2011-05-25 17:29:25 +02:00
ret = avformat_find_stream_info ( ic , opts ) ;
2011-09-27 02:14:37 +02:00
if ( ret < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " %s: could not find codec parameters \n " , filename ) ;
2011-12-13 00:29:25 +01:00
avformat_close_input ( & ic ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2001-07-22 16:37:44 +02:00
}
2011-09-05 02:04:27 +02:00
timestamp = o - > start_time ;
2004-09-20 17:49:24 +02:00
/* add the stream start time */
if ( ic - > start_time ! = AV_NOPTS_VALUE )
timestamp + = ic - > start_time ;
2003-11-10 19:54:17 +01:00
/* if seeking requested, we execute it */
2011-09-05 02:04:27 +02:00
if ( o - > start_time ! = 0 ) {
2004-10-11 00:05:43 +02:00
ret = av_seek_frame ( ic , - 1 , timestamp , AVSEEK_FLAG_BACKWARD ) ;
2003-11-10 19:54:17 +01:00
if ( ret < 0 ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_WARNING , " %s: could not seek to position %0.3f \n " ,
filename , ( double ) timestamp / AV_TIME_BASE ) ;
2003-11-10 19:54:17 +01:00
}
}
2001-07-22 16:37:44 +02:00
/* update the current parameters so that they match the one of the input stream */
2011-09-05 22:10:26 +02:00
add_input_streams ( o , ic ) ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
/* dump the file content */
2011-09-27 02:14:37 +02:00
av_dump_format ( ic , nb_input_files , filename , 0 ) ;
2004-04-11 15:50:42 +02:00
2011-05-22 22:12:35 +02:00
input_files = grow_array ( input_files , sizeof ( * input_files ) , & nb_input_files , nb_input_files + 1 ) ;
2012-04-15 15:28:30 +02:00
if ( ! ( input_files [ nb_input_files - 1 ] = av_mallocz ( sizeof ( * input_files [ 0 ] ) ) ) )
exit_program ( 1 ) ;
input_files [ nb_input_files - 1 ] - > ctx = ic ;
input_files [ nb_input_files - 1 ] - > ist_index = nb_input_streams - ic - > nb_streams ;
input_files [ nb_input_files - 1 ] - > ts_offset = o - > input_ts_offset - ( copy_ts ? 0 : timestamp ) ;
input_files [ nb_input_files - 1 ] - > nb_streams = ic - > nb_streams ;
input_files [ nb_input_files - 1 ] - > rate_emu = o - > rate_emu ;
2003-03-07 13:37:49 +01:00
2011-11-04 01:44:06 +01:00
for ( i = 0 ; i < o - > nb_dump_attachment ; i + + ) {
int j ;
for ( j = 0 ; j < ic - > nb_streams ; j + + ) {
AVStream * st = ic - > streams [ j ] ;
if ( check_stream_specifier ( ic , st , o - > dump_attachment [ i ] . specifier ) = = 1 )
dump_attachment ( st , o - > dump_attachment [ i ] . u . str ) ;
}
}
2005-12-17 19:14:38 +01:00
2011-05-25 17:29:25 +02:00
for ( i = 0 ; i < orig_nb_streams ; i + + )
av_dict_free ( & opts [ i ] ) ;
av_freep ( & opts ) ;
2011-09-05 02:04:27 +02:00
2011-09-05 03:11:18 +02:00
reset_options ( o , 1 ) ;
2011-05-24 18:14:42 +02:00
return 0 ;
2001-07-22 16:37:44 +02:00
}
2011-10-18 01:33:09 +02:00
static uint8_t * get_line ( AVIOContext * s )
{
AVIOContext * line ;
uint8_t * buf ;
char c ;
if ( avio_open_dyn_buf ( & line ) < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Could not alloc buffer for reading preset. \n " ) ;
exit_program ( 1 ) ;
}
while ( ( c = avio_r8 ( s ) ) & & c ! = ' \n ' )
avio_w8 ( line , c ) ;
avio_w8 ( line , 0 ) ;
avio_close_dyn_buf ( line , & buf ) ;
return buf ;
}
static int get_preset_file_2 ( const char * preset_name , const char * codec_name , AVIOContext * * s )
{
int i , ret = 1 ;
char filename [ 1000 ] ;
const char * base [ 3 ] = { getenv ( " AVCONV_DATADIR " ) ,
getenv ( " HOME " ) ,
AVCONV_DATADIR ,
} ;
for ( i = 0 ; i < FF_ARRAY_ELEMS ( base ) & & ret ; i + + ) {
if ( ! base [ i ] )
continue ;
if ( codec_name ) {
snprintf ( filename , sizeof ( filename ) , " %s%s/%s-%s.avpreset " , base [ i ] ,
i ! = 1 ? " " : " /.avconv " , codec_name , preset_name ) ;
2011-11-19 01:55:55 +01:00
ret = avio_open2 ( s , filename , AVIO_FLAG_READ , & int_cb , NULL ) ;
2011-10-18 01:33:09 +02:00
}
if ( ret ) {
snprintf ( filename , sizeof ( filename ) , " %s%s/%s.avpreset " , base [ i ] ,
i ! = 1 ? " " : " /.avconv " , preset_name ) ;
2011-11-19 01:55:55 +01:00
ret = avio_open2 ( s , filename , AVIO_FLAG_READ , & int_cb , NULL ) ;
2001-09-16 23:47:13 +02:00
}
}
2011-10-18 01:33:09 +02:00
return ret ;
2001-09-16 23:47:13 +02:00
}
2011-10-26 02:09:31 +02:00
static void choose_encoder ( OptionsContext * o , AVFormatContext * s , OutputStream * ost )
{
char * codec_name = NULL ;
MATCH_PER_STREAM_OPT ( codec_names , str , codec_name , s , ost - > st ) ;
if ( ! codec_name ) {
ost - > st - > codec - > codec_id = av_guess_codec ( s - > oformat , NULL , s - > filename ,
NULL , ost - > st - > codec - > codec_type ) ;
ost - > enc = avcodec_find_encoder ( ost - > st - > codec - > codec_id ) ;
} else if ( ! strcmp ( codec_name , " copy " ) )
ost - > stream_copy = 1 ;
else {
ost - > enc = find_codec_or_die ( codec_name , ost - > st - > codec - > codec_type , 1 ) ;
ost - > st - > codec - > codec_id = ost - > enc - > id ;
}
}
2012-03-29 15:45:50 +02:00
static OutputStream * new_output_stream ( OptionsContext * o , AVFormatContext * oc , enum AVMediaType type , int source_index )
2011-08-30 04:19:26 +02:00
{
OutputStream * ost ;
2011-10-20 02:23:36 +02:00
AVStream * st = avformat_new_stream ( oc , NULL ) ;
2011-10-18 01:33:09 +02:00
int idx = oc - > nb_streams - 1 , ret = 0 ;
2011-09-10 20:52:48 +02:00
char * bsf = NULL , * next , * codec_tag = NULL ;
2011-09-05 22:10:26 +02:00
AVBitStreamFilterContext * bsfc , * bsfc_prev = NULL ;
2011-09-11 23:35:35 +02:00
double qscale = - 1 ;
2011-10-18 01:33:09 +02:00
char * buf = NULL , * arg = NULL , * preset = NULL ;
AVIOContext * s = NULL ;
2011-08-30 04:19:26 +02:00
if ( ! st ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Could not alloc stream. \n " ) ;
2011-08-30 04:19:26 +02:00
exit_program ( 1 ) ;
}
2011-10-20 02:23:36 +02:00
if ( oc - > nb_streams - 1 < o - > nb_streamid_map )
st - > id = o - > streamid_map [ oc - > nb_streams - 1 ] ;
2011-08-30 15:03:53 +02:00
output_streams = grow_array ( output_streams , sizeof ( * output_streams ) , & nb_output_streams ,
nb_output_streams + 1 ) ;
2012-04-15 15:28:30 +02:00
if ( ! ( ost = av_mallocz ( sizeof ( * ost ) ) ) )
exit_program ( 1 ) ;
output_streams [ nb_output_streams - 1 ] = ost ;
2011-08-30 04:20:25 +02:00
ost - > file_index = nb_output_files ;
2011-12-30 03:46:24 +01:00
ost - > index = idx ;
ost - > st = st ;
2011-08-30 04:19:26 +02:00
st - > codec - > codec_type = type ;
2011-10-26 02:09:31 +02:00
choose_encoder ( o , oc , ost ) ;
2011-08-30 04:19:26 +02:00
if ( ost - > enc ) {
2012-06-30 00:28:02 +02:00
ost - > opts = filter_codec_opts ( codec_opts , ost - > enc - > id , oc , st , ost - > enc ) ;
2011-08-30 04:19:26 +02:00
}
avcodec_get_context_defaults3 ( st - > codec , ost - > enc ) ;
st - > codec - > codec_type = type ; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
2011-10-18 01:33:09 +02:00
MATCH_PER_STREAM_OPT ( presets , str , preset , oc , st ) ;
if ( preset & & ( ! ( ret = get_preset_file_2 ( preset , ost - > enc - > name , & s ) ) ) ) {
do {
buf = get_line ( s ) ;
if ( ! buf [ 0 ] | | buf [ 0 ] = = ' # ' ) {
av_free ( buf ) ;
continue ;
}
if ( ! ( arg = strchr ( buf , ' = ' ) ) ) {
av_log ( NULL , AV_LOG_FATAL , " Invalid line found in the preset file. \n " ) ;
exit_program ( 1 ) ;
}
* arg + + = 0 ;
av_dict_set ( & ost - > opts , buf , arg , AV_DICT_DONT_OVERWRITE ) ;
av_free ( buf ) ;
} while ( ! s - > eof_reached ) ;
avio_close ( s ) ;
}
if ( ret ) {
av_log ( NULL , AV_LOG_FATAL ,
" Preset %s specified for stream %d:%d, but could not be opened. \n " ,
preset , ost - > file_index , ost - > index ) ;
exit_program ( 1 ) ;
}
2011-11-07 02:41:01 +01:00
ost - > max_frames = INT64_MAX ;
MATCH_PER_STREAM_OPT ( max_frames , i64 , ost - > max_frames , oc , st ) ;
2011-09-05 22:10:26 +02:00
MATCH_PER_STREAM_OPT ( bitstream_filters , str , bsf , oc , st ) ;
while ( bsf ) {
if ( next = strchr ( bsf , ' , ' ) )
* next + + = 0 ;
if ( ! ( bsfc = av_bitstream_filter_init ( bsf ) ) ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Unknown bitstream filter %s \n " , bsf ) ;
2011-09-05 22:10:26 +02:00
exit_program ( 1 ) ;
2001-09-16 23:47:13 +02:00
}
2011-09-05 22:10:26 +02:00
if ( bsfc_prev )
bsfc_prev - > next = bsfc ;
else
ost - > bitstream_filters = bsfc ;
bsfc_prev = bsfc ;
bsf = next ;
2001-09-16 23:47:13 +02:00
}
2011-09-05 22:10:26 +02:00
2011-09-10 20:52:48 +02:00
MATCH_PER_STREAM_OPT ( codec_tags , str , codec_tag , oc , st ) ;
if ( codec_tag ) {
uint32_t tag = strtol ( codec_tag , & next , 0 ) ;
if ( * next )
tag = AV_RL32 ( codec_tag ) ;
st - > codec - > codec_tag = tag ;
2001-09-16 23:47:13 +02:00
}
2011-09-10 20:52:48 +02:00
2011-09-11 23:35:35 +02:00
MATCH_PER_STREAM_OPT ( qscale , dbl , qscale , oc , st ) ;
if ( qscale > = 0 | | same_quant ) {
st - > codec - > flags | = CODEC_FLAG_QSCALE ;
st - > codec - > global_quality = FF_QP2LAMBDA * qscale ;
}
2006-07-06 17:04:46 +02:00
2011-09-28 01:31:38 +02:00
if ( oc - > oformat - > flags & AVFMT_GLOBALHEADER )
st - > codec - > flags | = CODEC_FLAG_GLOBAL_HEADER ;
2006-07-06 17:04:46 +02:00
2011-10-13 04:55:40 +02:00
av_opt_get_int ( sws_opts , " sws_flags " , 0 , & ost - > sws_flags ) ;
2012-04-11 13:46:31 +02:00
av_opt_get_int ( swr_opts , " dither_method " , 0 , & ost - > swr_dither_method ) ;
av_opt_get_double ( swr_opts , " dither_scale " , 0 , & ost - > swr_dither_scale ) ;
2012-03-29 15:45:50 +02:00
ost - > source_index = source_index ;
if ( source_index > = 0 ) {
2012-04-17 04:01:17 +02:00
ost - > sync_ist = input_streams [ source_index ] ;
input_streams [ source_index ] - > discard = 0 ;
input_streams [ source_index ] - > st - > discard = AVDISCARD_NONE ;
2012-03-29 15:45:50 +02:00
}
2011-08-30 04:19:26 +02:00
return ost ;
}
2011-09-11 23:35:35 +02:00
static void parse_matrix_coeffs ( uint16_t * dest , const char * str )
{
int i ;
const char * p = str ;
2011-12-30 03:46:24 +01:00
for ( i = 0 ; ; i + + ) {
2011-09-11 23:35:35 +02:00
dest [ i ] = atoi ( p ) ;
2011-12-30 03:46:24 +01:00
if ( i = = 63 )
2011-09-11 23:35:35 +02:00
break ;
p = strchr ( p , ' , ' ) ;
2011-12-30 03:46:24 +01:00
if ( ! p ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Syntax error in matrix \" %s \" at coeff %d \n " , str , i ) ;
2011-09-11 23:35:35 +02:00
exit_program ( 1 ) ;
}
p + + ;
}
}
2005-12-17 19:14:38 +01:00
2012-03-29 15:45:50 +02:00
static OutputStream * new_video_stream ( OptionsContext * o , AVFormatContext * oc , int source_index )
2001-07-22 16:37:44 +02:00
{
AVStream * st ;
2011-06-23 19:14:08 +02:00
OutputStream * ost ;
2005-06-03 16:31:45 +02:00
AVCodecContext * video_enc ;
2012-06-11 03:00:28 +02:00
char * frame_rate = NULL ;
2011-02-14 23:02:10 +01:00
2012-03-29 15:45:50 +02:00
ost = new_output_stream ( o , oc , AVMEDIA_TYPE_VIDEO , source_index ) ;
2011-06-25 07:43:49 +02:00
st = ost - > st ;
2005-07-18 00:24:36 +02:00
video_enc = st - > codec ;
2005-12-17 19:14:38 +01:00
2012-06-11 03:00:28 +02:00
MATCH_PER_STREAM_OPT ( frame_rates , str , frame_rate , oc , st ) ;
if ( frame_rate & & av_parse_video_rate ( & ost - > frame_rate , frame_rate ) < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Invalid framerate value: %s \n " , frame_rate ) ;
exit_program ( 1 ) ;
}
2011-10-26 02:09:31 +02:00
if ( ! ost - > stream_copy ) {
2011-09-11 23:35:35 +02:00
const char * p = NULL ;
2012-06-26 23:27:59 +02:00
char * frame_size = NULL ;
2011-09-11 23:35:35 +02:00
char * frame_aspect_ratio = NULL , * frame_pix_fmt = NULL ;
2012-05-26 12:47:47 +02:00
char * intra_matrix = NULL , * inter_matrix = NULL ;
const char * filters = " null " ;
2005-06-03 16:31:45 +02:00
int i ;
2011-09-11 23:35:35 +02:00
MATCH_PER_STREAM_OPT ( frame_sizes , str , frame_size , oc , st ) ;
if ( frame_size & & av_parse_video_size ( & video_enc - > width , & video_enc - > height , frame_size ) < 0 ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Invalid frame size: %s. \n " , frame_size ) ;
2011-09-11 23:35:35 +02:00
exit_program ( 1 ) ;
}
2005-12-17 19:14:38 +01:00
2011-09-11 23:35:35 +02:00
MATCH_PER_STREAM_OPT ( frame_aspect_ratios , str , frame_aspect_ratio , oc , st ) ;
2012-01-17 15:25:14 +01:00
if ( frame_aspect_ratio ) {
AVRational q ;
if ( av_parse_ratio ( & q , frame_aspect_ratio , 255 , 0 , NULL ) < 0 | |
q . num < = 0 | | q . den < = 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Invalid aspect ratio: %s \n " , frame_aspect_ratio ) ;
exit_program ( 1 ) ;
}
ost - > frame_aspect_ratio = av_q2d ( q ) ;
}
2005-12-17 19:14:38 +01:00
2011-04-03 02:14:00 +02:00
video_enc - > bits_per_raw_sample = frame_bits_per_raw_sample ;
2011-09-11 23:35:35 +02:00
MATCH_PER_STREAM_OPT ( frame_pix_fmts , str , frame_pix_fmt , oc , st ) ;
2012-04-27 10:55:12 +02:00
if ( frame_pix_fmt & & * frame_pix_fmt = = ' + ' ) {
ost - > keep_pix_fmt = 1 ;
if ( ! * + + frame_pix_fmt )
frame_pix_fmt = NULL ;
}
2011-09-11 23:35:35 +02:00
if ( frame_pix_fmt & & ( video_enc - > pix_fmt = av_get_pix_fmt ( frame_pix_fmt ) ) = = PIX_FMT_NONE ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Unknown pixel format requested: %s. \n " , frame_pix_fmt ) ;
2011-09-11 23:35:35 +02:00
exit_program ( 1 ) ;
}
2008-08-24 01:13:58 +02:00
st - > sample_aspect_ratio = video_enc - > sample_aspect_ratio ;
2005-06-03 16:31:45 +02:00
2006-09-15 19:40:46 +02:00
if ( intra_only )
2005-06-03 16:31:45 +02:00
video_enc - > gop_size = 0 ;
2011-09-11 23:35:35 +02:00
MATCH_PER_STREAM_OPT ( intra_matrices , str , intra_matrix , oc , st ) ;
if ( intra_matrix ) {
if ( ! ( video_enc - > intra_matrix = av_mallocz ( sizeof ( * video_enc - > intra_matrix ) * 64 ) ) ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Could not allocate memory for intra matrix. \n " ) ;
2011-09-11 23:35:35 +02:00
exit_program ( 1 ) ;
}
parse_matrix_coeffs ( video_enc - > intra_matrix , intra_matrix ) ;
}
MATCH_PER_STREAM_OPT ( inter_matrices , str , inter_matrix , oc , st ) ;
if ( inter_matrix ) {
if ( ! ( video_enc - > inter_matrix = av_mallocz ( sizeof ( * video_enc - > inter_matrix ) * 64 ) ) ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Could not allocate memory for inter matrix. \n " ) ;
2011-09-11 23:35:35 +02:00
exit_program ( 1 ) ;
}
parse_matrix_coeffs ( video_enc - > inter_matrix , inter_matrix ) ;
2005-06-03 16:31:45 +02:00
}
2011-09-11 23:35:35 +02:00
MATCH_PER_STREAM_OPT ( rc_overrides , str , p , oc , st ) ;
2011-12-30 03:46:24 +01:00
for ( i = 0 ; p ; i + + ) {
2005-06-03 16:31:45 +02:00
int start , end , q ;
2011-12-30 03:46:24 +01:00
int e = sscanf ( p , " %d,%d,%d " , & start , & end , & q ) ;
if ( e ! = 3 ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " error parsing rc_override \n " ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2005-06-03 16:31:45 +02:00
}
2011-09-28 17:16:11 +02:00
/* FIXME realloc failure */
2011-12-30 03:46:24 +01:00
video_enc - > rc_override =
2005-12-17 19:14:38 +01:00
av_realloc ( video_enc - > rc_override ,
2011-12-30 03:46:24 +01:00
sizeof ( RcOverride ) * ( i + 1 ) ) ;
video_enc - > rc_override [ i ] . start_frame = start ;
video_enc - > rc_override [ i ] . end_frame = end ;
if ( q > 0 ) {
video_enc - > rc_override [ i ] . qscale = q ;
video_enc - > rc_override [ i ] . quality_factor = 1.0 ;
2005-06-03 16:31:45 +02:00
}
2011-12-30 03:46:24 +01:00
else {
video_enc - > rc_override [ i ] . qscale = 0 ;
video_enc - > rc_override [ i ] . quality_factor = - q / 100.0 ;
2005-06-03 16:31:45 +02:00
}
2011-12-30 03:46:24 +01:00
p = strchr ( p , ' / ' ) ;
if ( p ) p + + ;
2005-06-03 16:31:45 +02:00
}
2011-12-30 03:46:24 +01:00
video_enc - > rc_override_count = i ;
2007-01-22 11:01:14 +01:00
if ( ! video_enc - > rc_initial_buffer_occupancy )
2011-12-30 03:46:24 +01:00
video_enc - > rc_initial_buffer_occupancy = video_enc - > rc_buffer_size * 3 / 4 ;
video_enc - > intra_dc_precision = intra_dc_precision - 8 ;
2005-06-03 16:31:45 +02:00
2011-11-09 18:58:07 +01:00
if ( do_psnr )
video_enc - > flags | = CODEC_FLAG_PSNR ;
2005-06-03 16:31:45 +02:00
/* two pass mode */
if ( do_pass ) {
2011-10-30 02:26:48 +01:00
if ( do_pass & 1 ) {
2005-06-03 16:31:45 +02:00
video_enc - > flags | = CODEC_FLAG_PASS1 ;
2011-10-30 02:26:48 +01:00
}
if ( do_pass & 2 ) {
2005-06-03 16:31:45 +02:00
video_enc - > flags | = CODEC_FLAG_PASS2 ;
}
}
2010-10-18 23:47:15 +02:00
2012-06-22 14:36:27 +02:00
MATCH_PER_STREAM_OPT ( forced_key_frames , str , ost - > forced_keyframes , oc , st ) ;
if ( ost - > forced_keyframes )
ost - > forced_keyframes = av_strdup ( ost - > forced_keyframes ) ;
2011-09-11 23:35:35 +02:00
2011-11-07 02:41:01 +01:00
MATCH_PER_STREAM_OPT ( force_fps , i , ost - > force_fps , oc , st ) ;
ost - > top_field_first = - 1 ;
MATCH_PER_STREAM_OPT ( top_field_first , i , ost - > top_field_first , oc , st ) ;
2011-09-11 23:35:35 +02:00
MATCH_PER_STREAM_OPT ( filters , str , filters , oc , st ) ;
2012-05-26 12:47:47 +02:00
ost - > avfilter = av_strdup ( filters ) ;
2012-01-11 02:23:55 +01:00
} else {
MATCH_PER_STREAM_OPT ( copy_initial_nonkeyframes , i , ost - > copy_initial_nonkeyframes , oc , st ) ;
2005-06-03 16:31:45 +02:00
}
2011-08-30 04:05:20 +02:00
return ost ;
2005-06-03 16:31:45 +02:00
}
2012-03-29 15:45:50 +02:00
static OutputStream * new_audio_stream ( OptionsContext * o , AVFormatContext * oc , int source_index )
2005-06-03 16:31:45 +02:00
{
2011-11-04 18:54:01 +01:00
int n ;
2005-06-03 16:31:45 +02:00
AVStream * st ;
2011-06-23 19:14:08 +02:00
OutputStream * ost ;
2005-06-03 16:31:45 +02:00
AVCodecContext * audio_enc ;
2005-12-17 19:14:38 +01:00
2012-03-29 15:45:50 +02:00
ost = new_output_stream ( o , oc , AVMEDIA_TYPE_AUDIO , source_index ) ;
2011-06-25 07:43:49 +02:00
st = ost - > st ;
2006-07-06 17:04:46 +02:00
2005-07-18 00:24:36 +02:00
audio_enc = st - > codec ;
2010-03-31 01:30:55 +02:00
audio_enc - > codec_type = AVMEDIA_TYPE_AUDIO ;
2005-12-17 19:14:38 +01:00
2011-10-26 02:09:31 +02:00
if ( ! ost - > stream_copy ) {
2012-05-26 12:47:47 +02:00
char * sample_fmt = NULL ;
const char * filters = " anull " ;
2005-12-17 19:14:38 +01:00
2011-09-10 20:52:48 +02:00
MATCH_PER_STREAM_OPT ( audio_channels , i , audio_enc - > channels , oc , st ) ;
2011-09-11 23:35:35 +02:00
MATCH_PER_STREAM_OPT ( sample_fmts , str , sample_fmt , oc , st ) ;
if ( sample_fmt & &
( audio_enc - > sample_fmt = av_get_sample_fmt ( sample_fmt ) ) = = AV_SAMPLE_FMT_NONE ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Invalid sample format '%s' \n " , sample_fmt ) ;
2011-09-11 23:35:35 +02:00
exit_program ( 1 ) ;
2005-08-21 22:27:00 +02:00
}
2011-09-11 23:35:35 +02:00
MATCH_PER_STREAM_OPT ( audio_sample_rate , i , audio_enc - > sample_rate , oc , st ) ;
2011-10-26 00:45:52 +02:00
2012-05-05 18:22:46 +02:00
MATCH_PER_STREAM_OPT ( filters , str , filters , oc , st ) ;
2012-05-30 03:32:32 +02:00
av_assert1 ( filters ) ;
2012-05-26 12:47:47 +02:00
ost - > avfilter = av_strdup ( filters ) ;
2012-05-17 19:31:35 +02:00
/* check for channel mapping for this audio stream */
for ( n = 0 ; n < o - > nb_audio_channel_maps ; n + + ) {
AudioChannelMap * map = & o - > audio_channel_maps [ n ] ;
InputStream * ist = input_streams [ ost - > source_index ] ;
if ( ( map - > channel_idx = = - 1 | | ( ist - > file_index = = map - > file_idx & & ist - > st - > index = = map - > stream_idx ) ) & &
( map - > ofile_idx = = - 1 | | ost - > file_index = = map - > ofile_idx ) & &
( map - > ostream_idx = = - 1 | | ost - > st - > index = = map - > ostream_idx ) ) {
if ( ost - > audio_channels_mapped < FF_ARRAY_ELEMS ( ost - > audio_channels_map ) )
ost - > audio_channels_map [ ost - > audio_channels_mapped + + ] = map - > channel_idx ;
else
av_log ( NULL , AV_LOG_FATAL , " Max channel mapping for output %d.%d reached \n " ,
ost - > file_index , ost - > st - > index ) ;
}
}
2011-11-04 18:54:01 +01:00
}
2011-08-30 04:05:20 +02:00
return ost ;
2005-06-03 16:31:45 +02:00
}
2012-03-29 15:45:50 +02:00
static OutputStream * new_data_stream ( OptionsContext * o , AVFormatContext * oc , int source_index )
2011-04-14 13:32:36 +02:00
{
2011-06-25 07:43:49 +02:00
OutputStream * ost ;
2011-04-14 13:32:36 +02:00
2012-03-29 15:45:50 +02:00
ost = new_output_stream ( o , oc , AVMEDIA_TYPE_DATA , source_index ) ;
2011-10-26 02:09:31 +02:00
if ( ! ost - > stream_copy ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Data stream encoding not supported yet (only streamcopy) \n " ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2011-04-14 13:32:36 +02:00
}
2011-09-28 01:31:38 +02:00
return ost ;
}
2011-04-14 13:32:36 +02:00
2012-03-29 15:45:50 +02:00
static OutputStream * new_attachment_stream ( OptionsContext * o , AVFormatContext * oc , int source_index )
2011-09-28 01:31:38 +02:00
{
2012-03-29 15:45:50 +02:00
OutputStream * ost = new_output_stream ( o , oc , AVMEDIA_TYPE_ATTACHMENT , source_index ) ;
2011-10-26 02:09:31 +02:00
ost - > stream_copy = 1 ;
2011-08-30 04:05:20 +02:00
return ost ;
2011-04-14 13:32:36 +02:00
}
2012-03-29 15:45:50 +02:00
static OutputStream * new_subtitle_stream ( OptionsContext * o , AVFormatContext * oc , int source_index )
2005-06-03 16:31:45 +02:00
{
AVStream * st ;
2011-06-23 19:14:08 +02:00
OutputStream * ost ;
2005-06-03 16:31:45 +02:00
AVCodecContext * subtitle_enc ;
2005-12-17 19:14:38 +01:00
2012-03-29 15:45:50 +02:00
ost = new_output_stream ( o , oc , AVMEDIA_TYPE_SUBTITLE , source_index ) ;
2011-06-25 07:43:49 +02:00
st = ost - > st ;
subtitle_enc = st - > codec ;
2005-06-03 16:31:45 +02:00
2010-03-31 01:30:55 +02:00
subtitle_enc - > codec_type = AVMEDIA_TYPE_SUBTITLE ;
2009-03-11 09:14:19 +01:00
2012-04-15 21:43:55 +02:00
MATCH_PER_STREAM_OPT ( copy_initial_nonkeyframes , i , ost - > copy_initial_nonkeyframes , oc , st ) ;
2011-08-30 04:05:20 +02:00
return ost ;
2007-07-25 21:47:44 +02:00
}
2010-07-01 00:35:57 +02:00
/* arg format is "output-stream-index:streamid-value". */
2011-09-11 23:35:35 +02:00
static int opt_streamid ( OptionsContext * o , const char * opt , const char * arg )
2010-07-01 00:35:57 +02:00
{
int idx ;
char * p ;
char idx_str [ 16 ] ;
2011-05-03 20:19:31 +02:00
av_strlcpy ( idx_str , arg , sizeof ( idx_str ) ) ;
2010-07-01 00:35:57 +02:00
p = strchr ( idx_str , ' : ' ) ;
if ( ! p ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL ,
" Invalid value '%s' for option '%s', required syntax is 'index:value' \n " ,
arg , opt ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2010-07-01 00:35:57 +02:00
}
* p + + = ' \0 ' ;
2011-07-16 19:24:10 +02:00
idx = parse_number_or_die ( opt , idx_str , OPT_INT , 0 , MAX_STREAMS - 1 ) ;
2011-09-11 23:35:35 +02:00
o - > streamid_map = grow_array ( o - > streamid_map , sizeof ( * o - > streamid_map ) , & o - > nb_streamid_map , idx + 1 ) ;
o - > streamid_map [ idx ] = parse_number_or_die ( opt , p , OPT_INT , 0 , INT_MAX ) ;
2010-10-05 23:05:07 +02:00
return 0 ;
2010-07-01 00:35:57 +02:00
}
2011-08-30 04:19:26 +02:00
2011-09-05 22:10:26 +02:00
static int copy_chapters ( InputFile * ifile , OutputFile * ofile , int copy_metadata )
2011-08-30 04:15:30 +02:00
{
2011-09-05 02:04:27 +02:00
AVFormatContext * is = ifile - > ctx ;
AVFormatContext * os = ofile - > ctx ;
2011-08-30 04:15:30 +02:00
int i ;
for ( i = 0 ; i < is - > nb_chapters ; i + + ) {
AVChapter * in_ch = is - > chapters [ i ] , * out_ch ;
2011-09-05 02:04:27 +02:00
int64_t ts_off = av_rescale_q ( ofile - > start_time - ifile - > ts_offset ,
2011-12-30 03:46:24 +01:00
AV_TIME_BASE_Q , in_ch - > time_base ) ;
2011-09-05 02:04:27 +02:00
int64_t rt = ( ofile - > recording_time = = INT64_MAX ) ? INT64_MAX :
av_rescale_q ( ofile - > recording_time , AV_TIME_BASE_Q , in_ch - > time_base ) ;
2011-08-30 04:15:30 +02:00
if ( in_ch - > end < ts_off )
continue ;
if ( rt ! = INT64_MAX & & in_ch - > start > rt + ts_off )
break ;
out_ch = av_mallocz ( sizeof ( AVChapter ) ) ;
if ( ! out_ch )
return AVERROR ( ENOMEM ) ;
out_ch - > id = in_ch - > id ;
out_ch - > time_base = in_ch - > time_base ;
out_ch - > start = FFMAX ( 0 , in_ch - > start - ts_off ) ;
out_ch - > end = FFMIN ( rt , in_ch - > end - ts_off ) ;
2011-09-05 22:10:26 +02:00
if ( copy_metadata )
2011-08-30 04:15:30 +02:00
av_dict_copy ( & out_ch - > metadata , in_ch - > metadata , 0 ) ;
os - > nb_chapters + + ;
2011-09-28 17:16:11 +02:00
os - > chapters = av_realloc_f ( os - > chapters , os - > nb_chapters , sizeof ( AVChapter ) ) ;
2011-08-30 04:15:30 +02:00
if ( ! os - > chapters )
return AVERROR ( ENOMEM ) ;
os - > chapters [ os - > nb_chapters - 1 ] = out_ch ;
}
return 0 ;
}
2011-09-05 22:10:26 +02:00
static int read_ffserver_streams ( OptionsContext * o , AVFormatContext * s , const char * filename )
{
int i , err ;
2011-11-19 01:55:55 +01:00
AVFormatContext * ic = avformat_alloc_context ( ) ;
2011-09-05 22:10:26 +02:00
2011-11-19 01:55:55 +01:00
ic - > interrupt_callback = int_cb ;
2011-09-05 22:10:26 +02:00
err = avformat_open_input ( & ic , filename , NULL , NULL ) ;
if ( err < 0 )
return err ;
/* copy stream format */
for ( i = 0 ; i < ic - > nb_streams ; i + + ) {
AVStream * st ;
OutputStream * ost ;
AVCodec * codec ;
2011-10-29 20:21:59 +02:00
AVCodecContext * avctx ;
2011-09-05 22:10:26 +02:00
codec = avcodec_find_encoder ( ic - > streams [ i ] - > codec - > codec_id ) ;
2012-03-29 15:45:50 +02:00
ost = new_output_stream ( o , s , codec - > type , - 1 ) ;
2011-09-05 22:10:26 +02:00
st = ost - > st ;
2011-10-29 20:21:59 +02:00
avctx = st - > codec ;
2011-12-12 17:30:55 +01:00
ost - > enc = codec ;
2011-09-05 22:10:26 +02:00
// FIXME: a more elegant solution is needed
memcpy ( st , ic - > streams [ i ] , sizeof ( AVStream ) ) ;
2012-03-07 22:13:39 +01:00
st - > cur_dts = 0 ;
2011-09-05 22:10:26 +02:00
st - > info = av_malloc ( sizeof ( * st - > info ) ) ;
memcpy ( st - > info , ic - > streams [ i ] - > info , sizeof ( * st - > info ) ) ;
2011-10-29 20:21:59 +02:00
st - > codec = avctx ;
2011-09-05 22:10:26 +02:00
avcodec_copy_context ( st - > codec , ic - > streams [ i ] - > codec ) ;
2011-10-26 02:09:31 +02:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO & & ! ost - > stream_copy )
2011-09-05 22:10:26 +02:00
choose_sample_fmt ( st , codec ) ;
2011-10-26 02:09:31 +02:00
else if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & & ! ost - > stream_copy )
2012-04-17 03:15:19 +02:00
choose_pixel_fmt ( st , codec , st - > codec - > pix_fmt ) ;
2011-09-05 22:10:26 +02:00
}
2012-01-03 00:28:05 +01:00
avformat_close_input ( & ic ) ;
2011-09-05 22:10:26 +02:00
return 0 ;
}
2012-04-01 15:08:33 +02:00
static void init_output_filter ( OutputFilter * ofilter , OptionsContext * o ,
AVFormatContext * oc )
{
OutputStream * ost ;
2012-06-12 20:12:42 +02:00
switch ( avfilter_pad_get_type ( ofilter - > out_tmp - > filter_ctx - > output_pads ,
ofilter - > out_tmp - > pad_idx ) ) {
2012-05-19 20:31:24 +02:00
case AVMEDIA_TYPE_VIDEO : ost = new_video_stream ( o , oc , - 1 ) ; break ;
case AVMEDIA_TYPE_AUDIO : ost = new_audio_stream ( o , oc , - 1 ) ; break ;
2012-05-17 13:22:17 +02:00
default :
av_log ( NULL , AV_LOG_FATAL , " Only video and audio filters are supported "
" currently. \n " ) ;
2012-04-01 15:08:33 +02:00
exit_program ( 1 ) ;
}
ost - > source_index = - 1 ;
ost - > filter = ofilter ;
ofilter - > ost = ost ;
2012-04-21 07:03:06 +02:00
if ( ost - > stream_copy ) {
av_log ( NULL , AV_LOG_ERROR , " Streamcopy requested for output stream %d:%d, "
" which is fed from a complex filtergraph. Filtering and streamcopy "
" cannot be used together. \n " , ost - > file_index , ost - > index ) ;
exit_program ( 1 ) ;
}
2012-06-28 21:02:31 +02:00
if ( o - > recording_time ! = INT64_MAX )
av_log ( NULL , AV_LOG_WARNING ,
" -t does not work with -filter_complex (yet). \n " ) ;
2012-04-21 07:03:06 +02:00
2012-04-01 15:08:33 +02:00
if ( configure_output_filter ( ofilter - > graph , ofilter , ofilter - > out_tmp ) < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Error configuring filter. \n " ) ;
exit_program ( 1 ) ;
}
avfilter_inout_free ( & ofilter - > out_tmp ) ;
}
2011-08-28 14:43:54 +02:00
static void opt_output_file ( void * optctx , const char * filename )
2005-06-03 16:31:45 +02:00
{
2011-09-05 02:04:27 +02:00
OptionsContext * o = optctx ;
2005-06-03 16:31:45 +02:00
AVFormatContext * oc ;
2012-04-01 15:08:33 +02:00
int i , j , err ;
2009-10-30 10:57:34 +01:00
AVOutputFormat * file_oformat ;
2011-08-30 04:05:20 +02:00
OutputStream * ost ;
InputStream * ist ;
2001-07-22 16:37:44 +02:00
2012-04-01 15:08:33 +02:00
if ( configure_complex_filters ( ) < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Error configuring filters. \n " ) ;
exit_program ( 1 ) ;
}
2001-07-22 16:37:44 +02:00
if ( ! strcmp ( filename , " - " ) )
filename = " pipe: " ;
2011-09-05 02:04:27 +02:00
err = avformat_alloc_output_context2 ( & oc , NULL , o - > format , filename ) ;
2009-09-12 19:22:56 +02:00
if ( ! oc ) {
2011-05-19 22:09:34 +02:00
print_error ( filename , err ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2009-09-12 19:22:56 +02:00
}
2011-04-30 20:43:16 +02:00
file_oformat = oc - > oformat ;
2011-11-19 01:55:55 +01:00
oc - > interrupt_callback = int_cb ;
2001-07-22 16:37:44 +02:00
2012-04-01 15:08:33 +02:00
/* create streams for all unlabeled output pads */
for ( i = 0 ; i < nb_filtergraphs ; i + + ) {
FilterGraph * fg = filtergraphs [ i ] ;
for ( j = 0 ; j < fg - > nb_outputs ; j + + ) {
OutputFilter * ofilter = fg - > outputs [ j ] ;
if ( ! ofilter - > out_tmp | | ofilter - > out_tmp - > name )
continue ;
2012-06-12 20:12:42 +02:00
switch ( avfilter_pad_get_type ( ofilter - > out_tmp - > filter_ctx - > output_pads ,
ofilter - > out_tmp - > pad_idx ) ) {
2012-04-01 15:08:33 +02:00
case AVMEDIA_TYPE_VIDEO : o - > video_disable = 1 ; break ;
case AVMEDIA_TYPE_AUDIO : o - > audio_disable = 1 ; break ;
case AVMEDIA_TYPE_SUBTITLE : o - > subtitle_disable = 1 ; break ;
}
init_output_filter ( ofilter , o , oc ) ;
}
}
2005-12-17 19:14:38 +01:00
if ( ! strcmp ( file_oformat - > name , " ffm " ) & &
2007-06-24 13:27:12 +02:00
av_strstart ( filename , " http: " , NULL ) ) {
2011-10-29 20:25:39 +02:00
int j ;
2001-07-22 16:37:44 +02:00
/* special case for files sent to ffserver: we get the stream
parameters from ffserver */
2011-09-05 22:10:26 +02:00
int err = read_ffserver_streams ( o , oc , filename ) ;
2008-06-13 00:30:01 +02:00
if ( err < 0 ) {
print_error ( filename , err ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2001-07-22 16:37:44 +02:00
}
2011-10-29 20:25:39 +02:00
for ( j = nb_output_streams - oc - > nb_streams ; j < nb_output_streams ; j + + ) {
2012-04-17 04:01:17 +02:00
ost = output_streams [ j ] ;
2011-10-29 20:25:39 +02:00
for ( i = 0 ; i < nb_input_streams ; i + + ) {
2012-04-17 04:01:17 +02:00
ist = input_streams [ i ] ;
2011-10-29 20:25:39 +02:00
if ( ist - > st - > codec - > codec_type = = ost - > st - > codec - > codec_type ) {
ost - > sync_ist = ist ;
ost - > source_index = i ;
2012-05-30 03:32:32 +02:00
if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO ) ost - > avfilter = av_strdup ( " anull " ) ;
if ( ost - > st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ) ost - > avfilter = av_strdup ( " null " ) ;
2011-10-29 20:25:39 +02:00
ist - > discard = 0 ;
2012-03-03 20:45:45 +01:00
ist - > st - > discard = AVDISCARD_NONE ;
2011-10-29 20:25:39 +02:00
break ;
}
}
2011-11-21 23:32:39 +01:00
if ( ! ost - > sync_ist ) {
av_log ( NULL , AV_LOG_FATAL , " Missing %s stream which is required by this ffm \n " , av_get_media_type_string ( ost - > st - > codec - > codec_type ) ) ;
exit_program ( 1 ) ;
}
2011-10-29 20:25:39 +02:00
}
2011-09-05 02:04:27 +02:00
} else if ( ! o - > nb_stream_maps ) {
2011-08-30 04:05:20 +02:00
/* pick the "best" stream of each type */
/* video: highest resolution */
2011-09-10 20:52:48 +02:00
if ( ! o - > video_disable & & oc - > oformat - > video_codec ! = CODEC_ID_NONE ) {
2011-08-30 04:05:20 +02:00
int area = 0 , idx = - 1 ;
for ( i = 0 ; i < nb_input_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
ist = input_streams [ i ] ;
2011-08-30 04:05:20 +02:00
if ( ist - > st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & &
ist - > st - > codec - > width * ist - > st - > codec - > height > area ) {
area = ist - > st - > codec - > width * ist - > st - > codec - > height ;
idx = i ;
}
}
2012-03-29 15:45:50 +02:00
if ( idx > = 0 )
new_video_stream ( o , oc , idx ) ;
2011-08-30 04:05:20 +02:00
}
/* audio: most channels */
2011-09-10 20:52:48 +02:00
if ( ! o - > audio_disable & & oc - > oformat - > audio_codec ! = CODEC_ID_NONE ) {
2011-08-30 04:05:20 +02:00
int channels = 0 , idx = - 1 ;
for ( i = 0 ; i < nb_input_streams ; i + + ) {
2012-04-15 15:28:30 +02:00
ist = input_streams [ i ] ;
2011-08-30 04:05:20 +02:00
if ( ist - > st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO & &
ist - > st - > codec - > channels > channels ) {
channels = ist - > st - > codec - > channels ;
idx = i ;
}
}
2012-03-29 15:45:50 +02:00
if ( idx > = 0 )
new_audio_stream ( o , oc , idx ) ;
2011-08-30 04:05:20 +02:00
}
/* subtitles: pick first */
2011-09-10 20:52:48 +02:00
if ( ! o - > subtitle_disable & & ( oc - > oformat - > subtitle_codec ! = CODEC_ID_NONE | | subtitle_codec_name ) ) {
2011-08-30 04:05:20 +02:00
for ( i = 0 ; i < nb_input_streams ; i + + )
2012-04-15 15:28:30 +02:00
if ( input_streams [ i ] - > st - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
2012-03-29 15:45:50 +02:00
new_subtitle_stream ( o , oc , i ) ;
2011-08-30 04:05:20 +02:00
break ;
}
}
/* do something with data? */
2001-07-22 16:37:44 +02:00
} else {
2011-09-05 02:04:27 +02:00
for ( i = 0 ; i < o - > nb_stream_maps ; i + + ) {
StreamMap * map = & o - > stream_maps [ i ] ;
2012-04-17 04:01:17 +02:00
int src_idx = input_files [ map - > file_index ] - > ist_index + map - > stream_index ;
2011-08-30 04:05:20 +02:00
2011-08-30 04:06:24 +02:00
if ( map - > disabled )
continue ;
2011-08-30 04:05:20 +02:00
2012-04-01 15:08:33 +02:00
if ( map - > linklabel ) {
FilterGraph * fg ;
OutputFilter * ofilter = NULL ;
int j , k ;
for ( j = 0 ; j < nb_filtergraphs ; j + + ) {
fg = filtergraphs [ j ] ;
for ( k = 0 ; k < fg - > nb_outputs ; k + + ) {
AVFilterInOut * out = fg - > outputs [ k ] - > out_tmp ;
if ( out & & ! strcmp ( out - > name , map - > linklabel ) ) {
ofilter = fg - > outputs [ k ] ;
goto loop_end ;
}
}
}
loop_end :
if ( ! ofilter ) {
av_log ( NULL , AV_LOG_FATAL , " Output with label '%s' does not exist "
" in any defined filter graph. \n " , map - > linklabel ) ;
exit_program ( 1 ) ;
}
init_output_filter ( ofilter , o , oc ) ;
} else {
2012-03-30 22:07:56 +02:00
ist = input_streams [ input_files [ map - > file_index ] - > ist_index + map - > stream_index ] ;
2012-04-17 12:13:22 +02:00
if ( o - > subtitle_disable & & ist - > st - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE )
continue ;
if ( o - > audio_disable & & ist - > st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO )
continue ;
if ( o - > video_disable & & ist - > st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO )
continue ;
if ( o - > data_disable & & ist - > st - > codec - > codec_type = = AVMEDIA_TYPE_DATA )
continue ;
2012-03-30 22:07:56 +02:00
switch ( ist - > st - > codec - > codec_type ) {
2012-04-17 12:13:22 +02:00
case AVMEDIA_TYPE_VIDEO : ost = new_video_stream ( o , oc , src_idx ) ; break ;
case AVMEDIA_TYPE_AUDIO : ost = new_audio_stream ( o , oc , src_idx ) ; break ;
case AVMEDIA_TYPE_SUBTITLE : ost = new_subtitle_stream ( o , oc , src_idx ) ; break ;
case AVMEDIA_TYPE_DATA : ost = new_data_stream ( o , oc , src_idx ) ; break ;
case AVMEDIA_TYPE_ATTACHMENT : ost = new_attachment_stream ( o , oc , src_idx ) ; break ;
2012-03-30 22:07:56 +02:00
default :
av_log ( NULL , AV_LOG_FATAL , " Cannot map stream #%d:%d - unsupported type. \n " ,
2012-05-19 12:05:02 +02:00
map - > file_index , map - > stream_index ) ;
2012-03-30 22:07:56 +02:00
exit_program ( 1 ) ;
}
2012-04-01 15:08:33 +02:00
}
2011-08-30 04:05:20 +02:00
}
2001-07-22 16:37:44 +02:00
}
2012-02-18 07:53:05 +01:00
for ( i = nb_output_streams - oc - > nb_streams ; i < nb_output_streams ; i + + ) { //for all streams of this output file
AVDictionaryEntry * e ;
2012-04-17 04:01:17 +02:00
ost = output_streams [ i ] ;
2012-02-18 07:53:05 +01:00
if ( ost - > stream_copy
& & ( e = av_dict_get ( codec_opts , " flags " , NULL , AV_DICT_IGNORE_SUFFIX ) )
& & ( ! e - > key [ 5 ] | | check_stream_specifier ( oc , ost - > st , e - > key + 6 ) ) )
if ( av_opt_set ( ost - > st - > codec , " flags " , e - > value , 0 ) < 0 )
exit_program ( 1 ) ;
}
2011-11-04 01:44:06 +01:00
/* handle attached files */
for ( i = 0 ; i < o - > nb_attachments ; i + + ) {
AVIOContext * pb ;
uint8_t * attachment ;
const char * p ;
int64_t len ;
2001-07-22 16:37:44 +02:00
2011-11-19 01:55:55 +01:00
if ( ( err = avio_open2 ( & pb , o - > attachments [ i ] , AVIO_FLAG_READ , & int_cb , NULL ) ) < 0 ) {
2011-11-04 01:44:06 +01:00
av_log ( NULL , AV_LOG_FATAL , " Could not open attachment file %s. \n " ,
o - > attachments [ i ] ) ;
2011-08-29 07:03:24 +02:00
exit_program ( 1 ) ;
2001-07-22 16:37:44 +02:00
}
2011-11-04 01:44:06 +01:00
if ( ( len = avio_size ( pb ) ) < = 0 ) {
av_log ( NULL , AV_LOG_FATAL , " Could not get size of the attachment %s. \n " ,
o - > attachments [ i ] ) ;
exit_program ( 1 ) ;
}
if ( ! ( attachment = av_malloc ( len ) ) ) {
av_log ( NULL , AV_LOG_FATAL , " Attachment %s too large to fit into memory. \n " ,
o - > attachments [ i ] ) ;
exit_program ( 1 ) ;
}
avio_read ( pb , attachment , len ) ;
2012-03-29 15:45:50 +02:00
ost = new_attachment_stream ( o , oc , - 1 ) ;
2011-11-04 01:44:06 +01:00
ost - > stream_copy = 0 ;
ost - > attachment_filename = o - > attachments [ i ] ;
ost - > st - > codec - > extradata = attachment ;
ost - > st - > codec - > extradata_size = len ;
p = strrchr ( o - > attachments [ i ] , ' / ' ) ;
av_dict_set ( & ost - > st - > metadata , " filename " , ( p & & * p ) ? p + 1 : o - > attachments [ i ] , AV_DICT_DONT_OVERWRITE ) ;
avio_close ( pb ) ;
2001-07-22 16:37:44 +02:00
}
2011-08-30 14:19:39 +02:00
output_files = grow_array ( output_files , sizeof ( * output_files ) , & nb_output_files , nb_output_files + 1 ) ;
2012-04-15 15:28:30 +02:00
if ( ! ( output_files [ nb_output_files - 1 ] = av_mallocz ( sizeof ( * output_files [ 0 ] ) ) ) )
exit_program ( 1 ) ;
output_files [ nb_output_files - 1 ] - > ctx = oc ;
output_files [ nb_output_files - 1 ] - > ost_index = nb_output_streams - oc - > nb_streams ;
output_files [ nb_output_files - 1 ] - > recording_time = o - > recording_time ;
2012-02-05 15:49:14 +01:00
if ( o - > recording_time ! = INT64_MAX )
oc - > duration = o - > recording_time ;
2012-04-15 15:28:30 +02:00
output_files [ nb_output_files - 1 ] - > start_time = o - > start_time ;
output_files [ nb_output_files - 1 ] - > limit_filesize = o - > limit_filesize ;
av_dict_copy ( & output_files [ nb_output_files - 1 ] - > opts , format_opts , 0 ) ;
2001-07-22 16:37:44 +02:00
2001-09-16 23:47:13 +02:00
/* check filename in case of an image number is expected */
2002-05-20 18:32:49 +02:00
if ( oc - > oformat - > flags & AVFMT_NEEDNUMBER ) {
2006-09-04 11:57:47 +02:00
if ( ! av_filename_number_test ( oc - > filename ) ) {
2011-04-11 00:29:30 +02:00
print_error ( oc - > filename , AVERROR ( EINVAL ) ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2002-05-20 18:32:49 +02:00
}
2001-09-16 23:47:13 +02:00
}
2002-05-20 18:32:49 +02:00
if ( ! ( oc - > oformat - > flags & AVFMT_NOFILE ) ) {
2011-10-05 14:12:42 +02:00
/* test if it already exists to avoid losing precious files */
2011-11-04 01:44:06 +01:00
assert_file_overwrite ( filename ) ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
/* open the file */
2011-11-19 01:55:55 +01:00
if ( ( err = avio_open2 ( & oc - > pb , filename , AVIO_FLAG_WRITE ,
& oc - > interrupt_callback ,
2012-04-15 15:28:30 +02:00
& output_files [ nb_output_files - 1 ] - > opts ) ) < 0 ) {
2010-04-27 00:36:55 +02:00
print_error ( filename , err ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2001-07-22 16:37:44 +02:00
}
}
2011-10-26 02:09:31 +02:00
if ( o - > mux_preload ) {
uint8_t buf [ 64 ] ;
snprintf ( buf , sizeof ( buf ) , " %d " , ( int ) ( o - > mux_preload * AV_TIME_BASE ) ) ;
2012-04-15 15:28:30 +02:00
av_dict_set ( & output_files [ nb_output_files - 1 ] - > opts , " preload " , buf , 0 ) ;
2011-10-26 02:09:31 +02:00
}
2011-09-05 22:10:26 +02:00
oc - > max_delay = ( int ) ( o - > mux_max_delay * AV_TIME_BASE ) ;
2004-10-07 00:29:30 +02:00
2011-12-17 01:36:59 +01:00
/* copy metadata */
for ( i = 0 ; i < o - > nb_metadata_map ; i + + ) {
char * p ;
int in_file_index = strtol ( o - > metadata_map [ i ] . u . str , & p , 0 ) ;
2011-06-15 08:00:03 +02:00
2011-12-17 01:36:59 +01:00
if ( in_file_index > = nb_input_files ) {
av_log ( NULL , AV_LOG_FATAL , " Invalid input file index %d while processing metadata maps \n " , in_file_index ) ;
exit_program ( 1 ) ;
}
2012-04-17 04:01:17 +02:00
copy_metadata ( o - > metadata_map [ i ] . specifier , * p ? p + 1 : p , oc , in_file_index > = 0 ? input_files [ in_file_index ] - > ctx : NULL , o ) ;
2011-12-17 01:36:59 +01:00
}
2011-08-30 01:28:08 +02:00
/* copy chapters */
2011-09-05 22:10:26 +02:00
if ( o - > chapters_input_file > = nb_input_files ) {
if ( o - > chapters_input_file = = INT_MAX ) {
2011-08-30 01:28:08 +02:00
/* copy chapters from the first input file that has them*/
2011-09-05 22:10:26 +02:00
o - > chapters_input_file = - 1 ;
2011-08-30 01:28:08 +02:00
for ( i = 0 ; i < nb_input_files ; i + + )
2012-04-15 15:28:30 +02:00
if ( input_files [ i ] - > ctx - > nb_chapters ) {
2011-09-05 22:10:26 +02:00
o - > chapters_input_file = i ;
2011-08-30 01:28:08 +02:00
break ;
}
} else {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Invalid input file index %d in chapter mapping. \n " ,
2011-09-05 22:10:26 +02:00
o - > chapters_input_file ) ;
2011-08-30 01:28:08 +02:00
exit_program ( 1 ) ;
}
}
2011-09-05 22:10:26 +02:00
if ( o - > chapters_input_file > = 0 )
2012-04-15 15:28:30 +02:00
copy_chapters ( input_files [ o - > chapters_input_file ] , output_files [ nb_output_files - 1 ] ,
2011-09-11 23:35:35 +02:00
! o - > metadata_chapters_manual ) ;
2011-08-30 01:28:08 +02:00
2011-08-30 01:30:11 +02:00
/* copy global metadata by default */
2011-09-11 05:24:26 +02:00
if ( ! o - > metadata_global_manual & & nb_input_files ) {
2012-04-15 15:28:30 +02:00
av_dict_copy ( & oc - > metadata , input_files [ 0 ] - > ctx - > metadata ,
2011-08-30 01:30:11 +02:00
AV_DICT_DONT_OVERWRITE ) ;
2011-09-11 05:24:26 +02:00
if ( o - > recording_time ! = INT64_MAX )
av_dict_set ( & oc - > metadata , " duration " , NULL , 0 ) ;
2012-06-28 17:09:36 +02:00
av_dict_set ( & oc - > metadata , " creation_time " , NULL , 0 ) ;
2011-09-11 05:24:26 +02:00
}
2011-09-05 22:10:26 +02:00
if ( ! o - > metadata_streams_manual )
2012-04-15 15:28:30 +02:00
for ( i = output_files [ nb_output_files - 1 ] - > ost_index ; i < nb_output_streams ; i + + ) {
2011-11-04 01:44:06 +01:00
InputStream * ist ;
2012-04-15 15:28:30 +02:00
if ( output_streams [ i ] - > source_index < 0 ) /* this is true e.g. for attached files */
2011-11-04 01:44:06 +01:00
continue ;
2012-04-15 15:28:30 +02:00
ist = input_streams [ output_streams [ i ] - > source_index ] ;
av_dict_copy ( & output_streams [ i ] - > st - > metadata , ist - > st - > metadata , AV_DICT_DONT_OVERWRITE ) ;
2011-08-30 01:30:11 +02:00
}
2011-09-05 22:10:26 +02:00
/* process manually set metadata */
for ( i = 0 ; i < o - > nb_metadata ; i + + ) {
AVDictionary * * m ;
char type , * val ;
2011-12-17 01:36:59 +01:00
const char * stream_spec ;
2012-01-03 00:28:06 +01:00
int index = 0 , j , ret = 0 ;
2011-09-05 22:10:26 +02:00
val = strchr ( o - > metadata [ i ] . u . str , ' = ' ) ;
if ( ! val ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " No '=' character in metadata string %s. \n " ,
2011-09-05 22:10:26 +02:00
o - > metadata [ i ] . u . str ) ;
exit_program ( 1 ) ;
}
* val + + = 0 ;
2011-12-17 01:36:59 +01:00
parse_meta_type ( o - > metadata [ i ] . specifier , & type , & index , & stream_spec ) ;
if ( type = = ' s ' ) {
for ( j = 0 ; j < oc - > nb_streams ; j + + ) {
if ( ( ret = check_stream_specifier ( oc , oc - > streams [ j ] , stream_spec ) ) > 0 ) {
av_dict_set ( & oc - > streams [ j ] - > metadata , o - > metadata [ i ] . u . str , * val ? val : NULL , 0 ) ;
} else if ( ret < 0 )
exit_program ( 1 ) ;
2011-09-05 22:10:26 +02:00
}
2011-12-17 01:36:59 +01:00
}
else {
switch ( type ) {
case ' g ' :
m = & oc - > metadata ;
break ;
case ' c ' :
if ( index < 0 | | index > = oc - > nb_chapters ) {
av_log ( NULL , AV_LOG_FATAL , " Invalid chapter index %d in metadata specifier. \n " , index ) ;
exit_program ( 1 ) ;
}
m = & oc - > chapters [ index ] - > metadata ;
break ;
default :
av_log ( NULL , AV_LOG_FATAL , " Invalid metadata specifier %s. \n " , o - > metadata [ i ] . specifier ) ;
2011-09-05 22:10:26 +02:00
exit_program ( 1 ) ;
}
2011-12-17 01:36:59 +01:00
av_dict_set ( m , o - > metadata [ i ] . u . str , * val ? val : NULL , 0 ) ;
2011-09-05 22:10:26 +02:00
}
}
2004-10-07 00:29:30 +02:00
2011-09-05 03:11:18 +02:00
reset_options ( o , 0 ) ;
2001-07-22 16:37:44 +02:00
}
2002-10-10 19:09:01 +02:00
/* same option as mencoder */
2011-04-11 13:16:07 +02:00
static int opt_pass ( const char * opt , const char * arg )
2002-10-10 19:09:01 +02:00
{
2011-10-30 02:26:48 +01:00
do_pass = parse_number_or_die ( opt , arg , OPT_INT , 1 , 3 ) ;
2011-04-11 13:16:07 +02:00
return 0 ;
2002-10-10 19:09:01 +02:00
}
2001-09-25 01:22:25 +02:00
2010-02-22 23:21:58 +01:00
static int64_t getmaxrss ( void )
{
# if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
struct rusage rusage ;
getrusage ( RUSAGE_SELF , & rusage ) ;
return ( int64_t ) rusage . ru_maxrss * 1024 ;
# elif HAVE_GETPROCESSMEMORYINFO
HANDLE proc ;
PROCESS_MEMORY_COUNTERS memcounters ;
proc = GetCurrentProcess ( ) ;
memcounters . cb = sizeof ( memcounters ) ;
GetProcessMemoryInfo ( proc , & memcounters , sizeof ( memcounters ) ) ;
return memcounters . PeakPagefileUsage ;
# else
return 0 ;
# endif
}
2011-09-11 23:35:35 +02:00
static int opt_audio_qscale ( OptionsContext * o , const char * opt , const char * arg )
2003-10-31 11:25:21 +01:00
{
2011-09-11 23:35:35 +02:00
return parse_option ( o , " q:a " , arg , options ) ;
2003-10-31 11:25:21 +01:00
}
2009-12-21 03:12:34 +01:00
static void show_usage ( void )
2007-11-15 13:31:58 +01:00
{
2012-01-06 19:08:13 +01:00
av_log ( NULL , AV_LOG_INFO , " Hyper fast Audio and Video encoder \n " ) ;
av_log ( NULL , AV_LOG_INFO , " usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}... \n " , program_name ) ;
av_log ( NULL , AV_LOG_INFO , " \n " ) ;
2009-12-21 03:12:34 +01:00
}
2011-06-29 18:38:46 +02:00
static int opt_help ( const char * opt , const char * arg )
2009-12-21 03:12:34 +01:00
{
2011-10-13 04:55:40 +02:00
int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM ;
2009-12-21 03:12:34 +01:00
av_log_set_callback ( log_callback_help ) ;
show_usage ( ) ;
2007-11-15 13:31:58 +01:00
show_help_options ( options , " Main options: \n " ,
2008-06-16 12:00:32 +02:00
OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB , 0 ) ;
2008-06-17 12:11:46 +02:00
show_help_options ( options , " \n Advanced options: \n " ,
OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB ,
OPT_EXPERT ) ;
2007-11-15 13:31:58 +01:00
show_help_options ( options , " \n Video options: \n " ,
OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB ,
OPT_VIDEO ) ;
show_help_options ( options , " \n Advanced Video options: \n " ,
OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB ,
OPT_VIDEO | OPT_EXPERT ) ;
show_help_options ( options , " \n Audio options: \n " ,
OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB ,
OPT_AUDIO ) ;
show_help_options ( options , " \n Advanced Audio options: \n " ,
OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB ,
OPT_AUDIO | OPT_EXPERT ) ;
show_help_options ( options , " \n Subtitle options: \n " ,
OPT_SUBTITLE | OPT_GRAB ,
OPT_SUBTITLE ) ;
show_help_options ( options , " \n Audio/Video grab options: \n " ,
OPT_GRAB ,
OPT_GRAB ) ;
2008-05-31 20:36:44 +02:00
printf ( " \n " ) ;
2011-10-13 04:55:40 +02:00
show_help_children ( avcodec_get_class ( ) , flags ) ;
show_help_children ( avformat_get_class ( ) , flags ) ;
show_help_children ( sws_get_class ( ) , flags ) ;
2012-06-22 03:43:07 +02:00
show_help_children ( swr_get_class ( ) , AV_OPT_FLAG_AUDIO_PARAM ) ;
2011-06-09 10:58:23 +02:00
2011-06-29 18:38:46 +02:00
return 0 ;
2007-11-15 13:31:58 +01:00
}
2011-09-05 02:04:27 +02:00
static int opt_target ( OptionsContext * o , const char * opt , const char * arg )
2003-11-03 18:28:44 +01:00
{
2009-12-15 00:18:49 +01:00
enum { PAL , NTSC , FILM , UNKNOWN } norm = UNKNOWN ;
2011-12-30 03:46:24 +01:00
static const char * const frame_rates [ ] = { " 25 " , " 30000/1001 " , " 24000/1001 " } ;
2003-11-03 18:28:44 +01:00
2011-12-30 03:46:24 +01:00
if ( ! strncmp ( arg , " pal- " , 4 ) ) {
2009-12-15 00:18:49 +01:00
norm = PAL ;
2003-11-03 18:28:44 +01:00
arg + = 4 ;
2011-12-30 03:46:24 +01:00
} else if ( ! strncmp ( arg , " ntsc- " , 5 ) ) {
2009-12-15 00:18:49 +01:00
norm = NTSC ;
2003-11-03 18:28:44 +01:00
arg + = 5 ;
2011-12-30 03:46:24 +01:00
} else if ( ! strncmp ( arg , " film- " , 5 ) ) {
2009-12-15 00:18:49 +01:00
norm = FILM ;
2004-12-19 16:31:55 +01:00
arg + = 5 ;
2003-11-03 18:28:44 +01:00
} else {
2011-09-11 23:35:35 +02:00
/* Try to determine PAL/NTSC by peeking in the input files */
2011-12-30 03:46:24 +01:00
if ( nb_input_files ) {
2011-09-11 23:35:35 +02:00
int i , j , fr ;
for ( j = 0 ; j < nb_input_files ; j + + ) {
2012-04-15 15:28:30 +02:00
for ( i = 0 ; i < input_files [ j ] - > nb_streams ; i + + ) {
AVCodecContext * c = input_files [ j ] - > ctx - > streams [ i ] - > codec ;
2011-12-30 03:46:24 +01:00
if ( c - > codec_type ! = AVMEDIA_TYPE_VIDEO )
2011-09-11 23:35:35 +02:00
continue ;
fr = c - > time_base . den * 1000 / c - > time_base . num ;
2011-12-30 03:46:24 +01:00
if ( fr = = 25000 ) {
2011-09-11 23:35:35 +02:00
norm = PAL ;
2003-11-03 18:28:44 +01:00
break ;
2011-12-30 03:46:24 +01:00
} else if ( ( fr = = 29970 ) | | ( fr = = 23976 ) ) {
2011-09-11 23:35:35 +02:00
norm = NTSC ;
2003-11-03 18:28:44 +01:00
break ;
2011-09-11 23:35:35 +02:00
}
2003-11-03 18:28:44 +01:00
}
2011-12-30 03:46:24 +01:00
if ( norm ! = UNKNOWN )
2011-09-11 23:35:35 +02:00
break ;
2003-11-03 18:28:44 +01:00
}
}
2011-09-27 02:14:37 +02:00
if ( norm ! = UNKNOWN )
av_log ( NULL , AV_LOG_INFO , " Assuming %s for target. \n " , norm = = PAL ? " PAL " : " NTSC " ) ;
2003-11-03 18:28:44 +01:00
}
2011-12-30 03:46:24 +01:00
if ( norm = = UNKNOWN ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " Could not determine norm (PAL/NTSC/NTSC-Film) for target. \n " ) ;
av_log ( NULL , AV_LOG_FATAL , " Please prefix target with \" pal- \" , \" ntsc- \" or \" film- \" , \n " ) ;
av_log ( NULL , AV_LOG_FATAL , " or set a framerate with \" -r xxx \" . \n " ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2003-11-03 18:28:44 +01:00
}
2011-12-30 03:46:24 +01:00
if ( ! strcmp ( arg , " vcd " ) ) {
2011-09-05 22:10:26 +02:00
opt_video_codec ( o , " c:v " , " mpeg1video " ) ;
opt_audio_codec ( o , " c:a " , " mp2 " ) ;
2011-09-05 02:04:27 +02:00
parse_option ( o , " f " , " vcd " , options ) ;
2003-11-03 18:28:44 +01:00
2011-09-11 23:35:35 +02:00
parse_option ( o , " s " , norm = = PAL ? " 352x288 " : " 352x240 " , options ) ;
parse_option ( o , " r " , frame_rates [ norm ] , options ) ;
2009-12-16 00:25:16 +01:00
opt_default ( " g " , norm = = PAL ? " 15 " : " 18 " ) ;
2003-11-03 18:28:44 +01:00
2011-11-29 17:48:59 +01:00
opt_default ( " b:v " , " 1150000 " ) ;
2006-09-15 19:38:43 +02:00
opt_default ( " maxrate " , " 1150000 " ) ;
opt_default ( " minrate " , " 1150000 " ) ;
2006-09-18 21:27:12 +02:00
opt_default ( " bufsize " , " 327680 " ) ; // 40*1024*8;
2003-11-03 18:28:44 +01:00
2011-08-30 04:11:52 +02:00
opt_default ( " b:a " , " 224000 " ) ;
2011-09-11 23:35:35 +02:00
parse_option ( o , " ar " , " 44100 " , options ) ;
2011-09-10 20:52:48 +02:00
parse_option ( o , " ac " , " 2 " , options ) ;
2005-12-17 19:14:38 +01:00
2006-09-20 10:24:17 +02:00
opt_default ( " packetsize " , " 2324 " ) ;
2006-09-20 10:23:01 +02:00
opt_default ( " muxrate " , " 1411200 " ) ; // 2352 * 75 * 8;
2003-11-03 18:28:44 +01:00
2004-10-16 23:27:42 +02:00
/* We have to offset the PTS, so that it is consistent with the SCR.
SCR starts at 36000 , but the first two packs contain only padding
and the first pack from the other stream , respectively , may also have
been written before .
So the real data starts at SCR 36000 + 3 * 1200. */
2011-12-30 03:46:24 +01:00
o - > mux_preload = ( 36000 + 3 * 1200 ) / 90000.0 ; // 0.44
} else if ( ! strcmp ( arg , " svcd " ) ) {
2003-11-03 18:28:44 +01:00
2011-09-05 22:10:26 +02:00
opt_video_codec ( o , " c:v " , " mpeg2video " ) ;
opt_audio_codec ( o , " c:a " , " mp2 " ) ;
2011-09-05 02:04:27 +02:00
parse_option ( o , " f " , " svcd " , options ) ;
2003-11-03 18:28:44 +01:00
2011-09-11 23:35:35 +02:00
parse_option ( o , " s " , norm = = PAL ? " 480x576 " : " 480x480 " , options ) ;
parse_option ( o , " r " , frame_rates [ norm ] , options ) ;
parse_option ( o , " pix_fmt " , " yuv420p " , options ) ;
2009-12-16 00:25:16 +01:00
opt_default ( " g " , norm = = PAL ? " 15 " : " 18 " ) ;
2003-11-03 18:28:44 +01:00
2011-11-29 17:48:59 +01:00
opt_default ( " b:v " , " 2040000 " ) ;
2006-09-15 19:38:43 +02:00
opt_default ( " maxrate " , " 2516000 " ) ;
2011-12-30 03:46:24 +01:00
opt_default ( " minrate " , " 0 " ) ; // 1145000;
opt_default ( " bufsize " , " 1835008 " ) ; // 224*1024*8;
2012-03-25 16:38:57 +02:00
opt_default ( " scan_offset " , " 1 " ) ;
2005-09-12 12:23:52 +02:00
2003-11-03 18:28:44 +01:00
2011-08-30 04:11:52 +02:00
opt_default ( " b:a " , " 224000 " ) ;
2011-09-11 23:35:35 +02:00
parse_option ( o , " ar " , " 44100 " , options ) ;
2003-11-03 18:28:44 +01:00
2006-09-20 10:24:17 +02:00
opt_default ( " packetsize " , " 2324 " ) ;
2004-10-07 00:29:30 +02:00
2011-12-30 03:46:24 +01:00
} else if ( ! strcmp ( arg , " dvd " ) ) {
2003-11-03 18:28:44 +01:00
2011-09-05 22:10:26 +02:00
opt_video_codec ( o , " c:v " , " mpeg2video " ) ;
opt_audio_codec ( o , " c:a " , " ac3 " ) ;
2011-09-05 02:04:27 +02:00
parse_option ( o , " f " , " dvd " , options ) ;
2003-11-03 18:28:44 +01:00
2011-09-11 23:35:35 +02:00
parse_option ( o , " s " , norm = = PAL ? " 720x576 " : " 720x480 " , options ) ;
parse_option ( o , " r " , frame_rates [ norm ] , options ) ;
parse_option ( o , " pix_fmt " , " yuv420p " , options ) ;
2009-12-16 00:25:16 +01:00
opt_default ( " g " , norm = = PAL ? " 15 " : " 18 " ) ;
2003-11-03 18:28:44 +01:00
2011-11-29 17:48:59 +01:00
opt_default ( " b:v " , " 6000000 " ) ;
2006-09-15 19:38:43 +02:00
opt_default ( " maxrate " , " 9000000 " ) ;
2011-12-30 03:46:24 +01:00
opt_default ( " minrate " , " 0 " ) ; // 1500000;
opt_default ( " bufsize " , " 1835008 " ) ; // 224*1024*8;
2003-11-03 18:28:44 +01:00
2006-09-20 10:24:17 +02:00
opt_default ( " packetsize " , " 2048 " ) ; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2006-09-20 10:23:01 +02:00
opt_default ( " muxrate " , " 10080000 " ) ; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2004-11-21 04:37:33 +01:00
2011-08-30 04:11:52 +02:00
opt_default ( " b:a " , " 448000 " ) ;
2011-09-11 23:35:35 +02:00
parse_option ( o , " ar " , " 48000 " , options ) ;
2003-11-03 18:28:44 +01:00
2011-12-30 03:46:24 +01:00
} else if ( ! strncmp ( arg , " dv " , 2 ) ) {
2004-12-29 19:50:47 +01:00
2011-09-05 02:04:27 +02:00
parse_option ( o , " f " , " dv " , options ) ;
2004-12-29 19:50:47 +01:00
2011-09-11 23:35:35 +02:00
parse_option ( o , " s " , norm = = PAL ? " 720x576 " : " 720x480 " , options ) ;
parse_option ( o , " pix_fmt " , ! strncmp ( arg , " dv50 " , 4 ) ? " yuv422p " :
norm = = PAL ? " yuv420p " : " yuv411p " , options ) ;
parse_option ( o , " r " , frame_rates [ norm ] , options ) ;
2004-12-29 19:50:47 +01:00
2011-09-11 23:35:35 +02:00
parse_option ( o , " ar " , " 48000 " , options ) ;
2011-09-10 20:52:48 +02:00
parse_option ( o , " ac " , " 2 " , options ) ;
2004-12-29 19:50:47 +01:00
2003-11-03 18:28:44 +01:00
} else {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_ERROR , " Unknown target: %s \n " , arg ) ;
2011-05-24 18:14:42 +02:00
return AVERROR ( EINVAL ) ;
2003-11-03 18:28:44 +01:00
}
2011-05-24 18:14:42 +02:00
return 0 ;
2003-11-03 18:28:44 +01:00
}
2011-05-24 18:14:42 +02:00
static int opt_vstats_file ( const char * opt , const char * arg )
2007-04-25 15:55:11 +02:00
{
av_free ( vstats_filename ) ;
2011-12-30 03:46:24 +01:00
vstats_filename = av_strdup ( arg ) ;
2011-05-24 18:14:42 +02:00
return 0 ;
2007-04-25 15:55:11 +02:00
}
2011-05-24 18:14:42 +02:00
static int opt_vstats ( const char * opt , const char * arg )
2007-04-25 15:55:11 +02:00
{
char filename [ 40 ] ;
time_t today2 = time ( NULL ) ;
struct tm * today = localtime ( & today2 ) ;
snprintf ( filename , sizeof ( filename ) , " vstats_%02d%02d%02d.log " , today - > tm_hour , today - > tm_min ,
today - > tm_sec ) ;
2011-05-24 18:14:42 +02:00
return opt_vstats_file ( opt , filename ) ;
2007-04-25 15:55:11 +02:00
}
2011-09-05 22:10:26 +02:00
static int opt_video_frames ( OptionsContext * o , const char * opt , const char * arg )
2006-07-06 17:04:46 +02:00
{
2011-09-05 22:10:26 +02:00
return parse_option ( o , " frames:v " , arg , options ) ;
}
2006-07-06 17:04:46 +02:00
2011-09-05 22:10:26 +02:00
static int opt_audio_frames ( OptionsContext * o , const char * opt , const char * arg )
{
return parse_option ( o , " frames:a " , arg , options ) ;
}
2008-01-02 11:24:36 +01:00
2011-09-05 22:10:26 +02:00
static int opt_data_frames ( OptionsContext * o , const char * opt , const char * arg )
{
return parse_option ( o , " frames:d " , arg , options ) ;
2006-07-06 17:04:46 +02:00
}
2011-09-05 22:10:26 +02:00
static int opt_preset ( OptionsContext * o , const char * opt , const char * arg )
2011-09-02 23:49:07 +02:00
{
FILE * f = NULL ;
2012-05-03 23:07:24 +02:00
char filename [ 1000 ] , line [ 1000 ] , tmp_line [ 1000 ] ;
2011-09-12 12:02:41 +02:00
const char * codec_name = * opt = = ' v ' ? video_codec_name :
* opt = = ' a ' ? audio_codec_name :
subtitle_codec_name ;
2011-09-02 23:49:07 +02:00
if ( ! ( f = get_preset_file ( filename , sizeof ( filename ) , arg , * opt = = ' f ' , codec_name ) ) ) {
2011-09-26 22:02:13 +02:00
if ( ! strncmp ( arg , " libx264-lossless " , strlen ( " libx264-lossless " ) ) ) {
2012-02-10 20:47:42 +01:00
av_log ( NULL , AV_LOG_FATAL , " Please use -preset <speed> -qp 0 \n " ) ;
2011-09-26 22:02:13 +02:00
} else
2012-02-10 20:47:42 +01:00
av_log ( NULL , AV_LOG_FATAL , " File for preset '%s' not found \n " , arg ) ;
2011-09-02 23:49:07 +02:00
exit_program ( 1 ) ;
}
2012-05-03 23:07:24 +02:00
while ( fgets ( line , sizeof ( line ) , f ) ) {
char * key = tmp_line , * value , * endptr ;
if ( strcspn ( line , " # \n \r " ) = = 0 )
2011-09-02 23:49:07 +02:00
continue ;
2012-05-03 23:07:24 +02:00
strcpy ( tmp_line , line ) ;
if ( ! av_strtok ( key , " = " , & value ) | |
! av_strtok ( value , " \r \n " , & endptr ) ) {
2012-02-10 20:47:42 +01:00
av_log ( NULL , AV_LOG_FATAL , " %s: Invalid syntax: '%s' \n " , filename , line ) ;
2011-09-02 23:49:07 +02:00
exit_program ( 1 ) ;
}
2012-05-03 23:07:24 +02:00
av_log ( NULL , AV_LOG_DEBUG , " ffpreset[%s]: set '%s' = '%s' \n " , filename , key , value ) ;
if ( ! strcmp ( key , " acodec " ) ) opt_audio_codec ( o , key , value ) ;
else if ( ! strcmp ( key , " vcodec " ) ) opt_video_codec ( o , key , value ) ;
else if ( ! strcmp ( key , " scodec " ) ) opt_subtitle_codec ( o , key , value ) ;
else if ( ! strcmp ( key , " dcodec " ) ) opt_data_codec ( o , key , value ) ;
else if ( opt_default ( key , value ) < 0 ) {
av_log ( NULL , AV_LOG_FATAL , " %s: Invalid option or argument: '%s', parsed as '%s' = '%s' \n " ,
filename , line , key , value ) ;
2011-09-02 23:49:07 +02:00
exit_program ( 1 ) ;
}
}
fclose ( f ) ;
return 0 ;
}
2011-09-12 11:44:14 +02:00
static void log_callback_null ( void * ptr , int level , const char * fmt , va_list vl )
2011-04-18 13:10:52 +02:00
{
}
2011-06-29 18:38:46 +02:00
static int opt_passlogfile ( const char * opt , const char * arg )
2011-04-21 00:46:20 +02:00
{
pass_logfilename_prefix = arg ;
2011-08-09 01:05:28 +02:00
# if CONFIG_LIBX264_ENCODER
2012-02-11 04:18:22 +01:00
return opt_default ( opt , arg ) ;
2011-08-09 01:05:28 +02:00
# else
return 0 ;
# endif
2011-04-21 00:46:20 +02:00
}
2011-09-12 11:44:14 +02:00
static int opt_old2new ( OptionsContext * o , const char * opt , const char * arg )
{
2012-01-13 01:53:34 +01:00
char * s = av_asprintf ( " %s:%c " , opt + 1 , * opt ) ;
2012-01-13 18:56:59 +01:00
int ret = parse_option ( o , s , arg , options ) ;
2012-01-13 01:53:34 +01:00
av_free ( s ) ;
2012-01-13 18:56:59 +01:00
return ret ;
2011-09-11 01:12:58 +02:00
}
2011-09-26 20:35:48 +02:00
static int opt_bitrate ( OptionsContext * o , const char * opt , const char * arg )
{
if ( ! strcmp ( opt , " b " ) ) {
2012-02-10 20:47:42 +01:00
av_log ( NULL , AV_LOG_WARNING , " Please use -b:a or -b:v, -b is ambiguous \n " ) ;
2012-01-13 01:49:41 +01:00
return parse_option ( o , " b:v " , arg , options ) ;
2011-09-26 20:35:48 +02:00
}
return opt_default ( opt , arg ) ;
}
2012-01-26 18:49:53 +01:00
static int opt_qscale ( OptionsContext * o , const char * opt , const char * arg )
{
char * s ;
int ret ;
if ( ! strcmp ( opt , " qscale " ) ) {
2012-02-10 20:47:42 +01:00
av_log ( NULL , AV_LOG_WARNING , " Please use -q:a or -q:v, -qscale is ambiguous \n " ) ;
2012-01-26 18:49:53 +01:00
return parse_option ( o , " q:v " , arg , options ) ;
}
s = av_asprintf ( " q%s " , opt + 6 ) ;
ret = parse_option ( o , s , arg , options ) ;
av_free ( s ) ;
return ret ;
}
2012-04-01 20:48:20 +02:00
static int opt_profile ( OptionsContext * o , const char * opt , const char * arg )
{
if ( ! strcmp ( opt , " profile " ) ) {
av_log ( NULL , AV_LOG_WARNING , " Please use -profile:a or -profile:v, -profile is ambiguous \n " ) ;
return parse_option ( o , " profile:v " , arg , options ) ;
}
return opt_default ( opt , arg ) ;
}
2011-09-11 23:35:35 +02:00
static int opt_video_filters ( OptionsContext * o , const char * opt , const char * arg )
{
return parse_option ( o , " filter:v " , arg , options ) ;
}
2011-09-11 01:12:58 +02:00
2012-05-05 18:22:46 +02:00
static int opt_audio_filters ( OptionsContext * o , const char * opt , const char * arg )
{
return parse_option ( o , " filter:a " , arg , options ) ;
}
2012-01-05 02:03:12 +01:00
static int opt_vsync ( const char * opt , const char * arg )
{
if ( ! av_strcasecmp ( arg , " cfr " ) ) video_sync_method = VSYNC_CFR ;
else if ( ! av_strcasecmp ( arg , " vfr " ) ) video_sync_method = VSYNC_VFR ;
else if ( ! av_strcasecmp ( arg , " passthrough " ) ) video_sync_method = VSYNC_PASSTHROUGH ;
2012-01-28 19:56:13 +01:00
else if ( ! av_strcasecmp ( arg , " drop " ) ) video_sync_method = VSYNC_DROP ;
2012-01-05 02:03:12 +01:00
if ( video_sync_method = = VSYNC_AUTO )
video_sync_method = parse_number_or_die ( " vsync " , arg , OPT_INT , VSYNC_AUTO , VSYNC_VFR ) ;
return 0 ;
}
2012-01-30 16:05:28 +01:00
static int opt_deinterlace ( const char * opt , const char * arg )
{
av_log ( NULL , AV_LOG_WARNING , " -%s is deprecated, use -filter:v yadif instead \n " , opt ) ;
do_deinterlace = 1 ;
return 0 ;
}
2012-05-30 10:26:53 +02:00
static int opt_timecode ( OptionsContext * o , const char * opt , const char * arg )
{
char * tcr = av_asprintf ( " timecode=%s " , arg ) ;
int ret = parse_option ( o , " metadata:g " , tcr , options ) ;
if ( ret > = 0 )
ret = opt_default ( " gop_timecode " , arg ) ;
av_free ( tcr ) ;
return ret ;
}
2012-03-04 16:46:45 +01:00
static void parse_cpuflags ( int argc , char * * argv , const OptionDef * options )
{
int idx = locate_option ( argc , argv , options , " cpuflags " ) ;
if ( idx & & argv [ idx + 1 ] )
opt_cpuflags ( " cpuflags " , argv [ idx + 1 ] ) ;
}
2012-04-05 23:47:20 +02:00
static int opt_channel_layout ( OptionsContext * o , const char * opt , const char * arg )
{
char layout_str [ 32 ] ;
char * stream_str ;
char * ac_str ;
int ret , channels , ac_str_size ;
uint64_t layout ;
layout = av_get_channel_layout ( arg ) ;
if ( ! layout ) {
av_log ( NULL , AV_LOG_ERROR , " Unknown channel layout: %s \n " , arg ) ;
return AVERROR ( EINVAL ) ;
}
snprintf ( layout_str , sizeof ( layout_str ) , " % " PRIu64 , layout ) ;
ret = opt_default ( opt , layout_str ) ;
if ( ret < 0 )
return ret ;
/* set 'ac' option based on channel layout */
channels = av_get_channel_layout_nb_channels ( layout ) ;
snprintf ( layout_str , sizeof ( layout_str ) , " %d " , channels ) ;
stream_str = strchr ( opt , ' : ' ) ;
ac_str_size = 3 + ( stream_str ? strlen ( stream_str ) : 0 ) ;
ac_str = av_mallocz ( ac_str_size ) ;
if ( ! ac_str )
return AVERROR ( ENOMEM ) ;
av_strlcpy ( ac_str , " ac " , 3 ) ;
if ( stream_str )
av_strlcat ( ac_str , stream_str , ac_str_size ) ;
ret = parse_option ( o , ac_str , layout_str , options ) ;
av_free ( ac_str ) ;
return ret ;
}
2012-04-01 15:08:33 +02:00
static int opt_filter_complex ( const char * opt , const char * arg )
{
filtergraphs = grow_array ( filtergraphs , sizeof ( * filtergraphs ) ,
& nb_filtergraphs , nb_filtergraphs + 1 ) ;
if ( ! ( filtergraphs [ nb_filtergraphs - 1 ] = av_mallocz ( sizeof ( * filtergraphs [ 0 ] ) ) ) )
return AVERROR ( ENOMEM ) ;
filtergraphs [ nb_filtergraphs - 1 ] - > index = nb_filtergraphs - 1 ;
filtergraphs [ nb_filtergraphs - 1 ] - > graph_desc = arg ;
return 0 ;
}
2012-07-08 13:03:39 +02:00
static int opt_progress ( const char * opt , const char * arg )
{
AVIOContext * avio = NULL ;
int ret ;
if ( ! strcmp ( arg , " - " ) )
arg = " pipe: " ;
ret = avio_open2 ( & avio , arg , AVIO_FLAG_WRITE , & int_cb , NULL ) ;
if ( ret < 0 ) {
av_log ( 0 , AV_LOG_ERROR , " Failed to open progress URL \" %s \" : %s \n " ,
arg , av_err2str ( ret ) ) ;
return ret ;
}
progress_avio = avio ;
return 0 ;
}
2011-09-05 02:04:27 +02:00
# define OFFSET(x) offsetof(OptionsContext, x)
2008-05-01 17:12:00 +02:00
static const OptionDef options [ ] = {
2003-08-24 17:29:48 +02:00
/* main options */
2009-11-30 00:12:19 +01:00
# include "cmdutils_common_opts.h"
2011-09-05 02:04:27 +02:00
{ " f " , HAS_ARG | OPT_STRING | OPT_OFFSET , { . off = OFFSET ( format ) } , " force format " , " fmt " } ,
{ " i " , HAS_ARG | OPT_FUNC2 , { ( void * ) opt_input_file } , " input file name " , " filename " } ,
2001-08-13 23:43:02 +02:00
{ " y " , OPT_BOOL , { ( void * ) & file_overwrite } , " overwrite output files " } ,
2011-11-24 21:42:42 +01:00
{ " n " , OPT_BOOL , { ( void * ) & no_file_overwrite } , " do not overwrite output files " } ,
2011-09-05 22:10:26 +02:00
{ " c " , HAS_ARG | OPT_STRING | OPT_SPEC , { . off = OFFSET ( codec_names ) } , " codec name " , " codec " } ,
{ " codec " , HAS_ARG | OPT_STRING | OPT_SPEC , { . off = OFFSET ( codec_names ) } , " codec name " , " codec " } ,
2011-10-18 01:33:09 +02:00
{ " pre " , HAS_ARG | OPT_STRING | OPT_SPEC , { . off = OFFSET ( presets ) } , " preset name " , " preset " } ,
2011-12-13 00:29:25 +01:00
{ " map " , HAS_ARG | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_map } , " set input stream mapping " , " [-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]] " } ,
2011-11-04 18:54:01 +01:00
{ " map_channel " , HAS_ARG | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_map_channel } , " map an audio channel from one stream to another " , " file.stream.channel[:syncfile.syncstream] " } ,
2011-12-17 01:36:59 +01:00
{ " map_metadata " , HAS_ARG | OPT_STRING | OPT_SPEC , { . off = OFFSET ( metadata_map ) } , " set metadata information of outfile from infile " ,
2011-02-02 21:45:16 +01:00
" outfile[,metadata]:infile[,metadata] " } ,
2011-09-05 22:10:26 +02:00
{ " map_chapters " , OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET , { . off = OFFSET ( chapters_input_file ) } , " set chapters mapping " , " input_file_index " } ,
2011-09-05 02:04:27 +02:00
{ " t " , HAS_ARG | OPT_TIME | OPT_OFFSET , { . off = OFFSET ( recording_time ) } , " record or transcode \" duration \" seconds of audio/video " , " duration " } ,
{ " fs " , HAS_ARG | OPT_INT64 | OPT_OFFSET , { . off = OFFSET ( limit_filesize ) } , " set the limit file size in bytes " , " limit_size " } , //
{ " ss " , HAS_ARG | OPT_TIME | OPT_OFFSET , { . off = OFFSET ( start_time ) } , " set the start time offset " , " time_off " } ,
{ " itsoffset " , HAS_ARG | OPT_TIME | OPT_OFFSET , { . off = OFFSET ( input_ts_offset ) } , " set the input ts offset " , " time_off " } ,
2011-09-05 22:10:26 +02:00
{ " itsscale " , HAS_ARG | OPT_DOUBLE | OPT_SPEC , { . off = OFFSET ( ts_scale ) } , " set the input ts scale " , " scale " } ,
{ " timestamp " , HAS_ARG | OPT_FUNC2 , { ( void * ) opt_recording_timestamp } , " set the recording timestamp ('now' to set the current time) " , " time " } ,
{ " metadata " , HAS_ARG | OPT_STRING | OPT_SPEC , { . off = OFFSET ( metadata ) } , " add metadata " , " string=string " } ,
{ " dframes " , HAS_ARG | OPT_FUNC2 , { ( void * ) opt_data_frames } , " set the number of data frames to record " , " number " } ,
2005-12-17 19:14:38 +01:00
{ " benchmark " , OPT_BOOL | OPT_EXPERT , { ( void * ) & do_benchmark } ,
2001-07-31 01:19:22 +02:00
" add timings for benchmarking " } ,
2012-04-11 19:26:09 +02:00
{ " benchmark_all " , OPT_BOOL | OPT_EXPERT , { ( void * ) & do_benchmark_all } ,
" add timings for each task " } ,
2012-07-08 13:03:39 +02:00
{ " progress " , HAS_ARG | OPT_EXPERT , { ( void * ) opt_progress } ,
" write program-readable progress information " , " url " } ,
2012-07-11 21:10:17 +02:00
{ " stdin " , OPT_BOOL | OPT_EXPERT , { ( void * ) & stdin_interaction } ,
" enable or disable interaction on standard input " } ,
2011-05-24 18:14:42 +02:00
{ " timelimit " , HAS_ARG , { ( void * ) opt_timelimit } , " set max runtime in seconds " , " limit " } ,
2005-12-17 19:14:38 +01:00
{ " dump " , OPT_BOOL | OPT_EXPERT , { ( void * ) & do_pkt_dump } ,
2001-09-23 19:14:51 +02:00
" dump each input packet " } ,
2005-12-17 19:14:38 +01:00
{ " hex " , OPT_BOOL | OPT_EXPERT , { ( void * ) & do_hex_dump } ,
2003-11-10 19:54:17 +01:00
" when dumping packets, also dump the payload " } ,
2011-09-05 22:10:26 +02:00
{ " re " , OPT_BOOL | OPT_EXPERT | OPT_OFFSET , { . off = OFFSET ( rate_emu ) } , " read input at native frame rate " , " " } ,
2011-09-05 02:04:27 +02:00
{ " target " , HAS_ARG | OPT_FUNC2 , { ( void * ) opt_target } , " specify target file type ( \" vcd \" , \" svcd \" , \" dvd \" , \" dv \" , \" dv50 \" , \" pal-vcd \" , \" ntsc-svcd \" , ...) " , " type " } ,
2012-01-05 02:03:12 +01:00
{ " vsync " , HAS_ARG | OPT_EXPERT , { ( void * ) opt_vsync } , " video sync method " , " " } ,
2004-06-30 16:47:29 +02:00
{ " async " , HAS_ARG | OPT_INT | OPT_EXPERT , { ( void * ) & audio_sync_method } , " audio sync method " , " " } ,
2008-04-08 03:01:00 +02:00
{ " adrift_threshold " , HAS_ARG | OPT_FLOAT | OPT_EXPERT , { ( void * ) & audio_drift_threshold } , " audio drift threshold " , " threshold " } ,
2004-06-12 05:41:36 +02:00
{ " copyts " , OPT_BOOL | OPT_EXPERT , { ( void * ) & copy_ts } , " copy timestamps " } ,
2012-03-24 16:11:46 +01:00
{ " copytb " , HAS_ARG | OPT_INT | OPT_EXPERT , { ( void * ) & copy_tb } , " copy input stream time base when stream copying " , " mode " } ,
2005-03-23 01:52:31 +01:00
{ " shortest " , OPT_BOOL | OPT_EXPERT , { ( void * ) & opt_shortest } , " finish encoding within shortest input " } , //
2008-04-08 03:01:00 +02:00
{ " dts_delta_threshold " , HAS_ARG | OPT_FLOAT | OPT_EXPERT , { ( void * ) & dts_delta_threshold } , " timestamp discontinuity delta threshold " , " threshold " } ,
2012-02-07 23:43:10 +01:00
{ " dts_error_threshold " , HAS_ARG | OPT_FLOAT | OPT_EXPERT , { ( void * ) & dts_error_threshold } , " timestamp error delta threshold " , " threshold " } ,
2008-09-05 01:23:44 +02:00
{ " xerror " , OPT_BOOL , { ( void * ) & exit_on_error } , " exit on error " , " error " } ,
2011-11-07 02:41:01 +01:00
{ " copyinkf " , OPT_BOOL | OPT_EXPERT | OPT_SPEC , { . off = OFFSET ( copy_initial_nonkeyframes ) } , " copy initial non-keyframes " } ,
2011-09-05 22:10:26 +02:00
{ " frames " , OPT_INT64 | HAS_ARG | OPT_SPEC , { . off = OFFSET ( max_frames ) } , " set the number of frames to record " , " number " } ,
2011-09-10 20:52:48 +02:00
{ " tag " , OPT_STRING | HAS_ARG | OPT_SPEC , { . off = OFFSET ( codec_tags ) } , " force codec tag/fourcc " , " fourcc/tag " } ,
2011-09-11 23:35:35 +02:00
{ " q " , HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC , { . off = OFFSET ( qscale ) } , " use fixed quality scale (VBR) " , " q " } ,
2012-01-26 18:49:53 +01:00
{ " qscale " , HAS_ARG | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_qscale } , " use fixed quality scale (VBR) " , " q " } ,
2012-04-01 20:48:20 +02:00
{ " profile " , HAS_ARG | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_profile } , " set profile " , " profile " } ,
2011-09-11 23:35:35 +02:00
{ " filter " , HAS_ARG | OPT_STRING | OPT_SPEC , { . off = OFFSET ( filters ) } , " set stream filterchain " , " filter_list " } ,
2012-04-01 15:08:33 +02:00
{ " filter_complex " , HAS_ARG | OPT_EXPERT , { ( void * ) opt_filter_complex } , " create a complex filtergraph " , " graph_description " } ,
2011-10-10 03:41:49 +02:00
{ " stats " , OPT_BOOL , { & print_stats } , " print progress report during encoding " , } ,
2011-11-04 01:44:06 +01:00
{ " attach " , HAS_ARG | OPT_FUNC2 , { ( void * ) opt_attach } , " add an attachment to the output file " , " filename " } ,
{ " dump_attachment " , HAS_ARG | OPT_STRING | OPT_SPEC , { . off = OFFSET ( dump_attachment ) } , " extract an attachment into a file " , " filename " } ,
2012-01-20 17:06:26 +01:00
{ " debug_ts " , OPT_BOOL | OPT_EXPERT , { & debug_ts } , " print timestamp debugging info " } ,
2003-08-24 17:29:48 +02:00
/* video options */
2011-09-05 22:10:26 +02:00
{ " vframes " , HAS_ARG | OPT_VIDEO | OPT_FUNC2 , { ( void * ) opt_video_frames } , " set the number of video frames to record " , " number " } ,
2011-09-11 23:35:35 +02:00
{ " r " , HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC , { . off = OFFSET ( frame_rates ) } , " set frame rate (Hz value, fraction or abbreviation) " , " rate " } ,
{ " s " , HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC , { . off = OFFSET ( frame_sizes ) } , " set frame size (WxH or abbreviation) " , " size " } ,
{ " aspect " , HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC , { . off = OFFSET ( frame_aspect_ratios ) } , " set aspect ratio (4:3, 16:9 or 1.3333, 1.7777) " , " aspect " } ,
{ " pix_fmt " , HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC , { . off = OFFSET ( frame_pix_fmts ) } , " set pixel format " , " format " } ,
2011-04-03 02:14:00 +02:00
{ " bits_per_raw_sample " , OPT_INT | HAS_ARG | OPT_VIDEO , { ( void * ) & frame_bits_per_raw_sample } , " set the number of bits per raw sample " , " number " } ,
2011-05-24 18:14:42 +02:00
{ " croptop " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " cropbottom " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " cropleft " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " cropright " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " padtop " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padbottom " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padleft " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padright " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padcolor " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " color " } ,
2012-03-21 00:15:18 +01:00
{ " intra " , OPT_BOOL | OPT_EXPERT | OPT_VIDEO , { ( void * ) & intra_only } , " deprecated use -g 1 " } ,
2011-09-10 20:52:48 +02:00
{ " vn " , OPT_BOOL | OPT_VIDEO | OPT_OFFSET , { . off = OFFSET ( video_disable ) } , " disable video " } ,
2005-03-17 06:07:54 +01:00
{ " vdt " , OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) & video_discard } , " discard threshold " , " n " } ,
2011-09-11 23:35:35 +02:00
{ " rc_override " , HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC , { . off = OFFSET ( rc_overrides ) } , " rate control override for specific intervals " , " override " } ,
2011-09-05 22:10:26 +02:00
{ " vcodec " , HAS_ARG | OPT_VIDEO | OPT_FUNC2 , { ( void * ) opt_video_codec } , " force video codec ('copy' to copy stream) " , " codec " } ,
2011-08-30 01:46:34 +02:00
{ " sameq " , OPT_BOOL | OPT_VIDEO , { ( void * ) & same_quant } , " use same quantizer as source (implies VBR) " } ,
2011-09-11 23:35:35 +02:00
{ " same_quant " , OPT_BOOL | OPT_VIDEO , { ( void * ) & same_quant } ,
2011-04-09 13:50:05 +02:00
" use same quantizer as source (implies VBR) " } ,
2012-05-30 10:26:53 +02:00
{ " timecode " , HAS_ARG | OPT_VIDEO | OPT_FUNC2 , { ( void * ) opt_timecode } , " set initial TimeCode value. " , " hh:mm:ss[:;.]ff " } ,
2011-05-24 18:14:42 +02:00
{ " pass " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pass } , " select the pass number (1 or 2) " , " n " } ,
2011-04-21 00:46:20 +02:00
{ " passlogfile " , HAS_ARG | OPT_VIDEO , { ( void * ) & opt_passlogfile } , " select two pass log file name prefix " , " prefix " } ,
2012-01-30 16:05:28 +01:00
{ " deinterlace " , OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_deinterlace } ,
" this option is deprecated, use the yadif filter instead " } ,
2011-11-09 18:58:07 +01:00
{ " psnr " , OPT_BOOL | OPT_EXPERT | OPT_VIDEO , { ( void * ) & do_psnr } , " calculate PSNR of compressed frames " } ,
2007-04-25 15:55:11 +02:00
{ " vstats " , OPT_EXPERT | OPT_VIDEO , { ( void * ) & opt_vstats } , " dump video coding statistics to file " } ,
{ " vstats_file " , HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_vstats_file } , " dump video coding statistics to file " , " file " } ,
2011-09-11 23:35:35 +02:00
{ " vf " , HAS_ARG | OPT_VIDEO | OPT_FUNC2 , { ( void * ) opt_video_filters } , " video filters " , " filter list " } ,
{ " intra_matrix " , HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC , { . off = OFFSET ( intra_matrices ) } , " specify intra matrix coeffs " , " matrix " } ,
{ " inter_matrix " , HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC , { . off = OFFSET ( inter_matrices ) } , " specify inter matrix coeffs " , " matrix " } ,
{ " top " , HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT | OPT_SPEC , { . off = OFFSET ( top_field_first ) } , " top=1/bottom=0/auto=-1 field first " , " " } ,
2004-04-30 15:44:29 +02:00
{ " dc " , OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) & intra_dc_precision } , " intra_dc_precision " , " precision " } ,
2011-09-11 01:15:36 +02:00
{ " vtag " , HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2 , { ( void * ) opt_old2new } , " force video tag/fourcc " , " fourcc/tag " } ,
2005-12-18 21:01:02 +01:00
{ " qphist " , OPT_BOOL | OPT_EXPERT | OPT_VIDEO , { ( void * ) & qp_hist } , " show QP histogram " } ,
2011-09-11 23:35:35 +02:00
{ " force_fps " , OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC , { . off = OFFSET ( force_fps ) } , " force the selected framerate, disable the best supported framerate selection " } ,
{ " streamid " , HAS_ARG | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_streamid } , " set the value of an outfile streamid " , " streamIndex:value " } ,
{ " force_key_frames " , OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC , { . off = OFFSET ( forced_key_frames ) } , " force key frames at specified timestamps " , " timestamps " } ,
2011-09-26 20:35:48 +02:00
{ " b " , HAS_ARG | OPT_VIDEO | OPT_FUNC2 , { ( void * ) opt_bitrate } , " video bitrate (please use -b:v) " , " bitrate " } ,
2003-08-24 17:29:48 +02:00
/* audio options */
2011-09-05 22:10:26 +02:00
{ " aframes " , HAS_ARG | OPT_AUDIO | OPT_FUNC2 , { ( void * ) opt_audio_frames } , " set the number of audio frames to record " , " number " } ,
2011-09-11 23:35:35 +02:00
{ " aq " , HAS_ARG | OPT_AUDIO | OPT_FUNC2 , { ( void * ) opt_audio_qscale } , " set audio quality (codec-specific) " , " quality " , } ,
{ " ar " , HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC , { . off = OFFSET ( audio_sample_rate ) } , " set audio sampling rate (in Hz) " , " rate " } ,
2011-09-10 20:52:48 +02:00
{ " ac " , HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC , { . off = OFFSET ( audio_channels ) } , " set number of audio channels " , " channels " } ,
{ " an " , OPT_BOOL | OPT_AUDIO | OPT_OFFSET , { . off = OFFSET ( audio_disable ) } , " disable audio " } ,
2011-09-05 22:10:26 +02:00
{ " acodec " , HAS_ARG | OPT_AUDIO | OPT_FUNC2 , { ( void * ) opt_audio_codec } , " force audio codec ('copy' to copy stream) " , " codec " } ,
2011-09-11 01:15:36 +02:00
{ " atag " , HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2 , { ( void * ) opt_old2new } , " force audio tag/fourcc " , " fourcc/tag " } ,
2005-03-23 03:10:23 +01:00
{ " vol " , OPT_INT | HAS_ARG | OPT_AUDIO , { ( void * ) & audio_volume } , " change audio volume (256=normal) " , " volume " } , //
2011-09-11 23:35:35 +02:00
{ " sample_fmt " , HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING , { . off = OFFSET ( sample_fmts ) } , " set sample format " , " format " } ,
2012-04-05 23:47:20 +02:00
{ " channel_layout " , HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2 , { ( void * ) opt_channel_layout } , " set channel layout " , " layout " } ,
2012-05-05 18:22:46 +02:00
{ " af " , HAS_ARG | OPT_AUDIO | OPT_FUNC2 , { ( void * ) opt_audio_filters } , " audio filters " , " filter list " } ,
2003-08-24 17:29:48 +02:00
2005-06-03 16:31:45 +02:00
/* subtitle options */
2011-09-10 20:52:48 +02:00
{ " sn " , OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET , { . off = OFFSET ( subtitle_disable ) } , " disable subtitle " } ,
2011-09-05 22:10:26 +02:00
{ " scodec " , HAS_ARG | OPT_SUBTITLE | OPT_FUNC2 , { ( void * ) opt_subtitle_codec } , " force subtitle codec ('copy' to copy stream) " , " codec " } ,
2011-09-11 01:15:36 +02:00
{ " stag " , HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2 , { ( void * ) opt_old2new } , " force subtitle tag/fourcc " , " fourcc/tag " } ,
2005-12-17 19:14:38 +01:00
2003-08-24 17:29:48 +02:00
/* grab options */
2011-06-15 07:34:12 +02:00
{ " vc " , HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB , { ( void * ) opt_video_channel } , " deprecated, use -channel " , " channel " } ,
{ " tvstd " , HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB , { ( void * ) opt_video_standard } , " deprecated, use -standard " , " standard " } ,
2007-02-14 18:01:32 +01:00
{ " isync " , OPT_BOOL | OPT_EXPERT | OPT_GRAB , { ( void * ) & input_sync } , " sync read on input " , " " } ,
2005-12-17 19:14:38 +01:00
/* muxer options */
2011-09-05 22:10:26 +02:00
{ " muxdelay " , OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET , { . off = OFFSET ( mux_max_delay ) } , " set the maximum demux-decode delay " , " seconds " } ,
{ " muxpreload " , OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET , { . off = OFFSET ( mux_preload ) } , " set the initial demux-decode delay " , " seconds " } ,
2006-07-06 17:04:46 +02:00
2011-09-05 22:10:26 +02:00
{ " bsf " , HAS_ARG | OPT_STRING | OPT_SPEC , { . off = OFFSET ( bitstream_filters ) } , " A comma-separated list of bitstream filters " , " bitstream_filters " } ,
2011-09-11 01:12:58 +02:00
{ " absf " , HAS_ARG | OPT_AUDIO | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_old2new } , " deprecated " , " audio bitstream_filters " } ,
{ " vbsf " , HAS_ARG | OPT_VIDEO | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_old2new } , " deprecated " , " video bitstream_filters " } ,
2006-07-06 17:04:46 +02:00
2011-09-05 22:10:26 +02:00
{ " apre " , HAS_ARG | OPT_AUDIO | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_preset } , " set the audio options to the indicated preset " , " preset " } ,
{ " vpre " , HAS_ARG | OPT_VIDEO | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_preset } , " set the video options to the indicated preset " , " preset " } ,
{ " spre " , HAS_ARG | OPT_SUBTITLE | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_preset } , " set the subtitle options to the indicated preset " , " preset " } ,
{ " fpre " , HAS_ARG | OPT_EXPERT | OPT_FUNC2 , { ( void * ) opt_preset } , " set options from indicated preset file " , " filename " } ,
2011-04-14 13:32:36 +02:00
/* data codec support */
2011-09-05 22:10:26 +02:00
{ " dcodec " , HAS_ARG | OPT_DATA | OPT_FUNC2 , { ( void * ) opt_data_codec } , " force data codec ('copy' to copy stream) " , " codec " } ,
2011-12-01 18:02:04 +01:00
{ " dn " , OPT_BOOL | OPT_VIDEO | OPT_OFFSET , { . off = OFFSET ( data_disable ) } , " disable data " } ,
2008-06-07 11:12:42 +02:00
2011-05-24 18:14:42 +02:00
{ " default " , HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT , { ( void * ) opt_default } , " generic catch all option " , " " } ,
2001-07-22 16:37:44 +02:00
{ NULL , } ,
} ;
2007-09-16 20:08:51 +02:00
int main ( int argc , char * * argv )
{
2011-09-05 02:04:27 +02:00
OptionsContext o = { 0 } ;
2007-09-16 20:08:51 +02:00
int64_t ti ;
2011-09-05 03:11:18 +02:00
reset_options ( & o , 0 ) ;
2011-09-05 02:04:27 +02:00
2010-09-24 17:39:10 +02:00
av_log_set_flags ( AV_LOG_SKIP_REPEATED ) ;
2011-09-26 08:15:37 +02:00
parse_loglevel ( argc , argv , options ) ;
2010-09-24 17:39:10 +02:00
2011-04-18 13:10:52 +02:00
if ( argc > 1 & & ! strcmp ( argv [ 1 ] , " -d " ) ) {
2011-04-22 18:49:44 +02:00
run_as_daemon = 1 ;
2011-04-18 13:10:52 +02:00
av_log_set_callback ( log_callback_null ) ;
argc - - ;
argv + + ;
}
2007-11-22 17:10:02 +01:00
avcodec_register_all ( ) ;
2010-04-22 10:55:23 +02:00
# if CONFIG_AVDEVICE
2007-11-22 17:10:02 +01:00
avdevice_register_all ( ) ;
2010-05-07 11:43:21 +02:00
# endif
avfilter_register_all ( ) ;
2007-09-16 20:08:51 +02:00
av_register_all ( ) ;
2011-11-06 01:47:48 +01:00
avformat_network_init ( ) ;
2007-09-16 20:08:51 +02:00
2011-12-20 22:03:25 +01:00
show_banner ( argc , argv , options ) ;
2007-09-16 20:08:51 +02:00
2011-10-08 17:20:52 +02:00
term_init ( ) ;
2012-03-04 16:46:45 +01:00
parse_cpuflags ( argc , argv , options ) ;
2007-09-16 20:08:51 +02:00
/* parse options */
2011-09-05 02:04:27 +02:00
parse_options ( & o , argc , argv , options , opt_output_file ) ;
2007-09-16 20:08:51 +02:00
2011-12-30 03:46:24 +01:00
if ( nb_output_files < = 0 & & nb_input_files = = 0 ) {
2009-12-21 03:15:46 +01:00
show_usage ( ) ;
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_WARNING , " Use -h to get full help or, even better, run 'man %s' \n " , program_name ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2009-12-21 03:15:46 +01:00
}
2009-12-13 14:49:14 +01:00
2007-09-16 20:08:51 +02:00
/* file converter / grab */
if ( nb_output_files < = 0 ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " At least one output file must be specified \n " ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2007-09-16 20:08:51 +02:00
}
if ( nb_input_files = = 0 ) {
2011-09-27 02:14:37 +02:00
av_log ( NULL , AV_LOG_FATAL , " At least one input file must be specified \n " ) ;
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2007-09-16 20:08:51 +02:00
}
2012-04-11 19:26:09 +02:00
current_time = ti = getutime ( ) ;
2012-04-15 15:03:07 +02:00
if ( transcode ( ) < 0 )
2011-08-30 01:11:54 +02:00
exit_program ( 1 ) ;
2007-09-16 20:08:51 +02:00
ti = getutime ( ) - ti ;
if ( do_benchmark ) {
2010-02-22 23:21:58 +01:00
int maxrss = getmaxrss ( ) / 1024 ;
printf ( " bench: utime=%0.3fs maxrss=%ikB \n " , ti / 1000000.0 , maxrss ) ;
2007-09-16 20:08:51 +02:00
}
2011-08-29 07:03:24 +02:00
exit_program ( 0 ) ;
return 0 ;
2007-09-16 20:08:51 +02:00
}