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 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_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) {
- st->codec->codec_type = codec->type;
- ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
- }
-
- 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
*/
}
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;
}
}
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_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)
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;
}
+ /* 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);
orig_nb_streams = ic->nb_streams;
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 OutputStream *new_video_stream(AVFormatContext *oc, int file_idx)
+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);
+ }
+}
+
+static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
{
- AVStream *st;
OutputStream *ost;
- AVCodecContext *video_enc;
- enum CodecID codec_id = CODEC_ID_NONE;
- AVCodec *codec= NULL;
+ 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(!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);
- }
+ 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);
}
- ost = new_output_stream(oc, file_idx, codec);
+ 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 OutputStream *new_video_stream(AVFormatContext *oc)
+{
+ AVStream *st;
+ OutputStream *ost;
+ AVCodecContext *video_enc;
+
+ 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 OutputStream *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 OutputStream *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 OutputStream *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;
return ost;
}
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;
/* pick the "best" stream of each type */
#define NEW_STREAM(type, index)\
if (index >= 0) {\
- ost = new_ ## type ## _stream(oc, nb_output_files);\
+ ost = new_ ## type ## _stream(oc);\
ost->source_index = index;\
ost->sync_ist = &input_streams[index];\
input_streams[index].discard = 0;\
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, nb_output_files); break;
- case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc, nb_output_files); break;
- case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc, nb_output_files); break;
- case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc, nb_output_files); break;
+ 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);
}
/* copy global metadata by default */
- if (metadata_global_autocopy)
+ 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)
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_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
"outfile[,metadata]:infile[,metadata]" },
{ "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" },
{ "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" },
projects / ffmpeg / blobdiff