/* select an input stream for an output stream */
typedef struct StreamMap {
+ int disabled; /** 1 is this mapping is disabled by a negative map */
int file_index;
int stream_index;
int sync_file_index;
static StreamMap *stream_maps = NULL;
static int nb_stream_maps;
+static AVDictionary *codec_names;
+
/* first item specifies output metadata, second is input */
static MetadataMap (*meta_data_maps)[2] = NULL;
static int nb_meta_data_maps;
static const char *video_rc_override_string=NULL;
static int video_disable = 0;
static int video_discard = 0;
-static char *video_codec_name = NULL;
static unsigned int video_codec_tag = 0;
static char *video_language = NULL;
-static int same_quality = 0;
+static int same_quant = 0;
static int do_deinterlace = 0;
static int top_field_first = -1;
static int me_threshold = 0;
static int intra_dc_precision = 8;
-static int loop_input = 0;
-static int loop_output = AVFMT_NOOUTPUTLOOP;
static int qp_hist = 0;
#if CONFIG_AVFILTER
static char *vfilters = NULL;
static float audio_qscale = QSCALE_NONE;
static int audio_disable = 0;
static int audio_channels = 0;
-static char *audio_codec_name = NULL;
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 unsigned int subtitle_codec_tag = 0;
static int data_disable = 0;
-static char *data_codec_name = NULL;
static unsigned int data_codec_tag = 0;
static float mux_preload= 0.5;
static int do_psnr = 0;
static int do_pass = 0;
static char *pass_logfilename_prefix = NULL;
-static int audio_stream_copy = 0;
-static int video_stream_copy = 0;
-static int subtitle_stream_copy = 0;
-static int data_stream_copy = 0;
static int video_sync_method= -1;
static int audio_sync_method= 0;
static float audio_drift_threshold= 0.1;
av_free(vstats_filename);
av_free(streamid_map);
- av_free(stream_maps);
av_free(meta_data_maps);
av_freep(&input_streams);
av_freep(&input_files);
- av_free(video_codec_name);
- av_free(audio_codec_name);
- av_free(subtitle_codec_name);
- av_free(data_codec_name);
-
uninit_opts();
av_free(audio_buf);
av_free(audio_out);
}
}
-static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
-{
- OutputStream *ost;
- AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
- int idx = oc->nb_streams - 1;
-
- if (!st) {
- av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
- exit_program(1);
- }
-
- 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(OutputStream));
- if (!ost) {
- fprintf(stderr, "Could not alloc output stream\n");
- exit_program(1);
- }
- ost->file_index = file_idx;
- ost->index = idx;
- ost->st = st;
- ost->enc = codec;
- if (codec)
- ost->opts = filter_codec_opts(codec_opts, codec->id, 1);
-
- avcodec_get_context_defaults3(st->codec, codec);
-
- ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
- return ost;
-}
-
-static int read_avserver_streams(AVFormatContext *s, const char *filename)
-{
- int i, err;
- AVFormatContext *ic = NULL;
- int nopts = 0;
-
- err = avformat_open_input(&ic, filename, NULL, NULL);
- if (err < 0)
- return err;
- /* copy stream format */
- for(i=0;i<ic->nb_streams;i++) {
- AVStream *st;
- OutputStream *ost;
- AVCodec *codec;
-
- codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
- ost = new_output_stream(s, nb_output_files, codec);
- st = ost->st;
-
- // FIXME: a more elegant solution is needed
- memcpy(st, ic->streams[i], sizeof(AVStream));
- st->info = NULL;
- avcodec_copy_context(st->codec, ic->streams[i]->codec);
-
- 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->flags & CODEC_FLAG_BITEXACT)
- nopts = 1;
- }
-
- av_close_input_file(ic);
- return 0;
-}
-
static double
get_sync_ipts(const OutputStream *ost)
{
static int bit_buffer_size= 1024*256;
static uint8_t *bit_buffer= NULL;
+static void do_video_resample(OutputStream *ost,
+ InputStream *ist,
+ AVFrame *in_picture,
+ AVFrame **out_picture)
+{
+ int resample_changed = 0;
+ AVCodecContext *dec = ist->st->codec;
+ *out_picture = in_picture;
+
+ resample_changed = ost->resample_width != dec->width ||
+ ost->resample_height != dec->height ||
+ ost->resample_pix_fmt != dec->pix_fmt;
+
+ if (resample_changed) {
+ av_log(NULL, AV_LOG_INFO,
+ "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
+ ist->file_index, ist->st->index,
+ ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
+ dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
+ if(!ost->video_resample)
+ ost->video_resample = 1;
+ }
+
+#if !CONFIG_AVFILTER
+ if (ost->video_resample) {
+ *out_picture = &ost->pict_tmp;
+ if (resample_changed) {
+ /* initialize a new scaler context */
+ sws_freeContext(ost->img_resample_ctx);
+ ost->img_resample_ctx = sws_getContext(
+ ist->st->codec->width,
+ ist->st->codec->height,
+ ist->st->codec->pix_fmt,
+ ost->st->codec->width,
+ ost->st->codec->height,
+ ost->st->codec->pix_fmt,
+ ost->sws_flags, NULL, NULL, NULL);
+ if (ost->img_resample_ctx == NULL) {
+ fprintf(stderr, "Cannot get resampling context\n");
+ exit_program(1);
+ }
+ }
+ sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
+ 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
+ }
+#else
+ if (resample_changed) {
+ avfilter_graph_free(&ost->graph);
+ if (configure_video_filters(ist, ost)) {
+ fprintf(stderr, "Error reinitialising filters!\n");
+ exit_program(1);
+ }
+ }
+#endif
+ if (resample_changed) {
+ ost->resample_width = dec->width;
+ ost->resample_height = dec->height;
+ ost->resample_pix_fmt = dec->pix_fmt;
+ }
+}
+
+
static void do_video_out(AVFormatContext *s,
OutputStream *ost,
InputStream *ist,
AVFrame *in_picture,
int *frame_size, float quality)
{
- int nb_frames, i, ret, resample_changed;
- AVFrame *final_picture, *formatted_picture;
+ int nb_frames, i, ret;
+ AVFrame *final_picture;
AVCodecContext *enc, *dec;
double sync_ipts;
if (nb_frames <= 0)
return;
- formatted_picture = in_picture;
- final_picture = formatted_picture;
-
- resample_changed = ost->resample_width != dec->width ||
- ost->resample_height != dec->height ||
- ost->resample_pix_fmt != dec->pix_fmt;
-
- if (resample_changed) {
- av_log(NULL, AV_LOG_INFO,
- "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
- ist->file_index, ist->st->index,
- ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
- dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
- if(!ost->video_resample)
- exit_program(1);
- }
-
-#if !CONFIG_AVFILTER
- if (ost->video_resample) {
- final_picture = &ost->pict_tmp;
- if (resample_changed) {
- /* initialize a new scaler context */
- sws_freeContext(ost->img_resample_ctx);
- ost->img_resample_ctx = sws_getContext(
- ist->st->codec->width,
- ist->st->codec->height,
- ist->st->codec->pix_fmt,
- ost->st->codec->width,
- ost->st->codec->height,
- ost->st->codec->pix_fmt,
- ost->sws_flags, NULL, NULL, NULL);
- if (ost->img_resample_ctx == NULL) {
- fprintf(stderr, "Cannot get resampling context\n");
- exit_program(1);
- }
- }
- sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
- 0, ost->resample_height, final_picture->data, final_picture->linesize);
- }
-#endif
+ do_video_resample(ost, ist, in_picture, &final_picture);
/* duplicates frame if needed */
for(i=0;i<nb_frames;i++) {
big_picture.top_field_first = top_field_first;
}
- /* handles sameq here. This is not correct because it may
+ /* handles same_quant here. This is not correct because it may
not be a global option */
big_picture.quality = quality;
if(!me_threshold)
ret = avcodec_decode_video2(ist->st->codec,
&picture, &got_output, &avpkt);
- quality = same_quality ? picture.quality : 0;
+ quality = same_quant ? picture.quality : 0;
if (ret < 0)
return ret;
if (!got_output) {
ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
#endif
do_video_out(os, ost, ist, &picture, &frame_size,
- same_quality ? quality : ost->st->codec->global_quality);
+ same_quant ? quality : ost->st->codec->global_quality);
if (vstats_filename && frame_size)
do_video_stats(os, ost, frame_size);
break;
fflush(stdout);
}
-static int copy_chapters(int infile, int outfile)
-{
- AVFormatContext *is = input_files[infile].ctx;
- AVFormatContext *os = output_files[outfile];
- int i;
-
- for (i = 0; i < is->nb_chapters; i++) {
- AVChapter *in_ch = is->chapters[i], *out_ch;
- int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
- 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);
-
- if (metadata_chapters_autocopy)
- av_dict_copy(&out_ch->metadata, in_ch->metadata, 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;
-}
-
-static void parse_forced_key_frames(char *kf, OutputStream *ost,
- AVCodecContext *avctx)
-{
- char *p;
- int n = 1, i;
- int64_t t;
-
- for (p = kf; *p; p++)
- if (*p == ',')
- n++;
- ost->forced_kf_count = n;
- ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
- if (!ost->forced_kf_pts) {
- av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
- exit_program(1);
- }
- 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
*/
static int transcode(AVFormatContext **output_files,
int nb_output_files,
InputFile *input_files,
- int nb_input_files,
- StreamMap *stream_maps, int nb_stream_maps)
+ int nb_input_files)
{
int ret = 0, i, j, k, n, nb_ostreams = 0;
AVFormatContext *is, *os;
}
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");
- ret = AVERROR(EINVAL);
- goto fail;
- }
-
- /* Sanity check the mapping args -- do the input files & streams exist? */
- for(i=0;i<nb_stream_maps;i++) {
- int fi = stream_maps[i].file_index;
- int si = stream_maps[i].stream_index;
-
- if (fi < 0 || fi > nb_input_files - 1 ||
- si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
- fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
- 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 > input_files[fi].ctx->nb_streams - 1) {
- fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
- ret = AVERROR(EINVAL);
- goto fail;
- }
- }
ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
if (!ost_table)
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] = output_streams_for_file[k][i];
- if (nb_stream_maps > 0) {
- ost->source_index = input_files[stream_maps[n].file_index].ist_index +
- stream_maps[n].stream_index;
-
- /* Sanity check that the stream types match */
- if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
- int i= ost->file_index;
- av_dump_format(output_files[i], i, output_files[i]->filename, 1);
- 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);
- exit_program(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_input_streams; j++) {
- int skip=0;
- ist = &input_streams[j];
- if(opt_programid){
- int pi,si;
- AVFormatContext *f = input_files[ist->file_index].ctx;
- 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 (!found) {
- if(! opt_programid) {
- /* try again and reuse existing stream */
- for (j = 0; j < nb_input_streams; j++) {
- ist = &input_streams[j];
- if ( ist->st->codec->codec_type == ost->st->codec->codec_type
- && ist->st->discard != AVDISCARD_ALL) {
- ost->source_index = j;
- found = 1;
- }
- }
- }
- if (!found) {
- int i= ost->file_index;
- av_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);
- exit_program(1);
- }
- }
- }
- ist = &input_streams[ost->source_index];
- ist->discard = 0;
- ost->sync_ist = (nb_stream_maps > 0) ?
- &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
- stream_maps[n].sync_stream_index] : ist;
- }
+ for (i = 0; i < os->nb_streams; i++, n++)
+ ost_table[n] = output_streams_for_file[k][i];
}
/* for each output stream, we compute the right encoding parameters */
codec = ost->st->codec;
icodec = ist->st->codec;
- if (metadata_streams_autocopy)
- av_dict_copy(&ost->st->metadata, ist->st->metadata,
- AV_DICT_DONT_OVERWRITE);
-
ost->st->disposition = ist->st->disposition;
codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
codec->chroma_sample_location = icodec->chroma_sample_location;
}
assert_codec_experimental(ist->st->codec, 0);
assert_avoptions(ost->opts);
- //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
- // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
}
}
ist->is_start = 1;
}
- /* set meta data information from input file if required */
- for (i=0;i<nb_meta_data_maps;i++) {
- AVFormatContext *files[2];
- AVDictionary **meta[2];
- int j;
-
-#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
- if ((index) < 0 || (index) >= (nb_elems)) {\
- snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
- (desc), (index));\
- ret = AVERROR(EINVAL);\
- goto dump_format;\
+ /* open files and write file headers */
+ for(i=0;i<nb_output_files;i++) {
+ os = output_files[i];
+ if (avformat_write_header(os, &output_opts[i]) < 0) {
+ snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
+ ret = AVERROR(EINVAL);
+ goto dump_format;
+ }
+ assert_avoptions(output_opts[i]);
+ if (strcmp(output_files[i]->oformat->name, "rtp")) {
+ want_sdp = 0;
}
-
- int out_file_index = meta_data_maps[i][0].file;
- int in_file_index = meta_data_maps[i][1].file;
- if (in_file_index < 0 || out_file_index < 0)
- continue;
- METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
- METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
-
- files[0] = output_files[out_file_index];
- files[1] = input_files[in_file_index].ctx;
-
- for (j = 0; j < 2; j++) {
- MetadataMap *map = &meta_data_maps[i][j];
-
- switch (map->type) {
- case 'g':
- meta[j] = &files[j]->metadata;
- break;
- case 's':
- METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
- meta[j] = &files[j]->streams[map->index]->metadata;
- break;
- case 'c':
- METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
- meta[j] = &files[j]->chapters[map->index]->metadata;
- break;
- case 'p':
- METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
- meta[j] = &files[j]->programs[map->index]->metadata;
- break;
- }
- }
-
- av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
- }
-
- /* copy global metadata by default */
- if (metadata_global_autocopy) {
-
- for (i = 0; i < nb_output_files; i++)
- av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
- AV_DICT_DONT_OVERWRITE);
- }
-
- /* open files and write file headers */
- for(i=0;i<nb_output_files;i++) {
- os = output_files[i];
- if (avformat_write_header(os, &output_opts[i]) < 0) {
- snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
- ret = AVERROR(EINVAL);
- goto dump_format;
- }
- assert_avoptions(output_opts[i]);
- if (strcmp(output_files[i]->oformat->name, "rtp")) {
- want_sdp = 0;
- }
- }
+ }
dump_format:
/* dump the file output parameters - cannot be done before in case
fprintf(stderr, " [sync #%d.%d]",
ost->sync_ist->file_index,
ost->sync_ist->st->index);
+ if (ost->st->stream_copy)
+ fprintf(stderr, " (copy)");
fprintf(stderr, "\n");
}
}
for(; received_sigterm == 0;) {
int file_index, ist_index;
AVPacket pkt;
- double ipts_min;
+ int64_t ipts_min;
double opts_min;
redo:
- ipts_min= 1e100;
+ ipts_min = INT64_MAX;
opts_min= 1e100;
/* select the stream that we must read now by looking at the
smallest output pts */
file_index = -1;
for(i=0;i<nb_ostreams;i++) {
- double ipts, opts;
+ int64_t ipts;
+ double opts;
ost = ost_table[i];
os = output_files[ost->file_index];
ist = &input_streams[ost->source_index];
if(ist->is_past_recording_time || no_packet[ist->file_index])
continue;
opts = ost->st->pts.val * av_q2d(ost->st->time_base);
- ipts = (double)ist->pts;
+ ipts = ist->pts;
if (!input_files[ist->file_index].eof_reached){
if(ipts < ipts_min) {
ipts_min = ipts;
return 0;
}
-static int opt_video_channel(const char *opt, const char *arg)
-{
- av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
- opt_default("channel", arg);
- return 0;
-}
-
-static int opt_video_standard(const char *opt, const char *arg)
-{
- av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
- opt_default("standard", arg);
- return 0;
-}
-
-static int opt_codec(int *pstream_copy, char **pcodec_name,
- int codec_type, const char *arg)
+static int opt_codec(const char *opt, const char *arg)
{
- av_freep(pcodec_name);
- if (!strcmp(arg, "copy")) {
- *pstream_copy = 1;
- } else {
- *pcodec_name = av_strdup(arg);
- }
- return 0;
+ return av_dict_set(&codec_names, opt, arg, 0);
}
static int opt_audio_codec(const char *opt, const char *arg)
{
- return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
+ return opt_codec("codec:a", arg);
}
static int opt_video_codec(const char *opt, const char *arg)
{
- return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
+ return opt_codec("codec:v", arg);
}
static int opt_subtitle_codec(const char *opt, const char *arg)
{
- return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
+ return opt_codec("codec:s", arg);
}
static int opt_data_codec(const char *opt, const char *arg)
{
- return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
+ return opt_codec("codec:d", arg);
}
static int opt_codec_tag(const char *opt, const char *arg)
static int opt_map(const char *opt, const char *arg)
{
- StreamMap *m;
- char *p;
+ StreamMap *m = NULL;
+ int i, negative = 0, file_idx;
+ int sync_file_idx = -1, sync_stream_idx;
+ char *p, *sync;
+ char *map;
+
+ if (*arg == '-') {
+ negative = 1;
+ arg++;
+ }
+ map = av_strdup(arg);
+
+ /* parse sync stream first, just pick first matching stream */
+ if (sync = strchr(map, ',')) {
+ *sync = 0;
+ sync_file_idx = strtol(sync + 1, &sync, 0);
+ if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
+ av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
+ exit_program(1);
+ }
+ if (*sync)
+ sync++;
+ for (i = 0; i < input_files[sync_file_idx].ctx->nb_streams; i++)
+ if (check_stream_specifier(input_files[sync_file_idx].ctx,
+ input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
+ sync_stream_idx = i;
+ break;
+ }
+ if (i == input_files[sync_file_idx].ctx->nb_streams) {
+ av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
+ "match any streams.\n", arg);
+ exit_program(1);
+ }
+ }
- 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)
- p++;
+ file_idx = strtol(map, &p, 0);
+ if (file_idx >= nb_input_files || file_idx < 0) {
+ av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
+ exit_program(1);
+ }
+ if (negative)
+ /* disable some already defined maps */
+ for (i = 0; i < nb_stream_maps; i++) {
+ m = &stream_maps[i];
+ if (check_stream_specifier(input_files[m->file_index].ctx,
+ input_files[m->file_index].ctx->streams[m->stream_index],
+ *p == ':' ? p + 1 : p) > 0)
+ m->disabled = 1;
+ }
+ else
+ for (i = 0; i < input_files[file_idx].ctx->nb_streams; i++) {
+ if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
+ *p == ':' ? p + 1 : p) <= 0)
+ continue;
+ stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
+ m = &stream_maps[nb_stream_maps - 1];
- m->stream_index = strtol(p, &p, 0);
- if (*p) {
- p++;
- m->sync_file_index = strtol(p, &p, 0);
- if (*p)
- p++;
- m->sync_stream_index = strtol(p, &p, 0);
- } else {
- m->sync_file_index = m->file_index;
- m->sync_stream_index = m->stream_index;
+ m->file_index = file_idx;
+ m->stream_index = i;
+
+ if (sync_file_idx >= 0) {
+ m->sync_file_index = sync_file_idx;
+ m->sync_stream_index = sync_stream_idx;
+ } else {
+ m->sync_file_index = file_idx;
+ m->sync_stream_index = i;
+ }
+ }
+
+ if (!m) {
+ av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
+ exit_program(1);
}
+
+ av_freep(&map);
return 0;
}
-static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
+static void parse_meta_type(char *arg, char *type, int *index)
{
- *endptr = arg;
- if (*arg == ',') {
+ if (*arg == ':') {
*type = *(++arg);
switch (*arg) {
case 'g':
case 's':
case 'c':
case 'p':
- *index = strtol(++arg, endptr, 0);
+ if (*(++arg) == ':')
+ *index = strtol(++arg, NULL, 0);
break;
default:
fprintf(stderr, "Invalid metadata type %c.\n", *arg);
meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
&nb_meta_data_maps, nb_meta_data_maps + 1);
- m = &meta_data_maps[nb_meta_data_maps - 1][0];
+ m = &meta_data_maps[nb_meta_data_maps - 1][1];
m->file = strtol(arg, &p, 0);
- parse_meta_type(p, &m->type, &m->index, &p);
- if (*p)
- p++;
+ parse_meta_type(p, &m->type, &m->index);
- m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
- m1->file = strtol(p, &p, 0);
- parse_meta_type(p, &m1->type, &m1->index, &p);
+ m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
+ if (p = strchr(opt, ':'))
+ parse_meta_type(p, &m1->type, &m1->index);
+ else
+ m1->type = 'g';
if (m->type == 'g' || m1->type == 'g')
metadata_global_autocopy = 0;
return 0;
}
-static int opt_map_meta_data(const char *opt, const char *arg)
-{
- fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
- "Use -map_metadata instead.\n");
- return opt_map_metadata(opt, arg);
-}
-
static int opt_input_ts_scale(const char *opt, const char *arg)
{
unsigned int stream;
return 0;
}
-static int opt_recording_timestamp(const char *opt, const char *arg)
-{
- char buf[128];
- int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
- struct tm time = *gmtime((time_t*)&recording_timestamp);
- strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
- opt_metadata("metadata", buf);
-
- av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
- "tag instead.\n", opt);
- return 0;
-}
-
static int opt_input_ts_offset(const char *opt, const char *arg)
{
input_ts_offset = parse_time_or_die(opt, arg, 1);
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, enum AVMediaType type, int encoder)
{
const char *codec_string = encoder ? "encoder" : "decoder";
AVCodec *codec;
avcodec_find_encoder_by_name(name) :
avcodec_find_decoder_by_name(name);
if(!codec) {
- fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
+ av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
exit_program(1);
}
if(codec->type != type) {
- fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
+ av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
exit_program(1);
}
return codec->id;
}
+static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
+{
+ AVDictionaryEntry *e = NULL;
+ char *codec_name = NULL;
+ int ret;
+
+ while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
+ char *p = strchr(e->key, ':');
+
+ if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
+ codec_name = e->value;
+ else if (ret < 0)
+ exit_program(1);
+ }
+
+ if (!codec_name) {
+ if (s->oformat) {
+ st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
+ return avcodec_find_encoder(st->codec->codec_id);
+ }
+ } else if (!strcmp(codec_name, "copy"))
+ st->stream_copy = 1;
+ else {
+ st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
+ return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
+ avcodec_find_decoder_by_name(codec_name);
+ }
+
+ return NULL;
+}
+
static int opt_input_file(const char *opt, const char *filename)
{
AVFormatContext *ic;
if (frame_pix_fmt != PIX_FMT_NONE)
av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
- ic->video_codec_id =
- find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
- ic->audio_codec_id =
- find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
- ic->subtitle_codec_id=
- find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
ic->flags |= AVFMT_FLAG_NONBLOCK;
/* open the input file with generic libav function */
opt_programid=0;
}
- if (loop_input) {
- av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
- ic->loop_input = loop_input;
- }
+ /* apply forced codec ids */
+ for (i = 0; i < ic->nb_streams; i++)
+ choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
/* Set AVCodecContext options for avformat_find_stream_info */
opts = setup_find_stream_info_opts(ic, codec_opts);
ist->st = st;
ist->file_index = nb_input_files;
ist->discard = 1;
- ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, 0);
+ ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
if (i < nb_ts_scale)
ist->ts_scale = ts_scale[i];
+ ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
+
switch (dec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
- ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
if(audio_disable)
st->discard= AVDISCARD_ALL;
break;
case AVMEDIA_TYPE_VIDEO:
- ist->dec = avcodec_find_decoder_by_name(video_codec_name);
rfps = ic->streams[i]->r_frame_rate.num;
rfps_base = ic->streams[i]->r_frame_rate.den;
if (dec->lowres) {
case AVMEDIA_TYPE_DATA:
break;
case AVMEDIA_TYPE_SUBTITLE:
- ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
if(subtitle_disable)
st->discard = AVDISCARD_ALL;
break;
for (i = 0; i < orig_nb_streams; i++)
av_dict_free(&opts[i]);
av_freep(&opts);
- av_freep(&video_codec_name);
- av_freep(&audio_codec_name);
- av_freep(&subtitle_codec_name);
+ av_dict_free(&codec_names);
uninit_opts();
init_opts();
return 0;
}
-static void check_inputs(int *has_video_ptr,
- int *has_audio_ptr,
- int *has_subtitle_ptr,
- int *has_data_ptr)
+static void parse_forced_key_frames(char *kf, OutputStream *ost,
+ AVCodecContext *avctx)
{
- int has_video, has_audio, has_subtitle, has_data, i, j;
- AVFormatContext *ic;
+ char *p;
+ int n = 1, i;
+ int64_t t;
- has_video = 0;
- has_audio = 0;
- has_subtitle = 0;
- has_data = 0;
+ for (p = kf; *p; p++)
+ if (*p == ',')
+ n++;
+ ost->forced_kf_count = n;
+ ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
+ if (!ost->forced_kf_pts) {
+ av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
+ exit_program(1);
+ }
+ 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);
+ }
+}
- for(j=0;j<nb_input_files;j++) {
- ic = input_files[j].ctx;
- for(i=0;i<ic->nb_streams;i++) {
- AVCodecContext *enc = ic->streams[i]->codec;
- switch(enc->codec_type) {
- case AVMEDIA_TYPE_AUDIO:
- has_audio = 1;
- break;
- case AVMEDIA_TYPE_VIDEO:
- has_video = 1;
- break;
- case AVMEDIA_TYPE_SUBTITLE:
- has_subtitle = 1;
- break;
- case AVMEDIA_TYPE_DATA:
- case AVMEDIA_TYPE_ATTACHMENT:
- case AVMEDIA_TYPE_UNKNOWN:
- has_data = 1;
- break;
- default:
- abort();
- }
- }
+static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
+{
+ OutputStream *ost;
+ AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
+ int idx = oc->nb_streams - 1;
+
+ if (!st) {
+ av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
+ exit_program(1);
+ }
+
+ output_streams_for_file[nb_output_files] =
+ grow_array(output_streams_for_file[nb_output_files],
+ sizeof(*output_streams_for_file[nb_output_files]),
+ &nb_output_streams_for_file[nb_output_files],
+ oc->nb_streams);
+ ost = output_streams_for_file[nb_output_files][idx] =
+ av_mallocz(sizeof(OutputStream));
+ if (!ost) {
+ fprintf(stderr, "Could not alloc output stream\n");
+ exit_program(1);
+ }
+ ost->file_index = nb_output_files;
+ ost->index = idx;
+ ost->st = st;
+ st->codec->codec_type = type;
+ ost->enc = choose_codec(oc, st, type, codec_names);
+ if (ost->enc) {
+ ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
}
- *has_video_ptr = has_video;
- *has_audio_ptr = has_audio;
- *has_subtitle_ptr = has_subtitle;
- *has_data_ptr = has_data;
+
+ avcodec_get_context_defaults3(st->codec, ost->enc);
+ st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
+
+ ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
+ return ost;
}
-static void new_video_stream(AVFormatContext *oc, int file_idx)
+static OutputStream *new_video_stream(AVFormatContext *oc)
{
AVStream *st;
OutputStream *ost;
AVCodecContext *video_enc;
- enum CodecID codec_id = CODEC_ID_NONE;
- AVCodec *codec= NULL;
-
- if(!video_stream_copy){
- if (video_codec_name) {
- codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
- codec = avcodec_find_encoder_by_name(video_codec_name);
- } else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
- codec = avcodec_find_encoder(codec_id);
- }
- }
- ost = new_output_stream(oc, file_idx, codec);
+ ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
st = ost->st;
- if (!video_stream_copy) {
+ if (!st->stream_copy) {
ost->frame_aspect_ratio = frame_aspect_ratio;
frame_aspect_ratio = 0;
#if CONFIG_AVFILTER
video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
- video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
- if (video_stream_copy) {
- st->stream_copy = 1;
+ if (st->stream_copy) {
video_enc->sample_aspect_ratio =
st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
} else {
if (frame_rate.num)
ost->frame_rate = frame_rate;
- video_enc->codec_id = codec_id;
video_enc->width = frame_width;
video_enc->height = frame_height;
if (intra_only)
video_enc->gop_size = 0;
- if (video_qscale || same_quality) {
+ if (video_qscale || same_quant) {
video_enc->flags |= CODEC_FLAG_QSCALE;
video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
}
/* 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;
+ return ost;
}
-static void new_audio_stream(AVFormatContext *oc, int file_idx)
+static OutputStream *new_audio_stream(AVFormatContext *oc)
{
AVStream *st;
OutputStream *ost;
- AVCodec *codec= NULL;
AVCodecContext *audio_enc;
- enum CodecID codec_id = CODEC_ID_NONE;
- if(!audio_stream_copy){
- if (audio_codec_name) {
- codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
- codec = avcodec_find_encoder_by_name(audio_codec_name);
- } else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
- codec = avcodec_find_encoder(codec_id);
- }
- }
- ost = new_output_stream(oc, file_idx, codec);
+ ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
st = ost->st;
ost->bitstream_filters = audio_bitstream_filters;
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
- if (audio_stream_copy) {
- st->stream_copy = 1;
- } else {
- audio_enc->codec_id = codec_id;
-
+ if (!st->stream_copy) {
if (audio_qscale > QSCALE_NONE) {
audio_enc->flags |= CODEC_FLAG_QSCALE;
audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
/* reset some key parameters */
audio_disable = 0;
- av_freep(&audio_codec_name);
- audio_stream_copy = 0;
+
+ return ost;
}
-static void new_data_stream(AVFormatContext *oc, int file_idx)
+static OutputStream *new_data_stream(AVFormatContext *oc)
{
AVStream *st;
OutputStream *ost;
AVCodecContext *data_enc;
- ost = new_output_stream(oc, file_idx, NULL);
+ ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
st = ost->st;
data_enc = st->codec;
- if (!data_stream_copy) {
+ if (!st->stream_copy) {
fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
exit_program(1);
}
- data_enc->codec_type = AVMEDIA_TYPE_DATA;
-
if (data_codec_tag)
data_enc->codec_tag= data_codec_tag;
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
- if (data_stream_copy) {
- st->stream_copy = 1;
- }
data_disable = 0;
- av_freep(&data_codec_name);
- data_stream_copy = 0;
+ return ost;
}
-static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
+static OutputStream *new_subtitle_stream(AVFormatContext *oc)
{
AVStream *st;
OutputStream *ost;
- AVCodec *codec=NULL;
AVCodecContext *subtitle_enc;
- enum CodecID codec_id = CODEC_ID_NONE;
- if(!subtitle_stream_copy){
- if (subtitle_codec_name) {
- codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
- codec = avcodec_find_encoder_by_name(subtitle_codec_name);
- } else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
- codec = avcodec_find_encoder(codec_id);
- }
- }
- ost = new_output_stream(oc, file_idx, codec);
+ ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
st = ost->st;
subtitle_enc = st->codec;
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
- if (subtitle_stream_copy) {
- st->stream_copy = 1;
- } else {
- subtitle_enc->codec_id = codec_id;
- }
if (subtitle_language) {
av_dict_set(&st->metadata, "language", subtitle_language, 0);
}
subtitle_disable = 0;
- av_freep(&subtitle_codec_name);
- subtitle_stream_copy = 0;
-}
-
-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");
- exit_program(1);
- }
- oc = output_files[file_idx];
-
- 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 if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
- else av_assert0(0);
- return 0;
+ return ost;
}
/* arg format is "output-stream-index:streamid-value". */
return 0;
}
+static int copy_chapters(int infile, int outfile)
+{
+ AVFormatContext *is = input_files[infile].ctx;
+ AVFormatContext *os = output_files[outfile];
+ int i;
+
+ for (i = 0; i < is->nb_chapters; i++) {
+ AVChapter *in_ch = is->chapters[i], *out_ch;
+ int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
+ 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);
+
+ if (metadata_chapters_autocopy)
+ av_dict_copy(&out_ch->metadata, in_ch->metadata, 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;
+}
+
+static int read_avserver_streams(AVFormatContext *s, const char *filename)
+{
+ int i, err;
+ AVFormatContext *ic = NULL;
+
+ err = avformat_open_input(&ic, filename, NULL, NULL);
+ if (err < 0)
+ return err;
+ /* copy stream format */
+ for(i=0;i<ic->nb_streams;i++) {
+ AVStream *st;
+ OutputStream *ost;
+ AVCodec *codec;
+
+ codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
+ ost = new_output_stream(s, codec->type);
+ st = ost->st;
+
+ // FIXME: a more elegant solution is needed
+ memcpy(st, ic->streams[i], sizeof(AVStream));
+ st->info = NULL;
+ avcodec_copy_context(st->codec, ic->streams[i]->codec);
+
+ if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
+ choose_sample_fmt(st, codec);
+ else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
+ choose_pixel_fmt(st, codec);
+ }
+
+ av_close_input_file(ic);
+ return 0;
+}
+
static void opt_output_file(const char *filename)
{
AVFormatContext *oc;
- int i, err, use_video, use_audio, use_subtitle, use_data;
- int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
+ int i, err;
AVOutputFormat *file_oformat;
+ OutputStream *ost;
+ InputStream *ist;
if (!strcmp(filename, "-"))
filename = "pipe:";
print_error(filename, err);
exit_program(1);
}
+ } else if (!nb_stream_maps) {
+ /* pick the "best" stream of each type */
+#define NEW_STREAM(type, index)\
+ if (index >= 0) {\
+ ost = new_ ## type ## _stream(oc);\
+ ost->source_index = index;\
+ ost->sync_ist = &input_streams[index];\
+ input_streams[index].discard = 0;\
+ }
+
+ /* video: highest resolution */
+ if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
+ int area = 0, idx = -1;
+ for (i = 0; i < nb_input_streams; i++) {
+ ist = &input_streams[i];
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
+ ist->st->codec->width * ist->st->codec->height > area) {
+ area = ist->st->codec->width * ist->st->codec->height;
+ idx = i;
+ }
+ }
+ NEW_STREAM(video, idx);
+ }
+
+ /* audio: most channels */
+ if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
+ int channels = 0, idx = -1;
+ for (i = 0; i < nb_input_streams; i++) {
+ ist = &input_streams[i];
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
+ ist->st->codec->channels > channels) {
+ channels = ist->st->codec->channels;
+ idx = i;
+ }
+ }
+ NEW_STREAM(audio, idx);
+ }
+
+ /* subtitles: pick first */
+ if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
+ for (i = 0; i < nb_input_streams; i++)
+ if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
+ NEW_STREAM(subtitle, i);
+ break;
+ }
+ }
+ /* do something with data? */
} else {
- use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
- use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
- use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
- use_data = data_stream_copy || data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
-
- /* disable if no corresponding type found */
- check_inputs(&input_has_video,
- &input_has_audio,
- &input_has_subtitle,
- &input_has_data);
-
- if (!input_has_video)
- use_video = 0;
- if (!input_has_audio)
- use_audio = 0;
- if (!input_has_subtitle)
- use_subtitle = 0;
- if (!input_has_data)
- use_data = 0;
-
- /* manual disable */
- if (audio_disable) use_audio = 0;
- if (video_disable) use_video = 0;
- if (subtitle_disable) use_subtitle = 0;
- if (data_disable) use_data = 0;
-
- 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);
- if (use_data) new_data_stream(oc, nb_output_files);
-
- av_dict_copy(&oc->metadata, metadata, 0);
- av_dict_free(&metadata);
+ for (i = 0; i < nb_stream_maps; i++) {
+ StreamMap *map = &stream_maps[i];
+
+ if (map->disabled)
+ continue;
+
+ ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
+ switch (ist->st->codec->codec_type) {
+ case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(oc); break;
+ case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc); break;
+ case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
+ case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc); break;
+ default:
+ av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
+ map->file_index, map->stream_index);
+ exit_program(1);
+ }
+
+ ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
+ ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
+ map->sync_stream_index];
+ ist->discard = 0;
+ }
}
+ av_dict_copy(&oc->metadata, metadata, 0);
+ av_dict_free(&metadata);
+
av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
output_files[nb_output_files++] = oc;
oc->preload= (int)(mux_preload*AV_TIME_BASE);
oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
- if (loop_output >= 0) {
- av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
- oc->loop_output = loop_output;
- }
oc->flags |= AVFMT_FLAG_NONBLOCK;
/* copy chapters */
if (chapters_input_file >= 0)
copy_chapters(chapters_input_file, nb_output_files - 1);
+ /* copy metadata */
+ for (i = 0; i < nb_meta_data_maps; i++) {
+ AVFormatContext *files[2];
+ AVDictionary **meta[2];
+ int j;
+
+#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
+ if ((index) < 0 || (index) >= (nb_elems)) {\
+ av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
+ (desc), (index));\
+ exit_program(1);\
+ }
+
+ int in_file_index = meta_data_maps[i][1].file;
+ if (in_file_index < 0)
+ continue;
+ METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
+
+ files[0] = oc;
+ files[1] = input_files[in_file_index].ctx;
+
+ for (j = 0; j < 2; j++) {
+ MetadataMap *map = &meta_data_maps[i][j];
+
+ switch (map->type) {
+ case 'g':
+ meta[j] = &files[j]->metadata;
+ break;
+ case 's':
+ METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
+ meta[j] = &files[j]->streams[map->index]->metadata;
+ break;
+ case 'c':
+ METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
+ meta[j] = &files[j]->chapters[map->index]->metadata;
+ break;
+ case 'p':
+ METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
+ meta[j] = &files[j]->programs[map->index]->metadata;
+ break;
+ }
+ }
+
+ av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
+ }
+
+ /* copy global metadata by default */
+ if (metadata_global_autocopy && nb_input_files)
+ av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
+ AV_DICT_DONT_OVERWRITE);
+ if (metadata_streams_autocopy)
+ for (i = 0; i < oc->nb_streams; i++) {
+ InputStream *ist = &input_streams[output_streams_for_file[nb_output_files-1][i]->source_index];
+ av_dict_copy(&oc->streams[i]->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
+ }
+
frame_rate = (AVRational){0, 0};
frame_width = 0;
frame_height = 0;
audio_sample_fmt = AV_SAMPLE_FMT_NONE;
chapters_input_file = INT_MAX;
+ av_freep(&meta_data_maps);
+ nb_meta_data_maps = 0;
+ metadata_global_autocopy = 1;
+ metadata_streams_autocopy = 1;
+ metadata_chapters_autocopy = 1;
+ av_freep(&stream_maps);
+ nb_stream_maps = 0;
+
+ av_dict_free(&codec_names);
+
av_freep(&forced_key_frames);
uninit_opts();
init_opts();
}
if(!strcmp(arg, "vcd")) {
- opt_video_codec("vcodec", "mpeg1video");
- opt_audio_codec("vcodec", "mp2");
+ opt_codec("c:v", "mpeg1video");
+ opt_codec("c:a", "mp2");
opt_format("f", "vcd");
opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
opt_default("minrate", "1150000");
opt_default("bufsize", "327680"); // 40*1024*8;
- opt_default("ab", "224000");
+ opt_default("b:a", "224000");
audio_sample_rate = 44100;
audio_channels = 2;
mux_preload= (36000+3*1200) / 90000.0; //0.44
} else if(!strcmp(arg, "svcd")) {
- opt_video_codec("vcodec", "mpeg2video");
- opt_audio_codec("acodec", "mp2");
+ opt_codec("c:v", "mpeg2video");
+ opt_codec("c:a", "mp2");
opt_format("f", "svcd");
opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
opt_default("flags", "+scan_offset");
- opt_default("ab", "224000");
+ opt_default("b:a", "224000");
audio_sample_rate = 44100;
opt_default("packetsize", "2324");
} else if(!strcmp(arg, "dvd")) {
- opt_video_codec("vcodec", "mpeg2video");
- opt_audio_codec("vcodec", "ac3");
+ opt_codec("c:v", "mpeg2video");
+ opt_codec("c:a", "ac3");
opt_format("f", "dvd");
opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
- opt_default("ab", "448000");
+ opt_default("b:a", "448000");
audio_sample_rate = 48000;
} else if(!strncmp(arg, "dv", 2)) {
return 0;
}
-static int opt_preset(const char *opt, const char *arg)
-{
- FILE *f=NULL;
- char filename[1000], tmp[1000], tmp2[1000], line[1000];
- char *codec_name = *opt == 'v' ? video_codec_name :
- *opt == 'a' ? audio_codec_name :
- subtitle_codec_name;
-
- if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
- fprintf(stderr, "File for preset '%s' not found\n", arg);
- exit_program(1);
- }
-
- while(!feof(f)){
- int e= fscanf(f, "%999[^\n]\n", line) - 1;
- if(line[0] == '#' && !e)
- continue;
- e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
- if(e){
- fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
- exit_program(1);
- }
- if(!strcmp(tmp, "acodec")){
- opt_audio_codec(tmp, tmp2);
- }else if(!strcmp(tmp, "vcodec")){
- opt_video_codec(tmp, tmp2);
- }else if(!strcmp(tmp, "scodec")){
- opt_subtitle_codec(tmp, tmp2);
- }else if(!strcmp(tmp, "dcodec")){
- opt_data_codec(tmp, 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);
- exit_program(1);
- }
- }
-
- fclose(f);
-
- return 0;
-}
-
static const OptionDef options[] = {
/* main options */
#include "cmdutils_common_opts.h"
{ "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
{ "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
{ "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
+ { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
+ { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
{ "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
- { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
- "outfile[,metadata]:infile[,metadata]" },
{ "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
"outfile[,metadata]:infile[,metadata]" },
{ "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file}, "set chapters mapping", "input_file_index" },
{ "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
{ "itsoffset", 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", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
{ "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
{ "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},
{ "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
"when dumping packets, also dump the payload" },
{ "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
- { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
- { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
{ "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
{ "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
{ "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
{ "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
{ "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
{ "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
- { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
+ { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
"use same quantizer as source (implies VBR)" },
{ "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
{ "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
{ "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_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
- { "newvideo", OPT_VIDEO, {(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" },
{ "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_codec_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_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_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_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
/* grab options */
- { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
- { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
{ "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
/* muxer options */
{ "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
{ "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
- { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
- { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
- { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
- { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
/* data codec support */
{ "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
}
ti = getutime();
- if (transcode(output_files, nb_output_files, input_files, nb_input_files,
- stream_maps, nb_stream_maps) < 0)
+ if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
exit_program(1);
ti = getutime() - ti;
if (do_benchmark) {
projects / ffmpeg / blobdiff