#define MAX_FILES 20
+static 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 AVMetaDataMap meta_data_maps[MAX_FILES];
static int nb_meta_data_maps;
-static AVInputFormat *file_iformat;
-static AVOutputFormat *file_oformat;
static int frame_width = 0;
static int frame_height = 0;
static float frame_aspect_ratio = 0;
static float video_qscale = 0;
static uint16_t *intra_matrix = NULL;
static uint16_t *inter_matrix = NULL;
-#if 0 //experimental, (can be removed)
-static float video_rc_qsquish=1.0;
-static float video_rc_qmod_amp=0;
-static int video_rc_qmod_freq=0;
-#endif
static const char *video_rc_override_string=NULL;
static int video_disable = 0;
static int video_discard = 0;
AVFrame pict_tmp; /* temporary image for resampling */
struct SwsContext *img_resample_ctx; /* for image resampling */
int resample_height;
+ int resample_width;
+ int resample_pix_fmt;
+
+ /* full frame size of first frame */
+ int original_height;
+ int original_width;
+ /* cropping area sizes */
int video_crop;
- int topBand; /* cropping area sizes */
+ 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;
+ /* padding area sizes */
int video_pad;
- int padtop; /* padding area sizes */
+ int padtop;
int padbottom;
int padleft;
int padright;
#endif
}
-static volatile sig_atomic_t received_sigterm = 0;
+static volatile int received_sigterm = 0;
static void
sigterm_handler(int sig)
st = av_mallocz(sizeof(AVStream));
memcpy(st, ic->streams[i], sizeof(AVStream));
st->codec = avcodec_alloc_context();
+ if (!st->codec) {
+ print_error(filename, AVERROR(ENOMEM));
+ av_exit(1);
+ }
memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
s->streams[i] = st;
int64_t pts)
{
static uint8_t *subtitle_out = NULL;
- int subtitle_out_max_size = 65536;
+ int subtitle_out_max_size = 1024 * 1024;
int subtitle_out_size, nb, i;
AVCodecContext *enc;
AVPacket pkt;
nb = 1;
for(i = 0; i < nb; i++) {
+ sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
+ // start_display_time is required to be 0
+ sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
+ sub->end_display_time -= sub->start_display_time;
+ sub->start_display_time = 0;
subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
subtitle_out_max_size, sub);
+ if (subtitle_out_size < 0) {
+ fprintf(stderr, "Subtitle encoding failed\n");
+ av_exit(1);
+ }
av_init_packet(&pkt);
pkt.stream_index = ost->index;
pkt.data = subtitle_out;
pkt.size = subtitle_out_size;
- pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
+ pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
/* XXX: the pts correction is handled here. Maybe handling
it in the codec would be better */
int *frame_size)
{
int nb_frames, i, ret;
+ int64_t topBand, bottomBand, leftBand, rightBand;
AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
AVFrame picture_crop_temp, picture_pad_temp;
AVCodecContext *enc, *dec;
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)))
+ || (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));
+ /* 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->pix_fmt,
+ ost->st->codec->width - (ost->padleft + ost->padright),
+ ost->st->codec->height - (ost->padtop + ost->padbottom),
+ ost->st->codec->pix_fmt,
+ sws_flags, NULL, NULL, NULL);
+ if (ost->img_resample_ctx == NULL) {
+ fprintf(stderr, "Cannot get resampling context\n");
+ av_exit(1);
+ }
+ }
sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
}
AVSubtitle subtitle, *subtitle_to_free;
int got_subtitle;
AVPacket avpkt;
+ int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
if(ist->next_pts == AV_NOPTS_VALUE)
ist->next_pts= ist->pts;
handle_eof:
ist->pts= ist->next_pts;
- if(avpkt.size && avpkt.size != pkt->size && verbose>0)
+ if(avpkt.size && avpkt.size != pkt->size &&
+ !(ist->st->codec->codec->capabilities & CODEC_CAP_SUBFRAMES) && verbose>0)
fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
/* decode the packet if needed */
continue;
}
data_buf = (uint8_t *)samples;
- ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
+ ist->next_pts += ((int64_t)AV_TIME_BASE/bps * data_size) /
(ist->st->codec->sample_rate * ist->st->codec->channels);
break;}
case CODEC_TYPE_VIDEO:
if (ost->source_index == ist_index) {
os = output_files[ost->file_index];
-#if 0
- printf("%d: got pts=%0.3f %0.3f\n", i,
- (double)pkt->pts / AV_TIME_BASE,
- ((double)ist->pts / AV_TIME_BASE) -
- ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
-#endif
/* set the input output pts pairs */
//ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
opkt.flags= pkt->flags;
//FIXME remove the following 2 lines they shall be replaced by the bitstream filters
+ if(ost->st->codec->codec_id != CODEC_ID_H264) {
if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
opkt.destruct= av_destruct_packet;
+ } else {
+ opkt.data = data_buf;
+ opkt.size = data_size;
+ }
write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
ost->st->codec->frame_number++;
(frame_padtop + frame_padbottom)) ||
(codec->pix_fmt != icodec->pix_fmt));
if (ost->video_crop) {
- ost->topBand = frame_topBand;
- ost->leftBand = frame_leftBand;
+ 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_pad) {
ost->padtop = frame_padtop;
fprintf(stderr, "Cannot get resampling context\n");
av_exit(1);
}
- ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
+
+ ost->original_height = icodec->height;
+ ost->original_width = icodec->width;
+
+ ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
+ ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
+ ost->resample_pix_fmt= icodec->pix_fmt;
codec->bits_per_raw_sample= 0;
}
ost->encoding_needed = 1;
if (!bit_buffer)
bit_buffer = av_malloc(bit_buffer_size);
if (!bit_buffer) {
+ fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
+ bit_buffer_size);
ret = AVERROR(ENOMEM);
goto fail;
}
if (!codec)
codec = avcodec_find_encoder(ost->st->codec->codec_id);
if (!codec) {
- snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
- ost->file_index, ost->index);
+ snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
+ ost->st->codec->codec_id, ost->file_index, ost->index);
ret = AVERROR(EINVAL);
goto dump_format;
}
if (avcodec_open(ost->st->codec, codec) < 0) {
- snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
+ snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
ost->file_index, ost->index);
ret = AVERROR(EINVAL);
goto dump_format;
if (!codec)
codec = avcodec_find_decoder(ist->st->codec->codec_id);
if (!codec) {
- snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
+ snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
ist->st->codec->codec_id, ist->file_index, ist->index);
ret = AVERROR(EINVAL);
goto dump_format;
}
if (avcodec_open(ist->st->codec, codec) < 0) {
- snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
+ snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
ist->file_index, ist->index);
ret = AVERROR(EINVAL);
goto dump_format;
return ret;
}
-#if 0
-int file_read(const char *filename)
-{
- URLContext *h;
- unsigned char buffer[1024];
- int len, i;
-
- if (url_open(&h, filename, O_RDONLY) < 0) {
- printf("could not open '%s'\n", filename);
- return -1;
- }
- for(;;) {
- len = url_read(h, buffer, sizeof(buffer));
- if (len <= 0)
- break;
- for(i=0;i<len;i++) putchar(buffer[i]);
- }
- url_close(h);
- return 0;
-}
-#endif
-
static void opt_format(const char *arg)
{
/* compatibility stuff for pgmyuv */
fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
}
- file_iformat = av_find_input_format(arg);
- file_oformat = guess_format(arg, NULL, NULL);
- if (!file_iformat && !file_oformat) {
- fprintf(stderr, "Unknown input or output format: %s\n", arg);
- av_exit(1);
- }
+ last_asked_format = arg;
}
static void opt_video_rc_override_string(const char *arg)
return 0;
}
-static int opt_loglevel(const char *opt, const char *arg)
-{
- int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
- av_log_set_level(level);
- return 0;
-}
-
static int opt_verbose(const char *opt, const char *arg)
{
verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
{
AVFormatContext *ic;
AVFormatParameters params, *ap = ¶ms;
+ AVInputFormat *file_iformat = NULL;
int err, i, ret, rfps, rfps_base;
int64_t timestamp;
+ if (last_asked_format) {
+ file_iformat = av_find_input_format(last_asked_format);
+ last_asked_format = NULL;
+ }
+
if (!strcmp(filename, "-"))
filename = "pipe:";
/* get default parameters from command line */
ic = avformat_alloc_context();
+ if (!ic) {
+ print_error(filename, AVERROR(ENOMEM));
+ av_exit(1);
+ }
memset(ap, 0, sizeof(*ap));
ap->prealloced_context = 1;
dump_format(ic, nb_input_files, filename, 0);
nb_input_files++;
- file_iformat = NULL;
- file_oformat = NULL;
video_channel = 0;
{
AVStream *st;
AVCodecContext *video_enc;
- int codec_id;
+ enum CodecID codec_id;
st = av_new_stream(oc, oc->nb_streams);
if (!st) {
{
AVStream *st;
AVCodecContext *audio_enc;
- int codec_id;
+ enum CodecID codec_id;
st = av_new_stream(oc, oc->nb_streams);
if (!st) {
int use_video, use_audio, use_subtitle;
int input_has_video, input_has_audio, input_has_subtitle;
AVFormatParameters params, *ap = ¶ms;
+ AVOutputFormat *file_oformat;
if (!strcmp(filename, "-"))
filename = "pipe:";
oc = avformat_alloc_context();
+ if (!oc) {
+ print_error(filename, AVERROR(ENOMEM));
+ av_exit(1);
+ }
- if (!file_oformat) {
+ if (last_asked_format) {
+ file_oformat = guess_format(last_asked_format, NULL, NULL);
+ if (!file_oformat) {
+ fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
+ av_exit(1);
+ }
+ last_asked_format = NULL;
+ } else {
file_oformat = guess_format(NULL, filename, NULL);
if (!file_oformat) {
fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
oc->flags |= AVFMT_FLAG_NONBLOCK;
set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
-
- /* reset some options */
- file_oformat = NULL;
- file_iformat = NULL;
}
/* same option as mencoder */
opt_frame_size(norm ? "352x240" : "352x288");
opt_frame_rate(NULL, frame_rates[norm]);
- opt_default("gop", norm ? "18" : "15");
+ opt_default("g", norm ? "18" : "15");
opt_default("b", "1150000");
opt_default("maxrate", "1150000");
opt_frame_size(norm ? "480x480" : "480x576");
opt_frame_rate(NULL, frame_rates[norm]);
- opt_default("gop", norm ? "18" : "15");
+ opt_default("g", norm ? "18" : "15");
opt_default("b", "2040000");
opt_default("maxrate", "2516000");
opt_frame_size(norm ? "720x480" : "720x576");
opt_frame_rate(NULL, frame_rates[norm]);
- opt_default("gop", norm ? "18" : "15");
+ opt_default("g", norm ? "18" : "15");
opt_default("b", "6000000");
opt_default("maxrate", "9000000");
FFMPEG_DATADIR,
};
- for(i=!base[0]; i<2 && !f; i++){
- snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
- f= fopen(filename, "r");
- if(!f){
- char *codec_name= *opt == 'v' ? video_codec_name :
- *opt == 'a' ? audio_codec_name :
- subtitle_codec_name;
- snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
+ if (*opt != 'f') {
+ for(i=!base[0]; i<2 && !f; i++){
+ snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
f= fopen(filename, "r");
+ if(!f){
+ char *codec_name= *opt == 'v' ? video_codec_name :
+ *opt == 'a' ? audio_codec_name :
+ subtitle_codec_name;
+ snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
+ f= fopen(filename, "r");
+ }
}
- }
- if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
- is_dos_path(arg))){
+ } else {
av_strlcpy(filename, arg, sizeof(filename));
f= fopen(filename, "r");
}
{ "L", OPT_EXIT, {(void*)show_license}, "show license" },
{ "h", OPT_EXIT, {(void*)show_help}, "show help" },
{ "version", OPT_EXIT, {(void*)show_version}, "show version" },
- { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
+ { "formats" , OPT_EXIT, {(void*)show_formats }, "show available formats" },
+ { "codecs" , OPT_EXIT, {(void*)show_codecs }, "show available codecs" },
+ { "bsfs" , OPT_EXIT, {(void*)show_bsfs }, "show available bit stream filters" },
+ { "protocols", OPT_EXIT, {(void*)show_protocols}, "show available protocols" },
{ "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" },
{ "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
{ "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
{ "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
- { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "number" },
+ { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "loglevel" },
{ "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
{ "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
{ "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
{ "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
{ "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
{ "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
+ { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options to the indicated preset file", "filename" },
{ "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
{ NULL, },
avdevice_register_all();
av_register_all();
+#if HAVE_ISATTY
if(isatty(STDIN_FILENO))
url_set_interrupt_cb(decode_interrupt_cb);
+#endif
for(i=0; i<CODEC_TYPE_NB; i++){
avcodec_opts[i]= avcodec_alloc_context2(i);