#include "cmdutils.h"
-#undef NDEBUG
-#include <assert.h>
+#include "libavutil/avassert.h"
const char program_name[] = "FFmpeg";
const int program_birth_year = 2000;
static const OptionDef options[];
#define MAX_FILES 100
+#if !FF_API_MAX_STREAMS
+#define MAX_STREAMS 1024 /* arbitrary sanity check value */
+#endif
static const char *last_asked_format = NULL;
static AVFormatContext *input_files[MAX_FILES];
static int64_t input_files_ts_offset[MAX_FILES];
-static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
-static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
+static double *input_files_ts_scale[MAX_FILES] = {NULL};
+static AVCodec **input_codecs = NULL;
static int nb_input_files = 0;
-static int nb_icodecs;
+static int nb_input_codecs = 0;
+static int nb_input_files_ts_scale[MAX_FILES] = {0};
static AVFormatContext *output_files[MAX_FILES];
-static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
+static AVCodec **output_codecs = NULL;
static int nb_output_files = 0;
-static int nb_ocodecs;
+static int nb_output_codecs = 0;
-static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
+static AVStreamMap *stream_maps = NULL;
static int nb_stream_maps;
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 *streamid_map = NULL;
+static int nb_streamid_map = 0;
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_topBand = 0;
-static int frame_bottomBand = 0;
-static int frame_leftBand = 0;
-static int frame_rightBand = 0;
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
static AVRational frame_rate;
static float video_qscale = 0;
static int64_t recording_timestamp = 0;
static int64_t input_ts_offset = 0;
static int file_overwrite = 0;
-static int metadata_count;
-static AVMetadataTag *metadata;
+static AVMetadata *metadata;
static int do_benchmark = 0;
static int do_hex_dump = 0;
static int do_pkt_dump = 0;
static int input_sync;
static uint64_t limit_filesize = 0;
static int force_fps = 0;
+static char *forced_key_frames = NULL;
static int pgmyuv_compatibility_hack=0;
static float dts_delta_threshold = 10;
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
-static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
//double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
struct AVInputStream *sync_ist; /* input stream to sync against */
int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
+ AVBitStreamFilterContext *bitstream_filters;
/* video only */
int video_resample;
AVFrame pict_tmp; /* temporary image for resampling */
int original_height;
int original_width;
- /* cropping area sizes */
- int video_crop;
- int topBand;
- int bottomBand;
- int leftBand;
- int rightBand;
-
- /* cropping area of first frame */
- int original_topBand;
- int original_bottomBand;
- int original_leftBand;
- int original_rightBand;
+ /* forced key frames */
+ int64_t *forced_kf_pts;
+ int forced_kf_count;
+ int forced_kf_index;
/* audio only */
int audio_resample;
FILE *logfile;
} AVOutputStream;
+static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
+static int nb_output_streams_for_file[MAX_FILES] = { 0 };
+
typedef struct AVInputStream {
int file_index;
int index;
int64_t next_pts; /* synthetic pts for cases where pkt.pts
is not defined */
int64_t pts; /* current pts */
+ PtsCorrectionContext pts_ctx;
int is_start; /* is 1 at the start and after a discontinuity */
int showed_multi_packet_warning;
int is_past_recording_time;
#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)
{
/** filter graph containing all filters including input & output */
AVCodecContext *codec = ost->st->codec;
AVCodecContext *icodec = ist->st->codec;
+ FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
char args[255];
int ret;
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)
+ if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
return ret;
- snprintf(args, 255, "%d:%d:%d", ist->st->codec->width,
- ist->st->codec->height, ist->st->codec->pix_fmt);
+ snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
+ ist->st->codec->height, ist->st->codec->pix_fmt,
+ ist->st->time_base.num, ist->st->time_base.den);
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)
+ if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
return ret;
/* add input and output filters to the overall graph */
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))) {
+ if (codec->width != icodec->width || codec->height != icodec->height) {
snprintf(args, 255, "%d:%d:flags=0x%X",
codec->width,
codec->height,
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)
+ if ((ret = avfilter_graph_config(graph, NULL)) < 0)
return ret;
codec->width = ist->output_video_filter->inputs[0]->w;
for(j=0;j<s->nb_streams;j++) {
av_metadata_free(&s->streams[j]->metadata);
av_free(s->streams[j]->codec);
+ av_free(s->streams[j]->info);
av_free(s->streams[j]);
}
for(j=0;j<s->nb_programs;j++) {
}
av_metadata_free(&s->metadata);
av_free(s);
+ av_free(output_streams_for_file[i]);
}
- for(i=0;i<nb_input_files;i++)
+ for(i=0;i<nb_input_files;i++) {
av_close_input_file(input_files[i]);
+ av_free(input_files_ts_scale[i]);
+ }
av_free(intra_matrix);
av_free(inter_matrix);
av_free(vstats_filename);
av_free(opt_names);
+ av_free(streamid_map);
+ av_free(input_codecs);
+ av_free(output_codecs);
+ av_free(stream_maps);
av_free(video_codec_name);
av_free(audio_codec_name);
av_free(video_standard);
- for (i=0;i<AVMEDIA_TYPE_NB;i++)
- av_free(avcodec_opts[i]);
- av_free(avformat_opts);
- av_free(sws_opts);
+ uninit_opts();
av_free(audio_buf);
av_free(audio_out);
allocated_audio_buf_size= allocated_audio_out_size= 0;
return ret;
}
+/* similar to ff_dynarray_add() and av_fast_realloc() */
+static void *grow_array(void *array, int elem_size, int *size, int new_size)
+{
+ if (new_size >= INT_MAX / elem_size) {
+ fprintf(stderr, "Array too big.\n");
+ ffmpeg_exit(1);
+ }
+ if (*size < new_size) {
+ uint8_t *tmp = av_realloc(array, new_size*elem_size);
+ if (!tmp) {
+ fprintf(stderr, "Could not alloc buffer.\n");
+ ffmpeg_exit(1);
+ }
+ memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
+ *size = new_size;
+ return tmp;
+ }
+ return array;
+}
+
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
{
if(codec && codec->sample_fmts){
}
}else if(audio_sync_method>1){
int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
- assert(ost->audio_resample);
+ av_assert0(ost->audio_resample);
if(verbose > 2)
fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
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 |= AV_PKT_FLAG_KEY;
- write_frame(s, &pkt, enc, bitstream_filters[ost->file_index][pkt.stream_index]);
+ write_frame(s, &pkt, enc, ost->bitstream_filters);
ost->sync_opts += enc->frame_size;
}
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 |= AV_PKT_FLAG_KEY;
- write_frame(s, &pkt, enc, bitstream_filters[ost->file_index][pkt.stream_index]);
+ write_frame(s, &pkt, enc, ost->bitstream_filters);
}
}
else
pkt.pts += 90 * sub->end_display_time;
}
- write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
+ write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
}
}
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;
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)
- 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->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
- || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
+ if ( ost->resample_height != ist->st->codec->height
+ || ost->resample_width != ist->st->codec->width
|| (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
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) {
padding_src = NULL;
final_picture = &ost->pict_tmp;
- if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
- || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
+ if( ost->resample_height != ist->st->codec->height
+ || ost->resample_width != ist->st->codec->width
|| (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
- /* keep bands proportional to the frame size */
- topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
- bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
- leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
- rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
-
- /* sanity check to ensure no bad band sizes sneak in */
- assert(topBand <= INT_MAX && topBand >= 0);
- assert(bottomBand <= INT_MAX && bottomBand >= 0);
- assert(leftBand <= INT_MAX && leftBand >= 0);
- assert(rightBand <= INT_MAX && rightBand >= 0);
-
- ost->topBand = topBand;
- ost->bottomBand = bottomBand;
- ost->leftBand = leftBand;
- ost->rightBand = rightBand;
-
- ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
- ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
- ost->resample_pix_fmt= ist->st->codec->pix_fmt;
-
/* initialize a new scaler context */
sws_freeContext(ost->img_resample_ctx);
sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
ost->img_resample_ctx = sws_getContext(
- ist->st->codec->width - (ost->leftBand + ost->rightBand),
- ist->st->codec->height - (ost->topBand + ost->bottomBand),
+ ist->st->codec->width,
+ ist->st->codec->height,
ist->st->codec->pix_fmt,
ost->st->codec->width,
ost->st->codec->height,
pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
pkt.flags |= AV_PKT_FLAG_KEY;
- write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
+ write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
enc->coded_frame = old_frame;
} else {
AVFrame big_picture;
big_picture.pts= ost->sync_opts;
// big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
+ if (ost->forced_kf_index < ost->forced_kf_count &&
+ big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
+ big_picture.pict_type = FF_I_TYPE;
+ ost->forced_kf_index++;
+ }
ret = avcodec_encode_video(enc,
bit_buffer, bit_buffer_size,
&big_picture);
if(enc->coded_frame->key_frame)
pkt.flags |= AV_PKT_FLAG_KEY;
- write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
+ write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
*frame_size = ret;
video_size += ret;
//fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
void *buffer_to_free;
static unsigned int samples_size= 0;
AVSubtitle subtitle, *subtitle_to_free;
+ int64_t pkt_pts = AV_NOPTS_VALUE;
#if CONFIG_AVFILTER
int frame_available;
#endif
if(pkt->dts != AV_NOPTS_VALUE)
ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
+ if(pkt->pts != AV_NOPTS_VALUE)
+ pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
//while we have more to decode or while the decoder did output something on EOF
while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
/* XXX: allocate picture correctly */
avcodec_get_frame_defaults(&picture);
+ ist->st->codec->reordered_opaque = pkt_pts;
+ pkt_pts = AV_NOPTS_VALUE;
ret = avcodec_decode_video2(ist->st->codec,
&picture, &got_picture, &avpkt);
/* no picture yet */
goto discard_packet;
}
+ ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
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 *
if (start_time == 0 || ist->pts >= start_time)
#if CONFIG_AVFILTER
while (frame_available) {
+ AVRational ist_pts_tb;
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);
+ get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
+ if (ist->picref)
+ ist->pts = ist->picref->pts;
#endif
for(i=0;i<nb_ostreams;i++) {
int frame_size;
//ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
if (ost->encoding_needed) {
- assert(ist->decoding_needed);
+ av_assert0(ist->decoding_needed);
switch(ost->st->codec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
opkt.size = data_size;
}
- write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
+ write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
ost->st->codec->frame_number++;
ost->frame_number++;
av_free_packet(&opkt);
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);
- write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
+ write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
}
}
}
return 0;
}
+static void parse_forced_key_frames(char *kf, AVOutputStream *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");
+ ffmpeg_exit(1);
+ }
+ for (i = 0; i < n; i++) {
+ p = i ? strchr(p, ',') + 1 : kf;
+ 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);
+ }
+}
+
/*
* The following code is the main loop of the file converter
*/
ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
if (!ost_table)
goto fail;
- for(i=0;i<nb_ostreams;i++) {
- ost = av_mallocz(sizeof(AVOutputStream));
- if (!ost)
- goto fail;
- ost_table[i] = ost;
- }
-
n = 0;
for(k=0;k<nb_output_files;k++) {
os = output_files[k];
for(i=0;i<os->nb_streams;i++,n++) {
int found;
- ost = ost_table[n];
- ost->file_index = k;
- ost->index = i;
+ ost = ost_table[n] = output_streams_for_file[k][i];
ost->st = os->streams[i];
if (nb_stream_maps > 0) {
ost->source_index = file_table[stream_maps[n].file_index].ist_index +
}
codec->bit_rate = icodec->bit_rate;
+ codec->rc_max_rate = icodec->rc_max_rate;
+ codec->rc_buffer_size = icodec->rc_buffer_size;
codec->extradata= av_mallocz(extra_size);
if (!codec->extradata)
goto fail;
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_resample = ((codec->width != icodec->width -
- (frame_leftBand + frame_rightBand)) ||
- (codec->height != icodec->height -
- (frame_topBand + frame_bottomBand)) ||
+ ost->video_resample = (codec->width != icodec->width ||
+ codec->height != icodec->height ||
(codec->pix_fmt != icodec->pix_fmt));
- if (ost->video_crop) {
- ost->topBand = ost->original_topBand = frame_topBand;
- ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
- ost->leftBand = ost->original_leftBand = frame_leftBand;
- ost->rightBand = ost->original_rightBand = frame_rightBand;
- }
if (ost->video_resample) {
avcodec_get_frame_defaults(&ost->pict_tmp);
if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
}
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->width,
+ icodec->height,
icodec->pix_fmt,
codec->width,
codec->height,
#endif
codec->bits_per_raw_sample= 0;
}
- ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
- ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
+ ost->resample_height = icodec->height;
+ ost->resample_width = icodec->width;
ost->resample_pix_fmt= icodec->pix_fmt;
ost->encoding_needed = 1;
ist->decoding_needed = 1;
for(i=0;i<nb_ostreams;i++) {
ost = ost_table[i];
if (ost->encoding_needed) {
- AVCodec *codec = output_codecs[i];
+ AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
if (!codec)
codec = avcodec_find_encoder(ost->st->codec->codec_id);
if (!codec) {
for(i=0;i<nb_istreams;i++) {
ist = ist_table[i];
if (ist->decoding_needed) {
- AVCodec *codec = input_codecs[i];
+ AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
if (!codec)
codec = avcodec_find_decoder(ist->st->codec->codec_id);
if (!codec) {
st= ist->st;
ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
ist->next_pts = AV_NOPTS_VALUE;
+ init_pts_correction(&ist->pts_ctx);
ist->is_start = 1;
}
mtag=NULL;
while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
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*/
if (pkt.pts != AV_NOPTS_VALUE)
pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
- if(input_files_ts_scale[file_index][pkt.stream_index]){
+ if (pkt.stream_index < nb_input_files_ts_scale[file_index]
+ && input_files_ts_scale[file_index][pkt.stream_index]){
if(pkt.pts != AV_NOPTS_VALUE)
pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
if(pkt.dts != AV_NOPTS_VALUE)
av_fifo_free(ost->fifo); /* works even if fifo is not
initialized but set to zero */
av_free(ost->pict_tmp.data[0]);
+ av_free(ost->forced_kf_pts);
if (ost->video_resample)
sws_freeContext(ost->img_resample_ctx);
if (ost->resample)
return 0;
}
-static void opt_frame_crop_top(const char *arg)
-{
- frame_topBand = atoi(arg);
- if (frame_topBand < 0) {
- fprintf(stderr, "Incorrect top crop size\n");
- 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");
- ffmpeg_exit(1);
- }
- fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
- frame_height -= frame_topBand;
-}
-
-static void opt_frame_crop_bottom(const char *arg)
+static int opt_frame_crop(const char *opt, const char *arg)
{
- frame_bottomBand = atoi(arg);
- if (frame_bottomBand < 0) {
- fprintf(stderr, "Incorrect bottom crop size\n");
- 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");
- ffmpeg_exit(1);
- }
- fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
- frame_height -= frame_bottomBand;
-}
-
-static void opt_frame_crop_left(const char *arg)
-{
- frame_leftBand = atoi(arg);
- if (frame_leftBand < 0) {
- fprintf(stderr, "Incorrect left crop size\n");
- 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");
- ffmpeg_exit(1);
- }
- fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
- frame_width -= frame_leftBand;
-}
-
-static void opt_frame_crop_right(const char *arg)
-{
- frame_rightBand = atoi(arg);
- if (frame_rightBand < 0) {
- fprintf(stderr, "Incorrect right crop size\n");
- 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");
- ffmpeg_exit(1);
- }
- fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n");
- frame_width -= frame_rightBand;
+ fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
+ return AVERROR(EINVAL);
}
static void opt_frame_size(const char *arg)
}
*mid++= 0;
- metadata_count++;
- metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
- metadata[metadata_count-1].key = av_strdup(arg);
- metadata[metadata_count-1].value= av_strdup(mid);
+ av_metadata_set2(&metadata, arg, mid, 0);
return 0;
}
AVStreamMap *m;
char *p;
- m = &stream_maps[nb_stream_maps++];
+ stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
+ m = &stream_maps[nb_stream_maps-1];
m->file_index = strtol(arg, &p, 0);
if (*p)
if(stream >= MAX_STREAMS)
ffmpeg_exit(1);
+ input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
input_files_ts_scale[nb_input_files][stream]= scale;
}
ap->channel = video_channel;
ap->standard = video_standard;
- set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
+ set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
ic->video_codec_id =
find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
AVStream *st = ic->streams[i];
AVCodecContext *dec = st->codec;
avcodec_thread_init(dec, thread_count);
+ input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
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);
+ input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
+ set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
//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;
/* Note that av_find_stream_info can add more streams, and we
audio_sample_rate >>= dec->lowres;
break;
case AVMEDIA_TYPE_VIDEO:
- set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
+ input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
+ set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
frame_height = dec->height;
frame_width = dec->width;
if(ic->streams[i]->sample_aspect_ratio.num)
frame_rate.num = rfps;
frame_rate.den = rfps_base;
- input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
if(video_disable)
st->discard= AVDISCARD_ALL;
else if(video_discard)
case AVMEDIA_TYPE_DATA:
break;
case AVMEDIA_TYPE_SUBTITLE:
- input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
+ input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
if(subtitle_disable)
st->discard = AVDISCARD_ALL;
break;
case AVMEDIA_TYPE_ATTACHMENT:
case AVMEDIA_TYPE_UNKNOWN:
- nb_icodecs++;
break;
default:
abort();
*has_subtitle_ptr = has_subtitle;
}
-static void new_video_stream(AVFormatContext *oc)
+static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
+{
+ int idx = oc->nb_streams - 1;
+ AVOutputStream *ost;
+
+ output_streams_for_file[file_idx] =
+ grow_array(output_streams_for_file[file_idx],
+ sizeof(*output_streams_for_file[file_idx]),
+ &nb_output_streams_for_file[file_idx],
+ oc->nb_streams);
+ ost = output_streams_for_file[file_idx][idx] =
+ av_mallocz(sizeof(AVOutputStream));
+ if (!ost) {
+ fprintf(stderr, "Could not alloc output stream\n");
+ ffmpeg_exit(1);
+ }
+ ost->file_index = file_idx;
+ ost->index = idx;
+ return ost;
+}
+
+static void new_video_stream(AVFormatContext *oc, int file_idx)
{
AVStream *st;
+ AVOutputStream *ost;
AVCodecContext *video_enc;
enum CodecID codec_id;
+ AVCodec *codec= NULL;
- st = av_new_stream(oc, streamid_map[oc->nb_streams]);
+ st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
ffmpeg_exit(1);
}
- avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
- bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
+ ost = new_output_stream(oc, file_idx);
+
+ output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
+ if(!video_stream_copy){
+ if (video_codec_name) {
+ codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
+ avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
+ codec = avcodec_find_encoder_by_name(video_codec_name);
+ output_codecs[nb_output_codecs-1] = codec;
+ } else {
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
+ codec = avcodec_find_encoder(codec_id);
+ }
+ }
+
+ avcodec_get_context_defaults3(st->codec, codec);
+ ost->bitstream_filters = video_bitstream_filters;
video_bitstream_filters= NULL;
avcodec_thread_init(st->codec, thread_count);
} else {
const char *p;
int i;
- AVCodec *codec;
AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
- if (video_codec_name) {
- 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, AVMEDIA_TYPE_VIDEO);
- codec = avcodec_find_encoder(codec_id);
- }
-
video_enc->codec_id = codec_id;
-
- set_context_opts(video_enc, avcodec_opts[AVMEDIA_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, codec);
if (codec && codec->supported_framerates && !force_fps)
fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
video_enc->flags |= CODEC_FLAG_PASS2;
}
}
+
+ if (forced_key_frames)
+ parse_forced_key_frames(forced_key_frames, ost, video_enc);
}
- nb_ocodecs++;
if (video_language) {
av_metadata_set2(&st->metadata, "language", video_language, 0);
av_freep(&video_language);
/* reset some key parameters */
video_disable = 0;
av_freep(&video_codec_name);
+ av_freep(&forced_key_frames);
video_stream_copy = 0;
frame_pix_fmt = PIX_FMT_NONE;
}
-static void new_audio_stream(AVFormatContext *oc)
+static void new_audio_stream(AVFormatContext *oc, int file_idx)
{
AVStream *st;
+ AVOutputStream *ost;
+ AVCodec *codec= NULL;
AVCodecContext *audio_enc;
enum CodecID codec_id;
- st = av_new_stream(oc, streamid_map[oc->nb_streams]);
+ st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
ffmpeg_exit(1);
}
- avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
+ ost = new_output_stream(oc, file_idx);
+
+ output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
+ if(!audio_stream_copy){
+ if (audio_codec_name) {
+ codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
+ avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
+ codec = avcodec_find_encoder_by_name(audio_codec_name);
+ output_codecs[nb_output_codecs-1] = codec;
+ } else {
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
+ codec = avcodec_find_encoder(codec_id);
+ }
+ }
- bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
+ avcodec_get_context_defaults3(st->codec, codec);
+
+ ost->bitstream_filters = audio_bitstream_filters;
audio_bitstream_filters= NULL;
avcodec_thread_init(st->codec, thread_count);
audio_enc->channels = audio_channels;
audio_enc->sample_rate = audio_sample_rate;
} else {
- AVCodec *codec;
-
- 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, 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, AVMEDIA_TYPE_AUDIO);
- codec = avcodec_find_encoder(codec_id);
- }
audio_enc->codec_id = codec_id;
+ set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
if (audio_qscale > QSCALE_NONE) {
audio_enc->flags |= CODEC_FLAG_QSCALE;
choose_sample_fmt(st, codec);
choose_sample_rate(st, codec);
}
- nb_ocodecs++;
audio_enc->time_base= (AVRational){1, audio_sample_rate};
if (audio_language) {
av_metadata_set2(&st->metadata, "language", audio_language, 0);
audio_stream_copy = 0;
}
-static void new_subtitle_stream(AVFormatContext *oc)
+static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
{
AVStream *st;
+ AVOutputStream *ost;
+ AVCodec *codec=NULL;
AVCodecContext *subtitle_enc;
- st = av_new_stream(oc, streamid_map[oc->nb_streams]);
+ st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
if (!st) {
fprintf(stderr, "Could not alloc stream\n");
ffmpeg_exit(1);
}
- avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
+ ost = new_output_stream(oc, file_idx);
+ subtitle_enc = st->codec;
+ output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
+ if(!subtitle_stream_copy){
+ subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
+ avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
+ codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
+ }
+ avcodec_get_context_defaults3(st->codec, codec);
- bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
+ ost->bitstream_filters = subtitle_bitstream_filters;
subtitle_bitstream_filters= NULL;
- subtitle_enc = st->codec;
subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
if(subtitle_codec_tag)
if (subtitle_stream_copy) {
st->stream_copy = 1;
} else {
- 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);
+ set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
}
- nb_ocodecs++;
if (subtitle_language) {
av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
subtitle_stream_copy = 0;
}
-static void opt_new_stream(const char *opt, const char *arg)
+static int opt_new_stream(const char *opt, const char *arg)
{
AVFormatContext *oc;
+ int file_idx = nb_output_files - 1;
if (nb_output_files <= 0) {
fprintf(stderr, "At least one output file must be specified\n");
ffmpeg_exit(1);
}
- oc = output_files[nb_output_files - 1];
+ oc = output_files[file_idx];
- 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);
+ if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
+ else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
+ else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
+ else av_assert0(0);
+ return 0;
}
/* arg format is "output-stream-index:streamid-value". */
-static void opt_streamid(const char *opt, const char *arg)
+static int opt_streamid(const char *opt, const char *arg)
{
int idx;
char *p;
}
*p++ = '\0';
idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
+ streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
+ return 0;
}
static void opt_output_file(const char *filename)
int input_has_video, input_has_audio, input_has_subtitle;
AVFormatParameters params, *ap = ¶ms;
AVOutputFormat *file_oformat;
+ AVMetadataTag *tag = NULL;
if (!strcmp(filename, "-"))
filename = "pipe:";
}
/* manual disable */
- if (audio_disable) {
- use_audio = 0;
- }
- if (video_disable) {
- use_video = 0;
- }
- if (subtitle_disable) {
- use_subtitle = 0;
- }
+ if (audio_disable) use_audio = 0;
+ if (video_disable) use_video = 0;
+ if (subtitle_disable) use_subtitle = 0;
- if (use_video) {
- new_video_stream(oc);
- }
-
- if (use_audio) {
- new_audio_stream(oc);
- }
-
- if (use_subtitle) {
- new_subtitle_stream(oc);
- }
+ if (use_video) new_video_stream(oc, nb_output_files);
+ if (use_audio) new_audio_stream(oc, nb_output_files);
+ if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
oc->timestamp = recording_timestamp;
- for(; metadata_count>0; metadata_count--){
- 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);
+ while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
+ av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
+ av_metadata_free(&metadata);
}
output_files[nb_output_files++] = oc;
oc->loop_output = loop_output;
oc->flags |= AVFMT_FLAG_NONBLOCK;
- set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
+ set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
- memset(streamid_map, 0, sizeof(streamid_map));
+ nb_streamid_map = 0;
+ av_freep(&forced_key_frames);
}
/* same option as mencoder */
{ "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}, "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" },
+ { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
+ { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
+ { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
+ { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "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" },
{ "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" },
+ { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
/* audio options */
{ "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
int main(int argc, char **argv)
{
- int i;
int64_t ti;
av_log_set_flags(AV_LOG_SKIP_REPEATED);
url_set_interrupt_cb(decode_interrupt_cb);
#endif
- for(i=0; i<AVMEDIA_TYPE_NB; i++){
- avcodec_opts[i]= avcodec_alloc_context2(i);
- }
- avformat_opts = avformat_alloc_context();
- sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
+ init_opts();
show_banner();
projects / ffmpeg / blobdiff