#include "libavcodec/audioconvert.h"
#include "libavcodec/colorspace.h"
#include "libavutil/fifo.h"
+#include "libavutil/pixdesc.h"
#include "libavutil/avstring.h"
#include "libavformat/os_support.h"
static const OptionDef options[];
-#define MAX_FILES 20
+#define MAX_FILES 100
static const char *last_asked_format = NULL;
static AVFormatContext *input_files[MAX_FILES];
static int video_discard = 0;
static char *video_codec_name = NULL;
static int video_codec_tag = 0;
+static char *video_language = NULL;
static int same_quality = 0;
static int do_deinterlace = 0;
static int top_field_first = -1;
is not defined */
int64_t pts; /* current pts */
int is_start; /* is 1 at the start and after a discontinuity */
+ int showed_multi_packet_warning;
} AVInputStream;
typedef struct AVInputFile {
signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
+#ifdef SIGXCPU
+ signal(SIGXCPU, sigterm_handler);
+#endif
+
/*
register a function to be called at normal program termination
*/
{
uint8_t *buftmp;
int64_t audio_out_size, audio_buf_size;
+ int64_t allocated_for_size= size;
int size_out, frame_bytes, ret;
AVCodecContext *enc= ost->st->codec;
int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
const int coded_bps = av_get_bits_per_sample(enc->codec->id);
- audio_buf_size= (size + isize*dec->channels - 1) / (isize*dec->channels);
+need_realloc:
+ audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
- audio_buf_size= audio_buf_size*2 + 10000; //saftey factors for the deprecated resampling API
+ audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
audio_buf_size*= osize*enc->channels;
audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
static uint8_t *input_tmp= NULL;
input_tmp= av_realloc(input_tmp, byte_delta + size);
- if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
- ist->is_start=0;
- else
- byte_delta= MAX_AUDIO_PACKET_SIZE - size;
+ if(byte_delta > allocated_for_size - size){
+ allocated_for_size= byte_delta + (int64_t)size;
+ goto need_realloc;
+ }
+ ist->is_start=0;
memset(input_tmp, 0, byte_delta);
memcpy(input_tmp + byte_delta, buf, size);
if (verbose>2)
fprintf(stderr, "*** drop!\n");
}else if (nb_frames > 1) {
- nb_frames_dup += nb_frames;
+ nb_frames_dup += nb_frames - 1;
if (verbose>2)
fprintf(stderr, "*** %d dup!\n", nb_frames-1);
}
"size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
(double)total_size / 1024, ti1, bitrate);
- if (verbose > 1)
+ if (nb_frames_dup || nb_frames_drop)
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
nb_frames_dup, nb_frames_drop);
AVFormatContext *os;
AVOutputStream *ost;
int ret, i;
- uint8_t *data_buf;
- int data_size, got_picture;
+ int got_picture;
AVFrame picture;
void *buffer_to_free;
static unsigned int samples_size= 0;
//while we have more to decode or while the decoder did output something on EOF
while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
+ uint8_t *data_buf, *decoded_data_buf;
+ int data_size, decoded_data_size;
handle_eof:
ist->pts= ist->next_pts;
if(avpkt.size && avpkt.size != pkt->size &&
- !(ist->st->codec->codec->capabilities & CODEC_CAP_SUBFRAMES) && verbose>0)
+ ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
+ ist->showed_multi_packet_warning=1;
+ }
/* decode the packet if needed */
- data_buf = NULL; /* fail safe */
- data_size = 0;
+ decoded_data_buf = NULL; /* fail safe */
+ decoded_data_size= 0;
+ data_buf = avpkt.data;
+ data_size = avpkt.size;
subtitle_to_free = NULL;
if (ist->decoding_needed) {
switch(ist->st->codec->codec_type) {
av_free(samples);
samples= av_malloc(samples_size);
}
- data_size= samples_size;
+ decoded_data_size= samples_size;
/* XXX: could avoid copy if PCM 16 bits with same
endianness as CPU */
- ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
+ ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
&avpkt);
if (ret < 0)
goto fail_decode;
avpkt.data += ret;
avpkt.size -= ret;
+ data_size = ret;
/* Some bug in mpeg audio decoder gives */
- /* data_size < 0, it seems they are overflows */
- if (data_size <= 0) {
+ /* decoded_data_size < 0, it seems they are overflows */
+ if (decoded_data_size <= 0) {
/* no audio frame */
continue;
}
- data_buf = (uint8_t *)samples;
- ist->next_pts += ((int64_t)AV_TIME_BASE/bps * data_size) /
+ decoded_data_buf = (uint8_t *)samples;
+ ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
(ist->st->codec->sample_rate * ist->st->codec->channels);
break;}
case CODEC_TYPE_VIDEO:
- data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
+ decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
/* XXX: allocate picture correctly */
avcodec_get_frame_defaults(&picture);
}
break;
}
- data_buf = avpkt.data;
- data_size = avpkt.size;
ret = avpkt.size;
avpkt.size = 0;
}
if (audio_volume != 256) {
short *volp;
volp = samples;
- for(i=0;i<(data_size / sizeof(short));i++) {
+ for(i=0;i<(decoded_data_size / sizeof(short));i++) {
int v = ((*volp) * audio_volume + 128) >> 8;
if (v < -32768) v = -32768;
if (v > 32767) v = 32767;
//ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
if (ost->encoding_needed) {
+ assert(ist->decoding_needed);
switch(ost->st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
- do_audio_out(os, ost, ist, data_buf, data_size);
+ do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
break;
case CODEC_TYPE_VIDEO:
do_video_out(os, ost, ist, &picture, &frame_size);
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;
+ if( ost->st->codec->codec_id != CODEC_ID_H264
+ && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
+ && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
+ ) {
+ if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
+ opkt.destruct= av_destruct_packet;
} else {
opkt.data = data_buf;
opkt.size = data_size;
if(!codec->codec_tag){
if( !os->oformat->codec_tag
- || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
+ || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
|| av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
codec->codec_tag = icodec->codec_tag;
}
ist = ist_table[ost->source_index];
if(no_packet[ist->file_index])
continue;
- if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
- opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
- else
opts = ost->st->pts.val * av_q2d(ost->st->time_base);
ipts = (double)ist->pts;
if (!file_table[ist->file_index].eof_reached){
}
}
+ /* finish if recording time exhausted */
+ if (pkt.pts * av_q2d(ist->st->time_base) >= (recording_time / 1000000.0))
+ goto discard_packet;
+
//fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
static void opt_frame_pix_fmt(const char *arg)
{
if (strcmp(arg, "list")) {
- frame_pix_fmt = avcodec_get_pix_fmt(arg);
+ frame_pix_fmt = av_get_pix_fmt(arg);
if (frame_pix_fmt == PIX_FMT_NONE) {
fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
av_exit(1);
}
} else {
- list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
+ show_pix_fmts();
av_exit(0);
}
}
// ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
ap->channel = video_channel;
ap->standard = video_standard;
- ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
- ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
- if(pgmyuv_compatibility_hack)
- ap->video_codec_id= CODEC_ID_PGMYUV;
set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
ic->flags |= AVFMT_FLAG_NONBLOCK;
+ if(pgmyuv_compatibility_hack)
+ ic->video_codec_id= CODEC_ID_PGMYUV;
+
/* open the input file with generic libav function */
err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
if (err < 0) {
/* update the current parameters so that they match the one of the input stream */
for(i=0;i<ic->nb_streams;i++) {
- AVCodecContext *enc = ic->streams[i]->codec;
- if(thread_count>1)
- avcodec_thread_init(enc, thread_count);
- enc->thread_count= thread_count;
+ AVStream *st = ic->streams[i];
+ AVCodecContext *enc = st->codec;
+ avcodec_thread_init(enc, thread_count);
switch(enc->codec_type) {
case CODEC_TYPE_AUDIO:
set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
audio_sample_fmt = enc->sample_fmt;
input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
if(audio_disable)
- ic->streams[i]->discard= AVDISCARD_ALL;
+ st->discard= AVDISCARD_ALL;
break;
case CODEC_TYPE_VIDEO:
set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
if(video_disable)
- ic->streams[i]->discard= AVDISCARD_ALL;
+ st->discard= AVDISCARD_ALL;
else if(video_discard)
- ic->streams[i]->discard= video_discard;
+ st->discard= video_discard;
break;
case CODEC_TYPE_DATA:
break;
case CODEC_TYPE_SUBTITLE:
input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
if(subtitle_disable)
- ic->streams[i]->discard = AVDISCARD_ALL;
+ st->discard = AVDISCARD_ALL;
break;
case CODEC_TYPE_ATTACHMENT:
case CODEC_TYPE_UNKNOWN:
bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
video_bitstream_filters= NULL;
- if(thread_count>1)
- avcodec_thread_init(st->codec, thread_count);
+ avcodec_thread_init(st->codec, thread_count);
video_enc = st->codec;
if(inter_matrix)
video_enc->inter_matrix = inter_matrix;
- video_enc->thread_count = thread_count;
p= video_rc_override_string;
for(i=0; p; i++){
int start, end, q;
}
}
nb_ocodecs++;
+ if (video_language) {
+ av_metadata_set(&st->metadata, "language", video_language);
+ av_freep(&video_language);
+ }
/* reset some key parameters */
video_disable = 0;
bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
audio_bitstream_filters= NULL;
- if(thread_count>1)
- avcodec_thread_init(st->codec, thread_count);
+ avcodec_thread_init(st->codec, thread_count);
audio_enc = st->codec;
audio_enc->codec_type = CODEC_TYPE_AUDIO;
audio_enc->flags |= CODEC_FLAG_QSCALE;
audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
}
- audio_enc->thread_count = thread_count;
audio_enc->channels = audio_channels;
audio_enc->sample_fmt = audio_sample_fmt;
audio_enc->channel_layout = channel_layout;
audio_enc->time_base= (AVRational){1, audio_sample_rate};
if (audio_language) {
av_metadata_set(&st->metadata, "language", audio_language);
- av_free(audio_language);
- audio_language = NULL;
+ av_freep(&audio_language);
}
/* reset some key parameters */
if (subtitle_language) {
av_metadata_set(&st->metadata, "language", subtitle_language);
- av_free(subtitle_language);
- subtitle_language = NULL;
+ av_freep(&subtitle_language);
}
subtitle_disable = 0;
}
if (last_asked_format) {
- file_oformat = guess_format(last_asked_format, NULL, NULL);
+ file_oformat = av_guess_format(last_asked_format, NULL, NULL);
if (!file_oformat) {
fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
av_exit(1);
}
last_asked_format = NULL;
} else {
- file_oformat = guess_format(NULL, filename, NULL);
+ file_oformat = av_guess_format(NULL, filename, NULL);
if (!file_oformat) {
fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
filename);
vfprintf(stdout, fmt, vl);
}
+static void show_usage(void)
+{
+ printf("Hyper fast Audio and Video encoder\n");
+ printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
+ printf("\n");
+}
+
static void show_help(void)
{
av_log_set_callback(log_callback_help);
- printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
- "Hyper fast Audio and Video encoder\n");
- printf("\n");
+ show_usage();
show_help_options(options, "Main options:\n",
OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
show_help_options(options, "\nAdvanced options:\n",
static void opt_target(const char *arg)
{
- int norm = -1;
+ enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
if(!strncmp(arg, "pal-", 4)) {
- norm = 0;
+ norm = PAL;
arg += 4;
} else if(!strncmp(arg, "ntsc-", 5)) {
- norm = 1;
+ norm = NTSC;
arg += 5;
} else if(!strncmp(arg, "film-", 5)) {
- norm = 2;
+ norm = FILM;
arg += 5;
} else {
int fr;
/* Calculate FR via float to avoid int overflow */
fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
if(fr == 25000) {
- norm = 0;
+ norm = PAL;
} else if((fr == 29970) || (fr == 23976)) {
- norm = 1;
+ norm = NTSC;
} else {
/* Try to determine PAL/NTSC by peeking in the input files */
if(nb_input_files) {
continue;
fr = c->time_base.den * 1000 / c->time_base.num;
if(fr == 25000) {
- norm = 0;
+ norm = PAL;
break;
} else if((fr == 29970) || (fr == 23976)) {
- norm = 1;
+ norm = NTSC;
break;
}
}
- if(norm >= 0)
+ if(norm != UNKNOWN)
break;
}
}
}
- if(verbose && norm >= 0)
- fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
+ if(verbose && norm != UNKNOWN)
+ fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
}
- if(norm < 0) {
+ if(norm == UNKNOWN) {
fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
opt_audio_codec("mp2");
opt_format("vcd");
- opt_frame_size(norm ? "352x240" : "352x288");
+ opt_frame_size(norm == PAL ? "352x288" : "352x240");
opt_frame_rate(NULL, frame_rates[norm]);
- opt_default("g", norm ? "18" : "15");
+ opt_default("g", norm == PAL ? "15" : "18");
opt_default("b", "1150000");
opt_default("maxrate", "1150000");
opt_audio_codec("mp2");
opt_format("svcd");
- opt_frame_size(norm ? "480x480" : "480x576");
+ opt_frame_size(norm == PAL ? "480x576" : "480x480");
opt_frame_rate(NULL, frame_rates[norm]);
- opt_default("g", norm ? "18" : "15");
+ opt_default("g", norm == PAL ? "15" : "18");
opt_default("b", "2040000");
opt_default("maxrate", "2516000");
opt_audio_codec("ac3");
opt_format("dvd");
- opt_frame_size(norm ? "720x480" : "720x576");
+ opt_frame_size(norm == PAL ? "720x576" : "720x480");
opt_frame_rate(NULL, frame_rates[norm]);
- opt_default("g", norm ? "18" : "15");
+ opt_default("g", norm == PAL ? "15" : "18");
opt_default("b", "6000000");
opt_default("maxrate", "9000000");
opt_format("dv");
- opt_frame_size(norm ? "720x480" : "720x576");
+ opt_frame_size(norm == PAL ? "720x576" : "720x480");
opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
- (norm ? "yuv411p" : "yuv420p"));
+ (norm == PAL ? "yuv420p" : "yuv411p"));
opt_frame_rate(NULL, frame_rates[norm]);
audio_sample_rate = 48000;
{ "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
{ "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
"add timings for benchmarking" },
+ { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
{ "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
"dump each input packet" },
{ "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
{ "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
{ "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
{ "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
+ { "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" },
/* parse options */
parse_options(argc, argv, options, opt_output_file);
- if(nb_output_files <= 0 && nb_input_files == 0)
- show_help();
+ if(nb_output_files <= 0 && nb_input_files == 0) {
+ show_usage();
+ fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
+ av_exit(1);
+ }
/* file converter / grab */
if (nb_output_files <= 0) {