#include "libswscale/swscale.h"
#include "libavcodec/opt.h"
#include "libavcodec/audioconvert.h"
-#include "libavcodec/colorspace.h"
+#include "libavcore/parseutils.h"
+#include "libavutil/colorspace.h"
#include "libavutil/fifo.h"
#include "libavutil/pixdesc.h"
#include "libavutil/avstring.h"
+#include "libavutil/libm.h"
#include "libavformat/os_support.h"
+#if CONFIG_AVFILTER
+# include "libavfilter/avfilter.h"
+# include "libavfilter/avfiltergraph.h"
+# include "libavfilter/graphparser.h"
+# include "libavfilter/vsrc_buffer.h"
+#endif
+
#if HAVE_SYS_RESOURCE_H
#include <sys/types.h>
#include <sys/time.h>
#elif HAVE_CONIO_H
#include <conio.h>
#endif
-#undef time //needed because HAVE_AV_CONFIG_H is defined on top
#include <time.h>
#include "cmdutils.h"
#undef NDEBUG
#include <assert.h>
-#undef exit
-
const char program_name[] = "FFmpeg";
const int program_birth_year = 2000;
static AVMetaDataMap meta_data_maps[MAX_FILES];
static int nb_meta_data_maps;
+/* indexed by output file stream index */
+static int streamid_map[MAX_STREAMS];
+
static int frame_width = 0;
static int frame_height = 0;
static float frame_aspect_ratio = 0;
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
-static int frame_padtop = 0;
-static int frame_padbottom = 0;
-static int frame_padleft = 0;
-static int frame_padright = 0;
-static int padcolor[3] = {16,128,128}; /* default to black */
static int frame_topBand = 0;
static int frame_bottomBand = 0;
static int frame_leftBand = 0;
static int video_disable = 0;
static int video_discard = 0;
static char *video_codec_name = NULL;
-static int video_codec_tag = 0;
+static unsigned int video_codec_tag = 0;
static char *video_language = NULL;
static int same_quality = 0;
static int do_deinterlace = 0;
static int loop_input = 0;
static int loop_output = AVFMT_NOOUTPUTLOOP;
static int qp_hist = 0;
+#if CONFIG_AVFILTER
+static char *vfilters = NULL;
+AVFilterGraph *graph = NULL;
+#endif
static int intra_only = 0;
static int audio_sample_rate = 44100;
static int audio_disable = 0;
static int audio_channels = 1;
static char *audio_codec_name = NULL;
-static int audio_codec_tag = 0;
+static unsigned int audio_codec_tag = 0;
static char *audio_language = NULL;
static int subtitle_disable = 0;
static char *subtitle_codec_name = NULL;
static char *subtitle_language = NULL;
-static int subtitle_codec_tag = 0;
+static unsigned int subtitle_codec_tag = 0;
static float mux_preload= 0.5;
static float mux_max_delay= 0.7;
static int64_t recording_time = INT64_MAX;
static int64_t start_time = 0;
-static int64_t rec_timestamp = 0;
+static int64_t recording_timestamp = 0;
static int64_t input_ts_offset = 0;
static int file_overwrite = 0;
static int metadata_count;
int original_leftBand;
int original_rightBand;
- /* padding area sizes */
- int video_pad;
- int padtop;
- int padbottom;
- int padleft;
- int padright;
-
/* audio only */
int audio_resample;
ReSampleContext *resample; /* for audio resampling */
int is_start; /* is 1 at the start and after a discontinuity */
int showed_multi_packet_warning;
int is_past_recording_time;
+#if CONFIG_AVFILTER
+ AVFilterContext *output_video_filter;
+ AVFilterContext *input_video_filter;
+ AVFrame *filter_frame;
+ int has_filter_frame;
+ AVFilterBufferRef *picref;
+#endif
} AVInputStream;
typedef struct AVInputFile {
static struct termios oldtty;
#endif
+#if CONFIG_AVFILTER
+typedef struct {
+ int pix_fmt;
+} FilterOutPriv;
+
+
+static int output_init(AVFilterContext *ctx, const char *args, void *opaque)
+{
+ FilterOutPriv *priv = ctx->priv;
+
+ if(!opaque) return -1;
+
+ priv->pix_fmt = *((int *)opaque);
+
+ return 0;
+}
+
+static void output_end_frame(AVFilterLink *link)
+{
+}
+
+static int output_query_formats(AVFilterContext *ctx)
+{
+ FilterOutPriv *priv = ctx->priv;
+ enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
+
+ avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
+ return 0;
+}
+
+static int get_filtered_video_pic(AVFilterContext *ctx,
+ AVFilterBufferRef **picref, AVFrame *pic2,
+ uint64_t *pts)
+{
+ AVFilterBufferRef *pic;
+
+ if(avfilter_request_frame(ctx->inputs[0]))
+ return -1;
+ if(!(pic = ctx->inputs[0]->cur_buf))
+ return -1;
+ *picref = pic;
+ ctx->inputs[0]->cur_buf = NULL;
+
+ *pts = pic->pts;
+
+ memcpy(pic2->data, pic->data, sizeof(pic->data));
+ memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize));
+ pic2->interlaced_frame = pic->video->interlaced;
+ pic2->top_field_first = pic->video->top_field_first;
+
+ return 1;
+}
+
+static AVFilter output_filter =
+{
+ .name = "ffmpeg_output",
+
+ .priv_size = sizeof(FilterOutPriv),
+ .init = output_init,
+
+ .query_formats = output_query_formats,
+
+ .inputs = (AVFilterPad[]) {{ .name = "default",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .end_frame = output_end_frame,
+ .min_perms = AV_PERM_READ, },
+ { .name = NULL }},
+ .outputs = (AVFilterPad[]) {{ .name = NULL }},
+};
+
+static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
+{
+ AVFilterContext *last_filter, *filter;
+ /** filter graph containing all filters including input & output */
+ AVCodecContext *codec = ost->st->codec;
+ AVCodecContext *icodec = ist->st->codec;
+ char args[255];
+ int ret;
+
+ graph = av_mallocz(sizeof(AVFilterGraph));
+
+ if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
+ return ret;
+ if ((ret = avfilter_open(&ist->output_video_filter, &output_filter, "out")) < 0)
+ return ret;
+
+ snprintf(args, 255, "%d:%d:%d", ist->st->codec->width,
+ ist->st->codec->height, ist->st->codec->pix_fmt);
+ if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &codec->pix_fmt)) < 0)
+ return ret;
+
+ /* add input and output filters to the overall graph */
+ avfilter_graph_add_filter(graph, ist->input_video_filter);
+ avfilter_graph_add_filter(graph, ist->output_video_filter);
+
+ last_filter = ist->input_video_filter;
+
+ if (ost->video_crop) {
+ snprintf(args, 255, "%d:%d:%d:%d", ost->leftBand, ost->topBand,
+ codec->width,
+ codec->height);
+ if ((ret = avfilter_open(&filter, avfilter_get_by_name("crop"), NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
+ return ret;
+ last_filter = filter;
+ avfilter_graph_add_filter(graph, last_filter);
+ }
+
+ if((codec->width !=
+ icodec->width - (frame_leftBand + frame_rightBand)) ||
+ (codec->height != icodec->height - (frame_topBand + frame_bottomBand))) {
+ snprintf(args, 255, "%d:%d:flags=0x%X",
+ codec->width,
+ codec->height,
+ (int)av_get_int(sws_opts, "sws_flags", NULL));
+ if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
+ return ret;
+ last_filter = filter;
+ avfilter_graph_add_filter(graph, last_filter);
+ }
+
+ snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
+ graph->scale_sws_opts = av_strdup(args);
+
+ if (vfilters) {
+ AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
+ AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
+
+ outputs->name = av_strdup("in");
+ outputs->filter = last_filter;
+ outputs->pad_idx = 0;
+ outputs->next = NULL;
+
+ inputs->name = av_strdup("out");
+ inputs->filter = ist->output_video_filter;
+ inputs->pad_idx = 0;
+ inputs->next = NULL;
+
+ if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
+ return ret;
+ av_freep(&vfilters);
+ } else {
+ if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
+ return ret;
+ }
+
+ /* configure all the filter links */
+ if ((ret = avfilter_graph_check_validity(graph, NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_graph_config_formats(graph, NULL)) < 0)
+ return ret;
+ if ((ret = avfilter_graph_config_links(graph, NULL)) < 0)
+ return ret;
+
+ codec->width = ist->output_video_filter->inputs[0]->w;
+ codec->height = ist->output_video_filter->inputs[0]->h;
+
+ return 0;
+}
+#endif /* CONFIG_AVFILTER */
+
static void term_exit(void)
{
#if HAVE_TERMIOS_H
tcgetattr (0, &tty);
oldtty = tty;
+ atexit(term_exit);
tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
|INLCR|IGNCR|ICRNL|IXON);
#ifdef SIGXCPU
signal(SIGXCPU, sigterm_handler);
#endif
-
- /*
- register a function to be called at normal program termination
- */
- atexit(term_exit);
-#if CONFIG_BEOS_NETSERVER
- fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
-#endif
}
/* read a key without blocking */
#if HAVE_TERMIOS_H
int n = 1;
unsigned char ch;
-#if !CONFIG_BEOS_NETSERVER
struct timeval tv;
fd_set rfds;
tv.tv_sec = 0;
tv.tv_usec = 0;
n = select(1, &rfds, NULL, NULL, &tv);
-#endif
if (n > 0) {
n = read(0, &ch, 1);
if (n == 1)
return q_pressed || (q_pressed = read_key() == 'q');
}
-static int av_exit(int ret)
+static int ffmpeg_exit(int ret)
{
int i;
av_free(video_standard);
-#if CONFIG_POWERPC_PERF
- void powerpc_display_perf_report(void);
- powerpc_display_perf_report();
-#endif /* CONFIG_POWERPC_PERF */
-
- for (i=0;i<CODEC_TYPE_NB;i++)
+ for (i=0;i<AVMEDIA_TYPE_NB;i++)
av_free(avcodec_opts[i]);
av_free(avformat_opts);
av_free(sws_opts);
allocated_audio_buf_size= allocated_audio_out_size= 0;
av_free(samples);
+#if CONFIG_AVFILTER
+ avfilter_uninit();
+#endif
+
if (received_sigterm) {
fprintf(stderr,
"Received signal %d: terminating.\n",
return ret;
}
+static void choose_sample_fmt(AVStream *st, AVCodec *codec)
+{
+ if(codec && codec->sample_fmts){
+ const enum SampleFormat *p= codec->sample_fmts;
+ for(; *p!=-1; p++){
+ if(*p == st->codec->sample_fmt)
+ break;
+ }
+ if(*p == -1)
+ st->codec->sample_fmt = codec->sample_fmts[0];
+ }
+}
+
+static void choose_sample_rate(AVStream *st, AVCodec *codec)
+{
+ if(codec && codec->supported_samplerates){
+ const int *p= codec->supported_samplerates;
+ int best=0;
+ int best_dist=INT_MAX;
+ for(; *p; p++){
+ int dist= abs(st->codec->sample_rate - *p);
+ if(dist < best_dist){
+ best_dist= dist;
+ best= *p;
+ }
+ }
+ if(best_dist){
+ av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
+ }
+ st->codec->sample_rate= best;
+ }
+}
+
+static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
+{
+ if(codec && codec->pix_fmts){
+ const enum PixelFormat *p= codec->pix_fmts;
+ for(; *p!=-1; p++){
+ if(*p == st->codec->pix_fmt)
+ break;
+ }
+ if(*p == -1
+ && !( st->codec->codec_id==CODEC_ID_MJPEG
+ && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
+ && ( st->codec->pix_fmt == PIX_FMT_YUV420P
+ || st->codec->pix_fmt == PIX_FMT_YUV422P)))
+ st->codec->pix_fmt = codec->pix_fmts[0];
+ }
+}
+
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
{
int i, err;
s->nb_streams = ic->nb_streams;
for(i=0;i<ic->nb_streams;i++) {
AVStream *st;
+ AVCodec *codec;
// FIXME: a more elegant solution is needed
st = av_mallocz(sizeof(AVStream));
st->codec = avcodec_alloc_context();
if (!st->codec) {
print_error(filename, AVERROR(ENOMEM));
- av_exit(1);
+ ffmpeg_exit(1);
}
- memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
+ avcodec_copy_context(st->codec, ic->streams[i]->codec);
s->streams[i] = st;
- if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
- st->stream_copy = 1;
- else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
- st->stream_copy = 1;
+ codec = avcodec_find_encoder(st->codec->codec_id);
+ if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
+ if (audio_stream_copy) {
+ st->stream_copy = 1;
+ } else
+ choose_sample_fmt(st, codec);
+ } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+ if (video_stream_copy) {
+ st->stream_copy = 1;
+ } else
+ choose_pixel_fmt(st, codec);
+ }
if(!st->codec->thread_count)
st->codec->thread_count = 1;
int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
&new_pkt.data, &new_pkt.size,
pkt->data, pkt->size,
- pkt->flags & PKT_FLAG_KEY);
+ pkt->flags & AV_PKT_FLAG_KEY);
if(a>0){
av_free_packet(pkt);
new_pkt.destruct= av_destruct_packet;
avctx->codec ? avctx->codec->name : "copy");
print_error("", a);
if (exit_on_error)
- av_exit(1);
+ ffmpeg_exit(1);
}
*pkt= new_pkt;
ret= av_interleaved_write_frame(s, pkt);
if(ret < 0){
print_error("av_interleaved_write_frame()", ret);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
+ audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
audio_buf_size*= osize*enc->channels;
audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
fprintf(stderr, "Buffer sizes too large\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
if (!audio_buf || !audio_out){
fprintf(stderr, "Out of memory in do_audio_out\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if (enc->channels != dec->channels)
fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
dec->channels, dec->sample_rate,
enc->channels, enc->sample_rate);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
avcodec_get_sample_fmt_name(dec->sample_fmt),
avcodec_get_sample_fmt_name(enc->sample_fmt));
- av_exit(1);
+ ffmpeg_exit(1);
}
ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
}
if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
printf("av_audio_convert() failed\n");
if (exit_on_error)
- av_exit(1);
+ ffmpeg_exit(1);
return;
}
buftmp = audio_buf;
/* output resampled raw samples */
if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
fprintf(stderr, "av_fifo_realloc2() failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
(short *)audio_buf);
if (ret < 0) {
fprintf(stderr, "Audio encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
audio_size += ret;
pkt.stream_index= ost->index;
pkt.size= ret;
if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
ost->sync_opts += enc->frame_size;
if(size_out > audio_out_size){
fprintf(stderr, "Internal error, buffer size too small\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
//FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
(short *)buftmp);
if (ret < 0) {
fprintf(stderr, "Audio encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
audio_size += ret;
pkt.stream_index= ost->index;
pkt.size= ret;
if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
}
}
if (pts == AV_NOPTS_VALUE) {
fprintf(stderr, "Subtitle packets must have a pts\n");
if (exit_on_error)
- av_exit(1);
+ ffmpeg_exit(1);
return;
}
subtitle_out_max_size, sub);
if (subtitle_out_size < 0) {
fprintf(stderr, "Subtitle encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
av_init_packet(&pkt);
int *frame_size)
{
int nb_frames, i, ret;
+#if !CONFIG_AVFILTER
int64_t topBand, bottomBand, leftBand, rightBand;
+#endif
AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
AVFrame picture_crop_temp, picture_pad_temp;
AVCodecContext *enc, *dec;
+ double sync_ipts;
avcodec_get_frame_defaults(&picture_crop_temp);
avcodec_get_frame_defaults(&picture_pad_temp);
enc = ost->st->codec;
dec = ist->st->codec;
+ sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
+
/* by default, we output a single frame */
nb_frames = 1;
*frame_size = 0;
if(video_sync_method){
- double vdelta;
- vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
+ double vdelta = sync_ipts - ost->sync_opts;
//FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
if (vdelta < -1.1)
nb_frames = 0;
if(vdelta<=-0.6){
nb_frames=0;
}else if(vdelta>0.6)
- ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
+ ost->sync_opts= lrintf(sync_ipts);
}else if (vdelta > 1.1)
nb_frames = lrintf(vdelta);
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
fprintf(stderr, "*** %d dup!\n", nb_frames-1);
}
}else
- ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
+ ost->sync_opts= lrintf(sync_ipts);
- nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
+ nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
if (nb_frames <= 0)
return;
+#if CONFIG_AVFILTER
+ formatted_picture = in_picture;
+#else
if (ost->video_crop) {
if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
fprintf(stderr, "error cropping picture\n");
if (exit_on_error)
- av_exit(1);
+ ffmpeg_exit(1);
return;
}
formatted_picture = &picture_crop_temp;
} else {
formatted_picture = in_picture;
}
+#endif
final_picture = formatted_picture;
padding_src = formatted_picture;
resampling_dst = &ost->pict_tmp;
- if (ost->video_pad) {
- final_picture = &ost->pict_tmp;
- if (ost->video_resample) {
- if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
- fprintf(stderr, "error padding picture\n");
- if (exit_on_error)
- av_exit(1);
- return;
- }
- resampling_dst = &picture_pad_temp;
- }
- }
if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
|| (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
if(!ost->video_resample)
- av_exit(1);
+ ffmpeg_exit(1);
}
+#if !CONFIG_AVFILTER
if (ost->video_resample) {
padding_src = NULL;
final_picture = &ost->pict_tmp;
ist->st->codec->width - (ost->leftBand + ost->rightBand),
ist->st->codec->height - (ost->topBand + ost->bottomBand),
ist->st->codec->pix_fmt,
- ost->st->codec->width - (ost->padleft + ost->padright),
- ost->st->codec->height - (ost->padtop + ost->padbottom),
+ ost->st->codec->width,
+ ost->st->codec->height,
ost->st->codec->pix_fmt,
sws_flags, NULL, NULL, NULL);
if (ost->img_resample_ctx == NULL) {
fprintf(stderr, "Cannot get resampling context\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
}
sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
}
-
- if (ost->video_pad) {
- av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
- enc->height, enc->width, enc->pix_fmt,
- ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
- }
+#endif
/* duplicates frame if needed */
for(i=0;i<nb_frames;i++) {
pkt.data= (uint8_t *)final_picture;
pkt.size= sizeof(AVPicture);
pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
enc->coded_frame = old_frame;
/* better than nothing: use input picture interlaced
settings */
big_picture.interlaced_frame = in_picture->interlaced_frame;
- if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
+ if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
if(top_field_first == -1)
big_picture.top_field_first = in_picture->top_field_first;
else
/* handles sameq here. This is not correct because it may
not be a global option */
- if (same_quality) {
- big_picture.quality = ist->st->quality;
- }else
- big_picture.quality = ost->st->quality;
+ big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
if(!me_threshold)
big_picture.pict_type = 0;
// big_picture.pts = AV_NOPTS_VALUE;
&big_picture);
if (ret < 0) {
fprintf(stderr, "Video encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if(ret>0){
pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
if(enc->coded_frame->key_frame)
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
*frame_size = ret;
video_size += ret;
vstats_file = fopen(vstats_filename, "w");
if (!vstats_file) {
perror("fopen");
- av_exit(1);
+ ffmpeg_exit(1);
}
}
enc = ost->st->codec;
- if (enc->codec_type == CODEC_TYPE_VIDEO) {
+ 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)
for(i=0;i<nb_ostreams;i++) {
ost = ost_table[i];
enc = ost->st->codec;
- if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
+ if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
!ost->st->stream_copy ?
enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
}
- if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
+ if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
float t = (av_gettime()-timer_start) / 1000000.0;
frame_number = ost->frame_number;
void *buffer_to_free;
static unsigned int samples_size= 0;
AVSubtitle subtitle, *subtitle_to_free;
- int got_subtitle;
+#if CONFIG_AVFILTER
+ int frame_available;
+#endif
+
AVPacket avpkt;
int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
subtitle_to_free = NULL;
if (ist->decoding_needed) {
switch(ist->st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:{
+ case AVMEDIA_TYPE_AUDIO:{
if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
av_free(samples);
ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
(ist->st->codec->sample_rate * ist->st->codec->channels);
break;}
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
/* XXX: allocate picture correctly */
avcodec_get_frame_defaults(&picture);
}
avpkt.size = 0;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
ret = avcodec_decode_subtitle2(ist->st->codec,
- &subtitle, &got_subtitle, &avpkt);
+ &subtitle, &got_picture, &avpkt);
if (ret < 0)
goto fail_decode;
- if (!got_subtitle) {
+ if (!got_picture) {
goto discard_packet;
}
subtitle_to_free = &subtitle;
}
} else {
switch(ist->st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
ist->st->codec->sample_rate;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
if (ist->st->codec->time_base.num != 0) {
int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
ist->next_pts += ((int64_t)AV_TIME_BASE *
}
buffer_to_free = NULL;
- if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
pre_process_video_frame(ist, (AVPicture *)&picture,
&buffer_to_free);
}
+#if CONFIG_AVFILTER
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
+ // add it to be filtered
+ av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
+ ist->pts,
+ ist->st->codec->sample_aspect_ratio);
+ }
+#endif
+
// preprocess audio (volume)
- if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
if (audio_volume != 256) {
short *volp;
volp = samples;
if (pts > now)
usleep(pts - now);
}
-
+#if CONFIG_AVFILTER
+ frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
+ !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
+#endif
/* if output time reached then transcode raw format,
encode packets and output them */
if (start_time == 0 || ist->pts >= start_time)
+#if CONFIG_AVFILTER
+ while (frame_available) {
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
+ get_filtered_video_pic(ist->output_video_filter, &ist->picref, &picture, &ist->pts);
+#endif
for(i=0;i<nb_ostreams;i++) {
int frame_size;
if (ost->encoding_needed) {
assert(ist->decoding_needed);
switch(ost->st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
+#if CONFIG_AVFILTER
+ if (ist->picref->video)
+ ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
+#endif
do_video_out(os, ost, ist, &picture, &frame_size);
if (vstats_filename && frame_size)
do_video_stats(os, ost, frame_size);
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
do_subtitle_out(os, ost, ist, &subtitle,
pkt->pts);
break;
av_init_packet(&opkt);
- if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
+ if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
continue;
/* no reencoding needed : output the packet directly */
avcodec_get_frame_defaults(&avframe);
ost->st->codec->coded_frame= &avframe;
- avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
+ avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
- if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
+ if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
audio_size += data_size;
- else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
+ else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
video_size += data_size;
ost->sync_opts++;
}
&& ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
&& ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
) {
- if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
+ if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
opkt.destruct= av_destruct_packet;
} else {
opkt.data = data_buf;
}
}
}
+
+#if CONFIG_AVFILTER
+ frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
+ ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
+ if(ist->picref)
+ avfilter_unref_buffer(ist->picref);
+ }
+#endif
av_free(buffer_to_free);
/* XXX: allocate the subtitles in the codec ? */
if (subtitle_to_free) {
AVCodecContext *enc= ost->st->codec;
os = output_files[ost->file_index];
- if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
+ if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
continue;
- if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
+ if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
continue;
if (ost->encoding_needed) {
pkt.stream_index= ost->index;
switch(ost->st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
fifo_bytes = av_fifo_size(ost->fifo);
ret = 0;
/* encode any samples remaining in fifo */
int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
int fs_tmp = enc->frame_size;
- av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
+ av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
enc->frame_size = fifo_bytes / (osize * enc->channels);
} else { /* pad */
int frame_bytes = enc->frame_size*osize*enc->channels;
- if (samples_size < frame_bytes)
- av_exit(1);
- memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
+ if (allocated_audio_buf_size < frame_bytes)
+ ffmpeg_exit(1);
+ memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
}
- ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
+ ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
ost->st->time_base.num, enc->sample_rate);
enc->frame_size = fs_tmp;
}
if (ret < 0) {
fprintf(stderr, "Audio encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
audio_size += ret;
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
if (ret < 0) {
fprintf(stderr, "Video encoding failed\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
video_size += ret;
if(enc->coded_frame && enc->coded_frame->key_frame)
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
if (ost->logfile && enc->stats_out) {
fprintf(ost->logfile, "%s", enc->stats_out);
}
fflush(stdout);
}
+static int copy_chapters(int infile, int outfile)
+{
+ AVFormatContext *is = input_files[infile];
+ AVFormatContext *os = output_files[outfile];
+ int i;
+
+ for (i = 0; i < is->nb_chapters; i++) {
+ AVChapter *in_ch = is->chapters[i], *out_ch;
+ AVMetadataTag *t = NULL;
+ int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
+ AV_TIME_BASE_Q, in_ch->time_base);
+ int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
+ av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
+
+
+ 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);
+
+ while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
+ av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
+
+ os->nb_chapters++;
+ os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
+ if (!os->chapters)
+ return AVERROR(ENOMEM);
+ os->chapters[os->nb_chapters - 1] = out_ch;
+ }
+ return 0;
+}
+
/*
* The following code is the main loop of the file converter
*/
-static int av_encode(AVFormatContext **output_files,
+static int transcode(AVFormatContext **output_files,
int nb_output_files,
AVFormatContext **input_files,
int nb_input_files,
if (!os->nb_streams) {
dump_format(output_files[i], i, output_files[i]->filename, 1);
fprintf(stderr, "Output file #%d does not contain any stream\n", i);
- av_exit(1);
+ ret = AVERROR(EINVAL);
+ goto fail;
}
nb_ostreams += os->nb_streams;
}
if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
fprintf(stderr, "Number of stream maps must match number of output streams\n");
- av_exit(1);
+ ret = AVERROR(EINVAL);
+ goto fail;
}
/* Sanity check the mapping args -- do the input files & streams exist? */
if (fi < 0 || fi > nb_input_files - 1 ||
si < 0 || si > file_table[fi].nb_streams - 1) {
fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
- av_exit(1);
+ ret = AVERROR(EINVAL);
+ goto fail;
}
fi = stream_maps[i].sync_file_index;
si = stream_maps[i].sync_stream_index;
if (fi < 0 || fi > nb_input_files - 1 ||
si < 0 || si > file_table[fi].nb_streams - 1) {
fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
- av_exit(1);
+ ret = AVERROR(EINVAL);
+ goto fail;
}
}
fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
stream_maps[n].file_index, stream_maps[n].stream_index,
ost->file_index, ost->index);
- av_exit(1);
+ ffmpeg_exit(1);
}
} else {
int best_nb_frames=-1;
- /* get corresponding input stream index : we select the first one with the right type */
- found = 0;
- for(j=0;j<nb_istreams;j++) {
- int skip=0;
- ist = ist_table[j];
- if(opt_programid){
- int pi,si;
- AVFormatContext *f= input_files[ ist->file_index ];
- skip=1;
- for(pi=0; pi<f->nb_programs; pi++){
- AVProgram *p= f->programs[pi];
- if(p->id == opt_programid)
- for(si=0; si<p->nb_stream_indexes; si++){
- if(f->streams[ p->stream_index[si] ] == ist->st)
- skip=0;
- }
- }
+ /* get corresponding input stream index : we select the first one with the right type */
+ found = 0;
+ for(j=0;j<nb_istreams;j++) {
+ int skip=0;
+ ist = ist_table[j];
+ if(opt_programid){
+ int pi,si;
+ AVFormatContext *f= input_files[ ist->file_index ];
+ skip=1;
+ for(pi=0; pi<f->nb_programs; pi++){
+ AVProgram *p= f->programs[pi];
+ if(p->id == opt_programid)
+ for(si=0; si<p->nb_stream_indexes; si++){
+ if(f->streams[ p->stream_index[si] ] == ist->st)
+ skip=0;
+ }
}
- if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
- ist->st->codec->codec_type == ost->st->codec->codec_type) {
- if(best_nb_frames < ist->st->codec_info_nb_frames){
- best_nb_frames= ist->st->codec_info_nb_frames;
- ost->source_index = j;
- found = 1;
- }
+ }
+ if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
+ ist->st->codec->codec_type == ost->st->codec->codec_type) {
+ if(best_nb_frames < ist->st->codec_info_nb_frames){
+ best_nb_frames= ist->st->codec_info_nb_frames;
+ ost->source_index = j;
+ found = 1;
}
}
+ }
if (!found) {
if(! opt_programid) {
dump_format(output_files[i], i, output_files[i]->filename, 1);
fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
ost->file_index, ost->index);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
}
/* for each output stream, we compute the right encoding parameters */
for(i=0;i<nb_ostreams;i++) {
- AVMetadataTag *t = NULL, *lang = NULL;
+ AVMetadataTag *t = NULL;
ost = ost_table[i];
os = output_files[ost->file_index];
ist = ist_table[ost->source_index];
codec = ost->st->codec;
icodec = ist->st->codec;
- if (av_metadata_get(ist->st->metadata, "language", NULL, 0))
- lang = av_metadata_get(ost->st->metadata, "language", NULL, 0);
while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
- if (lang && !strcmp(t->key, "language"))
- continue;
- av_metadata_set2(&ost->st->metadata, t->key, t->value, NULL);
+ av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
}
ost->st->disposition = ist->st->disposition;
codec->chroma_sample_location = icodec->chroma_sample_location;
if (ost->st->stream_copy) {
+ uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
+
+ if (extra_size > INT_MAX)
+ goto fail;
+
/* if stream_copy is selected, no need to decode or encode */
codec->codec_id = icodec->codec_id;
codec->codec_type = icodec->codec_type;
}
codec->bit_rate = icodec->bit_rate;
- codec->extradata= icodec->extradata;
+ codec->extradata= av_mallocz(extra_size);
+ if (!codec->extradata)
+ goto fail;
+ memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
codec->extradata_size= icodec->extradata_size;
if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
codec->time_base = icodec->time_base;
codec->time_base.num *= icodec->ticks_per_frame;
+ av_reduce(&codec->time_base.num, &codec->time_base.den,
+ codec->time_base.num, codec->time_base.den, INT_MAX);
}else
codec->time_base = ist->st->time_base;
switch(codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
if(audio_volume != 256) {
fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
codec->channel_layout = icodec->channel_layout;
codec->sample_rate = icodec->sample_rate;
if(codec->codec_id == CODEC_ID_AC3)
codec->block_align= 0;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
codec->pix_fmt = icodec->pix_fmt;
codec->width = icodec->width;
codec->height = icodec->height;
codec->has_b_frames = icodec->has_b_frames;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
codec->width = icodec->width;
codec->height = icodec->height;
break;
}
} else {
switch(codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
ost->fifo= av_fifo_alloc(1024);
if(!ost->fifo)
goto fail;
ist->decoding_needed = 1;
ost->encoding_needed = 1;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
- fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
- av_exit(1);
+ fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
+ ffmpeg_exit(1);
}
ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
- ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
ost->video_resample = ((codec->width != icodec->width -
- (frame_leftBand + frame_rightBand) +
- (frame_padleft + frame_padright)) ||
+ (frame_leftBand + frame_rightBand)) ||
(codec->height != icodec->height -
- (frame_topBand + frame_bottomBand) +
- (frame_padtop + frame_padbottom)) ||
+ (frame_topBand + frame_bottomBand)) ||
(codec->pix_fmt != icodec->pix_fmt));
if (ost->video_crop) {
ost->topBand = ost->original_topBand = frame_topBand;
ost->leftBand = ost->original_leftBand = frame_leftBand;
ost->rightBand = ost->original_rightBand = frame_rightBand;
}
- if (ost->video_pad) {
- ost->padtop = frame_padtop;
- ost->padleft = frame_padleft;
- ost->padbottom = frame_padbottom;
- ost->padright = frame_padright;
- if (!ost->video_resample) {
- avcodec_get_frame_defaults(&ost->pict_tmp);
- if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
- codec->width, codec->height))
- goto fail;
- }
- }
if (ost->video_resample) {
avcodec_get_frame_defaults(&ost->pict_tmp);
if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
codec->width, codec->height)) {
fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
ost->img_resample_ctx = sws_getContext(
icodec->width - (frame_leftBand + frame_rightBand),
icodec->height - (frame_topBand + frame_bottomBand),
icodec->pix_fmt,
- codec->width - (frame_padleft + frame_padright),
- codec->height - (frame_padtop + frame_padbottom),
+ codec->width,
+ codec->height,
codec->pix_fmt,
sws_flags, NULL, NULL, NULL);
if (ost->img_resample_ctx == NULL) {
fprintf(stderr, "Cannot get resampling context\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
+#if !CONFIG_AVFILTER
ost->original_height = icodec->height;
ost->original_width = icodec->width;
-
+#endif
codec->bits_per_raw_sample= 0;
}
ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
ost->resample_pix_fmt= icodec->pix_fmt;
ost->encoding_needed = 1;
ist->decoding_needed = 1;
+
+#if CONFIG_AVFILTER
+ if (configure_filters(ist, ost)) {
+ fprintf(stderr, "Error opening filters!\n");
+ exit(1);
+ }
+#endif
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
ost->encoding_needed = 1;
ist->decoding_needed = 1;
break;
(codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
char logfilename[1024];
FILE *f;
- int size;
- char *logbuffer;
snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
i);
if (codec->flags & CODEC_FLAG_PASS1) {
- f = fopen(logfilename, "w");
+ f = fopen(logfilename, "wb");
if (!f) {
fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
- av_exit(1);
+ ffmpeg_exit(1);
}
ost->logfile = f;
} else {
- /* read the log file */
- f = fopen(logfilename, "r");
- if (!f) {
- fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
- av_exit(1);
- }
- fseek(f, 0, SEEK_END);
- size = ftell(f);
- fseek(f, 0, SEEK_SET);
- logbuffer = av_malloc(size + 1);
- if (!logbuffer) {
- fprintf(stderr, "Could not allocate log buffer\n");
- av_exit(1);
+ char *logbuffer;
+ size_t logbuffer_size;
+ if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
+ fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
+ ffmpeg_exit(1);
}
- size = fread(logbuffer, 1, size, f);
- fclose(f);
- logbuffer[size] = '\0';
codec->stats_in = logbuffer;
}
}
}
- if(codec->codec_type == CODEC_TYPE_VIDEO){
+ if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
int size= codec->width * codec->height;
bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
}
ret = AVERROR(EINVAL);
goto dump_format;
}
- //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
+ //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
// ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
}
}
mtag=NULL;
while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
- av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
+ av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
av_metadata_conv(out_file, out_file->oformat->metadata_conv,
in_file->iformat->metadata_conv);
}
+ /* copy chapters from the first input file that has them*/
+ for (i = 0; i < nb_input_files; i++) {
+ if (!input_files[i]->nb_chapters)
+ continue;
+
+ for (j = 0; j < nb_output_files; j++)
+ if ((ret = copy_chapters(i, j)) < 0)
+ goto dump_format;
+ }
+
/* open files and write file headers */
for(i=0;i<nb_output_files;i++) {
os = output_files[i];
}
/* finish if limit size exhausted */
- if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
+ if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
break;
/* read a frame from it and output it in the fifo */
fprintf(stderr, "Error while decoding stream #%d.%d\n",
ist->file_index, ist->index);
if (exit_on_error)
- av_exit(1);
+ ffmpeg_exit(1);
av_free_packet(&pkt);
goto redo;
}
avcodec_close(ist->st->codec);
}
}
+#if CONFIG_AVFILTER
+ if (graph) {
+ avfilter_graph_destroy(graph);
+ av_freep(&graph);
+ }
+#endif
/* finished ! */
ret = 0;
for(i=0;i<nb_ostreams;i++) {
ost = ost_table[i];
if (ost) {
+ if (ost->st->stream_copy)
+ av_freep(&ost->st->codec->extradata);
if (ost->logfile) {
fclose(ost->logfile);
ost->logfile = NULL;
static int opt_frame_rate(const char *opt, const char *arg)
{
- if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
+ if (av_parse_video_rate(&frame_rate, arg) < 0) {
fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
- av_exit(1);
+ ffmpeg_exit(1);
}
return 0;
}
static int opt_bitrate(const char *opt, const char *arg)
{
- int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
+ int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
opt_default(opt, arg);
frame_topBand = atoi(arg);
if (frame_topBand < 0) {
fprintf(stderr, "Incorrect top crop size\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if ((frame_topBand) >= frame_height){
fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
+ fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
frame_height -= frame_topBand;
}
frame_bottomBand = atoi(arg);
if (frame_bottomBand < 0) {
fprintf(stderr, "Incorrect bottom crop size\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if ((frame_bottomBand) >= frame_height){
fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
+ fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
frame_height -= frame_bottomBand;
}
frame_leftBand = atoi(arg);
if (frame_leftBand < 0) {
fprintf(stderr, "Incorrect left crop size\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if ((frame_leftBand) >= frame_width){
fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
+ fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
frame_width -= frame_leftBand;
}
frame_rightBand = atoi(arg);
if (frame_rightBand < 0) {
fprintf(stderr, "Incorrect right crop size\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if ((frame_rightBand) >= frame_width){
fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
+ fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
frame_width -= frame_rightBand;
}
static void opt_frame_size(const char *arg)
{
- if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
+ if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
fprintf(stderr, "Incorrect frame size\n");
- av_exit(1);
- }
-}
-
-static void opt_pad_color(const char *arg) {
- /* Input is expected to be six hex digits similar to
- how colors are expressed in html tags (but without the #) */
- int rgb = strtol(arg, NULL, 16);
- int r,g,b;
-
- r = (rgb >> 16);
- g = ((rgb >> 8) & 255);
- b = (rgb & 255);
-
- padcolor[0] = RGB_TO_Y(r,g,b);
- padcolor[1] = RGB_TO_U(r,g,b,0);
- padcolor[2] = RGB_TO_V(r,g,b,0);
-}
-
-static void opt_frame_pad_top(const char *arg)
-{
- frame_padtop = atoi(arg);
- if (frame_padtop < 0) {
- fprintf(stderr, "Incorrect top pad size\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
}
-static void opt_frame_pad_bottom(const char *arg)
-{
- frame_padbottom = atoi(arg);
- if (frame_padbottom < 0) {
- fprintf(stderr, "Incorrect bottom pad size\n");
- av_exit(1);
- }
-}
-
-
-static void opt_frame_pad_left(const char *arg)
-{
- frame_padleft = atoi(arg);
- if (frame_padleft < 0) {
- fprintf(stderr, "Incorrect left pad size\n");
- av_exit(1);
- }
-}
-
-
-static void opt_frame_pad_right(const char *arg)
-{
- frame_padright = atoi(arg);
- if (frame_padright < 0) {
- fprintf(stderr, "Incorrect right pad size\n");
- av_exit(1);
- }
+static int opt_pad(const char *opt, const char *arg) {
+ fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
+ return -1;
}
static void opt_frame_pix_fmt(const char *arg)
frame_pix_fmt = av_get_pix_fmt(arg);
if (frame_pix_fmt == PIX_FMT_NONE) {
fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
- av_exit(1);
+ ffmpeg_exit(1);
}
} else {
show_pix_fmts();
- av_exit(0);
+ ffmpeg_exit(0);
}
}
if (!ar) {
fprintf(stderr, "Incorrect aspect ratio specification.\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
frame_aspect_ratio = ar;
}
if(!mid){
fprintf(stderr, "Missing =\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
*mid++= 0;
if (video_qscale <= 0 ||
video_qscale > 255) {
fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
}
audio_sample_fmt = avcodec_get_sample_fmt(arg);
else {
list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
- av_exit(0);
+ ffmpeg_exit(0);
}
}
static void opt_audio_codec(const char *arg)
{
- opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
+ opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
}
static void opt_audio_tag(const char *arg)
static void opt_video_codec(const char *arg)
{
- opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
+ opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
}
static void opt_subtitle_codec(const char *arg)
{
- opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
+ opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
}
static void opt_subtitle_tag(const char *arg)
scale= strtod(p, &p);
if(stream >= MAX_STREAMS)
- av_exit(1);
+ ffmpeg_exit(1);
input_files_ts_scale[nb_input_files][stream]= scale;
}
return 0;
}
-static int opt_rec_timestamp(const char *opt, const char *arg)
+static int opt_recording_timestamp(const char *opt, const char *arg)
{
- rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
+ recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
return 0;
}
return 0;
}
-static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
+static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
{
const char *codec_string = encoder ? "encoder" : "decoder";
AVCodec *codec;
avcodec_find_decoder_by_name(name);
if(!codec) {
fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
- av_exit(1);
+ ffmpeg_exit(1);
}
if(codec->type != type) {
fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
- av_exit(1);
+ ffmpeg_exit(1);
+ }
+ if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
+ strict > FF_COMPLIANCE_EXPERIMENTAL) {
+ fprintf(stderr, "%s '%s' is experimental and might produce bad "
+ "results.\nAdd '-strict experimental' if you want to use it.\n",
+ codec_string, codec->name);
+ codec = encoder ?
+ avcodec_find_encoder(codec->id) :
+ avcodec_find_decoder(codec->id);
+ if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
+ fprintf(stderr, "Or use the non experimental %s '%s'.\n",
+ codec_string, codec->name);
+ ffmpeg_exit(1);
}
return codec->id;
}
int64_t timestamp;
if (last_asked_format) {
- file_iformat = av_find_input_format(last_asked_format);
+ if (!(file_iformat = av_find_input_format(last_asked_format))) {
+ fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
+ ffmpeg_exit(1);
+ }
last_asked_format = NULL;
}
ic = avformat_alloc_context();
if (!ic) {
print_error(filename, AVERROR(ENOMEM));
- av_exit(1);
+ ffmpeg_exit(1);
}
memset(ap, 0, sizeof(*ap));
ap->channels = audio_channels;
ap->time_base.den = frame_rate.num;
ap->time_base.num = frame_rate.den;
- ap->width = frame_width + frame_padleft + frame_padright;
- ap->height = frame_height + frame_padtop + frame_padbottom;
+ ap->width = frame_width;
+ ap->height = frame_height;
ap->pix_fmt = frame_pix_fmt;
// ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
ap->channel = video_channel;
set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
- ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
- ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
- ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
+ ic->video_codec_id =
+ find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
+ avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
+ ic->audio_codec_id =
+ find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
+ avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
+ ic->subtitle_codec_id=
+ find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
+ avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
ic->flags |= AVFMT_FLAG_NONBLOCK;
if(pgmyuv_compatibility_hack)
err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
if (err < 0) {
print_error(filename, err);
- av_exit(1);
+ ffmpeg_exit(1);
}
if(opt_programid) {
int i, j;
}else{
found=1;
for(j=0; j<p->nb_stream_indexes; j++){
- ic->streams[p->stream_index[j]]->discard= 0;
+ ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
}
}
}
if(!found){
fprintf(stderr, "Specified program id not found\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
opt_programid=0;
}
ret = av_find_stream_info(ic);
if (ret < 0 && verbose >= 0) {
fprintf(stderr, "%s: could not find codec parameters\n", filename);
- av_exit(1);
+ av_close_input_file(ic);
+ ffmpeg_exit(1);
}
timestamp = start_time;
/* update the current parameters so that they match the one of the input stream */
for(i=0;i<ic->nb_streams;i++) {
AVStream *st = ic->streams[i];
- AVCodecContext *enc = st->codec;
- avcodec_thread_init(enc, thread_count);
- switch(enc->codec_type) {
- case CODEC_TYPE_AUDIO:
- set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
- //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
- channel_layout = enc->channel_layout;
- audio_channels = enc->channels;
- audio_sample_rate = enc->sample_rate;
- audio_sample_fmt = enc->sample_fmt;
+ AVCodecContext *dec = st->codec;
+ avcodec_thread_init(dec, thread_count);
+ switch (dec->codec_type) {
+ case AVMEDIA_TYPE_AUDIO:
+ set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
+ //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
+ channel_layout = dec->channel_layout;
+ audio_channels = dec->channels;
+ audio_sample_rate = dec->sample_rate;
+ audio_sample_fmt = dec->sample_fmt;
input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
if(audio_disable)
st->discard= AVDISCARD_ALL;
break;
- case CODEC_TYPE_VIDEO:
- set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
- frame_height = enc->height;
- frame_width = enc->width;
+ case AVMEDIA_TYPE_VIDEO:
+ set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
+ frame_height = dec->height;
+ frame_width = dec->width;
if(ic->streams[i]->sample_aspect_ratio.num)
frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
else
- frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
- frame_aspect_ratio *= (float) enc->width / enc->height;
- frame_pix_fmt = enc->pix_fmt;
+ frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
+ frame_aspect_ratio *= (float) dec->width / dec->height;
+ frame_pix_fmt = dec->pix_fmt;
rfps = ic->streams[i]->r_frame_rate.num;
rfps_base = ic->streams[i]->r_frame_rate.den;
- if(enc->lowres) {
- enc->flags |= CODEC_FLAG_EMU_EDGE;
- frame_height >>= enc->lowres;
- frame_width >>= enc->lowres;
+ if (dec->lowres) {
+ dec->flags |= CODEC_FLAG_EMU_EDGE;
+ frame_height >>= dec->lowres;
+ frame_width >>= dec->lowres;
}
if(me_threshold)
- enc->debug |= FF_DEBUG_MV;
+ dec->debug |= FF_DEBUG_MV;
- if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
+ if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
if (verbose >= 0)
fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
- i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
+ i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
(float)rfps / rfps_base, rfps, rfps_base);
}
else if(video_discard)
st->discard= video_discard;
break;
- case CODEC_TYPE_DATA:
+ case AVMEDIA_TYPE_DATA:
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
if(subtitle_disable)
st->discard = AVDISCARD_ALL;
break;
- case CODEC_TYPE_ATTACHMENT:
- case CODEC_TYPE_UNKNOWN:
+ case AVMEDIA_TYPE_ATTACHMENT:
+ case AVMEDIA_TYPE_UNKNOWN:
nb_icodecs++;
break;
default:
for(i=0;i<ic->nb_streams;i++) {
AVCodecContext *enc = ic->streams[i]->codec;
switch(enc->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
has_audio = 1;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
has_video = 1;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
has_subtitle = 1;
break;
- case CODEC_TYPE_DATA:
- case CODEC_TYPE_ATTACHMENT:
- case CODEC_TYPE_UNKNOWN:
+ case AVMEDIA_TYPE_DATA:
+ case AVMEDIA_TYPE_ATTACHMENT:
+ case AVMEDIA_TYPE_UNKNOWN:
break;
default:
abort();
AVCodecContext *video_enc;
enum CodecID codec_id;
- st = av_new_stream(oc, oc->nb_streams);
+ st = av_new_stream(oc, streamid_map[oc->nb_streams]);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
- avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
+ avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
video_bitstream_filters= NULL;
if( (video_global_header&1)
|| (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
+ avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
}
if(video_global_header&2){
video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
- avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
+ avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
}
if (video_stream_copy) {
st->stream_copy = 1;
- video_enc->codec_type = CODEC_TYPE_VIDEO;
+ video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
video_enc->sample_aspect_ratio =
st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
} else {
AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
if (video_codec_name) {
- codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
+ codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
+ video_enc->strict_std_compliance);
codec = avcodec_find_encoder_by_name(video_codec_name);
output_codecs[nb_ocodecs] = codec;
} else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
codec = avcodec_find_encoder(codec_id);
}
video_enc->codec_id = codec_id;
- set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
+ set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
if (codec && codec->supported_framerates && !force_fps)
fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
video_enc->time_base.den = fps.num;
video_enc->time_base.num = fps.den;
- video_enc->width = frame_width + frame_padright + frame_padleft;
- video_enc->height = frame_height + frame_padtop + frame_padbottom;
+ video_enc->width = frame_width;
+ video_enc->height = frame_height;
video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
video_enc->pix_fmt = frame_pix_fmt;
st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
- if(codec && codec->pix_fmts){
- const enum PixelFormat *p= codec->pix_fmts;
- for(; *p!=-1; p++){
- if(*p == video_enc->pix_fmt)
- break;
- }
- if(*p == -1)
- video_enc->pix_fmt = codec->pix_fmts[0];
- }
+ choose_pixel_fmt(st, codec);
if (intra_only)
video_enc->gop_size = 0;
int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
if(e!=3){
fprintf(stderr, "error parsing rc_override\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
video_enc->rc_override=
av_realloc(video_enc->rc_override,
}
nb_ocodecs++;
if (video_language) {
- av_metadata_set(&st->metadata, "language", video_language);
+ av_metadata_set2(&st->metadata, "language", video_language, 0);
av_freep(&video_language);
}
video_disable = 0;
av_freep(&video_codec_name);
video_stream_copy = 0;
+ frame_pix_fmt = PIX_FMT_NONE;
}
static void new_audio_stream(AVFormatContext *oc)
AVCodecContext *audio_enc;
enum CodecID codec_id;
- st = av_new_stream(oc, oc->nb_streams);
+ st = av_new_stream(oc, streamid_map[oc->nb_streams]);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
- avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
+ avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
audio_bitstream_filters= NULL;
avcodec_thread_init(st->codec, thread_count);
audio_enc = st->codec;
- audio_enc->codec_type = CODEC_TYPE_AUDIO;
+ audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
if(audio_codec_tag)
audio_enc->codec_tag= audio_codec_tag;
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
+ avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
}
if (audio_stream_copy) {
st->stream_copy = 1;
audio_enc->channels = audio_channels;
+ audio_enc->sample_rate = audio_sample_rate;
} else {
AVCodec *codec;
- set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
+ set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
if (audio_codec_name) {
- codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
+ codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
+ audio_enc->strict_std_compliance);
codec = avcodec_find_encoder_by_name(audio_codec_name);
output_codecs[nb_ocodecs] = codec;
} else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
codec = avcodec_find_encoder(codec_id);
}
audio_enc->codec_id = codec_id;
}
audio_enc->channels = audio_channels;
audio_enc->sample_fmt = audio_sample_fmt;
+ audio_enc->sample_rate = audio_sample_rate;
audio_enc->channel_layout = channel_layout;
if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
audio_enc->channel_layout = 0;
-
- if(codec && codec->sample_fmts){
- const enum SampleFormat *p= codec->sample_fmts;
- for(; *p!=-1; p++){
- if(*p == audio_enc->sample_fmt)
- break;
- }
- if(*p == -1)
- audio_enc->sample_fmt = codec->sample_fmts[0];
- }
+ choose_sample_fmt(st, codec);
+ choose_sample_rate(st, codec);
}
nb_ocodecs++;
- audio_enc->sample_rate = audio_sample_rate;
audio_enc->time_base= (AVRational){1, audio_sample_rate};
if (audio_language) {
- av_metadata_set(&st->metadata, "language", audio_language);
+ av_metadata_set2(&st->metadata, "language", audio_language, 0);
av_freep(&audio_language);
}
AVStream *st;
AVCodecContext *subtitle_enc;
- st = av_new_stream(oc, oc->nb_streams);
+ st = av_new_stream(oc, streamid_map[oc->nb_streams]);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
- avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
+ avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
subtitle_bitstream_filters= NULL;
subtitle_enc = st->codec;
- subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
+ subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
if(subtitle_codec_tag)
subtitle_enc->codec_tag= subtitle_codec_tag;
if (subtitle_stream_copy) {
st->stream_copy = 1;
} else {
- set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
- subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
+ set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
+ subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
+ subtitle_enc->strict_std_compliance);
output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
}
nb_ocodecs++;
if (subtitle_language) {
- av_metadata_set(&st->metadata, "language", subtitle_language);
+ av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
av_freep(&subtitle_language);
}
subtitle_stream_copy = 0;
}
-static void opt_new_audio_stream(void)
+static void opt_new_stream(const char *opt, const char *arg)
{
AVFormatContext *oc;
if (nb_output_files <= 0) {
fprintf(stderr, "At least one output file must be specified\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
oc = output_files[nb_output_files - 1];
- new_audio_stream(oc);
-}
-static void opt_new_video_stream(void)
-{
- AVFormatContext *oc;
- if (nb_output_files <= 0) {
- fprintf(stderr, "At least one output file must be specified\n");
- av_exit(1);
- }
- oc = output_files[nb_output_files - 1];
- new_video_stream(oc);
+ if (!strcmp(opt, "newvideo" )) new_video_stream (oc);
+ else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc);
+ else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc);
+ else assert(0);
}
-static void opt_new_subtitle_stream(void)
+/* arg format is "output-stream-index:streamid-value". */
+static void opt_streamid(const char *opt, const char *arg)
{
- AVFormatContext *oc;
- if (nb_output_files <= 0) {
- fprintf(stderr, "At least one output file must be specified\n");
- av_exit(1);
+ int idx;
+ char *p;
+ char idx_str[16];
+
+ strncpy(idx_str, arg, sizeof(idx_str));
+ idx_str[sizeof(idx_str)-1] = '\0';
+ p = strchr(idx_str, ':');
+ if (!p) {
+ fprintf(stderr,
+ "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
+ arg, opt);
+ ffmpeg_exit(1);
}
- oc = output_files[nb_output_files - 1];
- new_subtitle_stream(oc);
+ *p++ = '\0';
+ idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
+ streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
}
static void opt_output_file(const char *filename)
{
AVFormatContext *oc;
- int use_video, use_audio, use_subtitle;
+ int err, use_video, use_audio, use_subtitle;
int input_has_video, input_has_audio, input_has_subtitle;
AVFormatParameters params, *ap = ¶ms;
AVOutputFormat *file_oformat;
oc = avformat_alloc_context();
if (!oc) {
print_error(filename, AVERROR(ENOMEM));
- av_exit(1);
+ ffmpeg_exit(1);
}
if (last_asked_format) {
file_oformat = av_guess_format(last_asked_format, NULL, NULL);
if (!file_oformat) {
fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
- av_exit(1);
+ ffmpeg_exit(1);
}
last_asked_format = NULL;
} else {
if (!file_oformat) {
fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
filename);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
int err = read_ffserver_streams(oc, filename);
if (err < 0) {
print_error(filename, err);
- av_exit(1);
+ ffmpeg_exit(1);
}
} else {
use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
new_subtitle_stream(oc);
}
- oc->timestamp = rec_timestamp;
+ oc->timestamp = recording_timestamp;
for(; metadata_count>0; metadata_count--){
- av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
- metadata[metadata_count-1].value);
+ av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
+ metadata[metadata_count-1].value, 0);
}
av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
}
if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
if (!av_filename_number_test(oc->filename)) {
print_error(oc->filename, AVERROR_NUMEXPECTED);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
fflush(stderr);
if (!read_yesno()) {
fprintf(stderr, "Not overwriting - exiting\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
}
else {
fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
}
/* open the file */
- if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
- fprintf(stderr, "Could not open '%s'\n", filename);
- av_exit(1);
+ if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
+ print_error(filename, err);
+ ffmpeg_exit(1);
}
}
if (av_set_parameters(oc, ap) < 0) {
fprintf(stderr, "%s: Invalid encoding parameters\n",
oc->filename);
- av_exit(1);
+ ffmpeg_exit(1);
}
oc->preload= (int)(mux_preload*AV_TIME_BASE);
oc->flags |= AVFMT_FLAG_NONBLOCK;
set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
+
+ memset(streamid_map, 0, sizeof(streamid_map));
}
/* same option as mencoder */
pass = atoi(pass_str);
if (pass != 1 && pass != 2) {
fprintf(stderr, "pass number can be only 1 or 2\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
do_pass = pass;
}
p = strchr(p, ',');
if(!p) {
fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
- av_exit(1);
+ ffmpeg_exit(1);
}
p++;
}
for(j = 0; j < nb_input_files; j++) {
for(i = 0; i < input_files[j]->nb_streams; i++) {
AVCodecContext *c = input_files[j]->streams[i]->codec;
- if(c->codec_type != CODEC_TYPE_VIDEO)
+ if(c->codec_type != AVMEDIA_TYPE_VIDEO)
continue;
fr = c->time_base.den * 1000 / c->time_base.num;
if(fr == 25000) {
fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if(!strcmp(arg, "vcd")) {
} else {
fprintf(stderr, "Unknown target: %s\n", arg);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
if(!bsfc){
fprintf(stderr, "Unknown bitstream filter %s\n", arg);
- av_exit(1);
+ ffmpeg_exit(1);
}
bsfp= *opt == 'v' ? &video_bitstream_filters :
FILE *f=NULL;
char filename[1000], tmp[1000], tmp2[1000], line[1000];
int i;
- const char *base[2]= { getenv("HOME"),
+ const char *base[3]= { getenv("FFMPEG_DATADIR"),
+ getenv("HOME"),
FFMPEG_DATADIR,
};
if (*opt != 'f') {
- for(i=!base[0]; i<2 && !f; i++){
- snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
+ for(i=0; i<3 && !f; i++){
+ if(!base[i])
+ continue;
+ snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
f= fopen(filename, "r");
if(!f){
char *codec_name= *opt == 'v' ? video_codec_name :
*opt == 'a' ? audio_codec_name :
subtitle_codec_name;
- snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
+ snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg);
f= fopen(filename, "r");
}
}
if(!f){
fprintf(stderr, "File for preset '%s' not found\n", arg);
- av_exit(1);
+ ffmpeg_exit(1);
}
while(!feof(f)){
e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
if(e){
fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
- av_exit(1);
+ ffmpeg_exit(1);
}
if(!strcmp(tmp, "acodec")){
opt_audio_codec(tmp2);
opt_subtitle_codec(tmp2);
}else if(opt_default(tmp, tmp2) < 0){
fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
- av_exit(1);
+ ffmpeg_exit(1);
}
}
{ "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
{ "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
{ "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
- { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
+ { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
{ "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
- { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
+ { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
{ "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
"add timings for benchmarking" },
{ "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
/* video options */
{ "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
{ "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
- { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
+ { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
{ "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
{ "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
{ "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
{ "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
- { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
- { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
- { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
- { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
- { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
- { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
- { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
- { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
- { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
+ { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "Deprecated, please use the crop avfilter", "size" },
+ { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "Deprecated, please use the crop avfilter", "size" },
+ { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "Deprecated, please use the crop avfilter", "size" },
+ { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "Deprecated, please use the crop avfilter", "size" },
+ { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
+ { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
+ { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
+ { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
+ { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
{ "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
{ "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
{ "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
{ "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
{ "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" },
+#if CONFIG_AVFILTER
+ { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
+#endif
{ "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
{ "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
{ "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
{ "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
{ "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
- { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
+ { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
{ "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
{ "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
{ "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
+ { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
/* audio options */
{ "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
- { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
+ { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
{ "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
{ "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
{ "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
{ "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
{ "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
{ "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
- { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
+ { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
{ "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
{ "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
/* subtitle options */
{ "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
{ "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
- { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
+ { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
{ "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
{ "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
int64_t ti;
avcodec_register_all();
+#if CONFIG_AVDEVICE
avdevice_register_all();
+#endif
+#if CONFIG_AVFILTER
+ avfilter_register_all();
+#endif
av_register_all();
#if HAVE_ISATTY
url_set_interrupt_cb(decode_interrupt_cb);
#endif
- for(i=0; i<CODEC_TYPE_NB; i++){
+ for(i=0; i<AVMEDIA_TYPE_NB; i++){
avcodec_opts[i]= avcodec_alloc_context2(i);
}
avformat_opts = avformat_alloc_context();
if(nb_output_files <= 0 && nb_input_files == 0) {
show_usage();
fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
/* file converter / grab */
if (nb_output_files <= 0) {
fprintf(stderr, "At least one output file must be specified\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
if (nb_input_files == 0) {
fprintf(stderr, "At least one input file must be specified\n");
- av_exit(1);
+ ffmpeg_exit(1);
}
ti = getutime();
- if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
+ if (transcode(output_files, nb_output_files, input_files, nb_input_files,
stream_maps, nb_stream_maps) < 0)
- av_exit(1);
+ ffmpeg_exit(1);
ti = getutime() - ti;
if (do_benchmark) {
int maxrss = getmaxrss() / 1024;
printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
}
- return av_exit(0);
+ return ffmpeg_exit(0);
}