#include "libavcodec/audioconvert.h"
#include "libavcodec/colorspace.h"
#include "libavutil/fifo.h"
+#include "libavutil/pixdesc.h"
#include "libavutil/avstring.h"
+#include "libavutil/libm.h"
#include "libavformat/os_support.h"
#if HAVE_SYS_RESOURCE_H
#include <sys/types.h>
+#include <sys/time.h>
#include <sys/resource.h>
#elif HAVE_GETPROCESSTIMES
#include <windows.h>
#endif
+#if HAVE_GETPROCESSMEMORYINFO
+#include <windows.h>
+#include <psapi.h>
+#endif
#if HAVE_SYS_SELECT_H
#include <sys/select.h>
#elif HAVE_CONIO_H
#include <conio.h>
#endif
-#undef time //needed because HAVE_AV_CONFIG_H is defined on top
#include <time.h>
#include "cmdutils.h"
#undef NDEBUG
#include <assert.h>
-#undef exit
-
const char program_name[] = "FFmpeg";
const int program_birth_year = 2000;
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 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 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;
static uint8_t *audio_buf;
static uint8_t *audio_out;
-static uint8_t *audio_out2;
+unsigned int allocated_audio_out_size, allocated_audio_buf_size;
static short *samples;
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;
+ int is_past_recording_time;
} AVInputStream;
typedef struct AVInputFile {
tcgetattr (0, &tty);
oldtty = tty;
+ atexit(term_exit);
tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
|INLCR|IGNCR|ICRNL|IXON);
signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
- /*
- register a function to be called at normal program termination
- */
- atexit(term_exit);
+#ifdef SIGXCPU
+ signal(SIGXCPU, sigterm_handler);
+#endif
+
#if CONFIG_BEOS_NETSERVER
fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
#endif
powerpc_display_perf_report();
#endif /* CONFIG_POWERPC_PERF */
- for (i=0;i<CODEC_TYPE_NB;i++)
+ for (i=0;i<AVMEDIA_TYPE_NB;i++)
av_free(avcodec_opts[i]);
av_free(avformat_opts);
av_free(sws_opts);
av_free(audio_buf);
av_free(audio_out);
- av_free(audio_out2);
+ allocated_audio_buf_size= allocated_audio_out_size= 0;
av_free(samples);
if (received_sigterm) {
return ret;
}
+static void choose_sample_fmt(AVStream *st, AVCodec *codec)
+{
+ if(codec && codec->sample_fmts){
+ const enum SampleFormat *p= codec->sample_fmts;
+ for(; *p!=-1; p++){
+ if(*p == st->codec->sample_fmt)
+ break;
+ }
+ if(*p == -1)
+ st->codec->sample_fmt = codec->sample_fmts[0];
+ }
+}
+
+static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
+{
+ if(codec && codec->pix_fmts){
+ const enum PixelFormat *p= codec->pix_fmts;
+ for(; *p!=-1; p++){
+ if(*p == st->codec->pix_fmt)
+ break;
+ }
+ if(*p == -1
+ && !( st->codec->codec_id==CODEC_ID_MJPEG
+ && st->codec->strict_std_compliance <= FF_COMPLIANCE_INOFFICIAL
+ && ( st->codec->pix_fmt == PIX_FMT_YUV420P
+ || st->codec->pix_fmt == PIX_FMT_YUV422P)))
+ st->codec->pix_fmt = codec->pix_fmts[0];
+ }
+}
+
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
{
int i, err;
s->nb_streams = ic->nb_streams;
for(i=0;i<ic->nb_streams;i++) {
AVStream *st;
+ AVCodec *codec;
// FIXME: a more elegant solution is needed
st = av_mallocz(sizeof(AVStream));
print_error(filename, AVERROR(ENOMEM));
av_exit(1);
}
- memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
+ avcodec_copy_context(st->codec, ic->streams[i]->codec);
s->streams[i] = st;
- if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
- st->stream_copy = 1;
- else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
- st->stream_copy = 1;
+ codec = avcodec_find_encoder(st->codec->codec_id);
+ 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->thread_count)
st->codec->thread_count = 1;
int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
&new_pkt.data, &new_pkt.size,
pkt->data, pkt->size,
- pkt->flags & PKT_FLAG_KEY);
+ pkt->flags & AV_PKT_FLAG_KEY);
if(a>0){
av_free_packet(pkt);
new_pkt.destruct= av_destruct_packet;
unsigned char *buf, int size)
{
uint8_t *buftmp;
- const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
+ 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;
AVCodecContext *dec= ist->st->codec;
int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
+ const int coded_bps = av_get_bits_per_sample(enc->codec->id);
+
+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; //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);
+ if(coded_bps > 8*osize)
+ audio_out_size= audio_out_size * coded_bps / (8*osize);
+ audio_out_size += FF_MIN_BUFFER_SIZE;
- /* SC: dynamic allocation of buffers */
- if (!audio_buf)
- audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
- if (!audio_out)
- audio_out = av_malloc(audio_out_size);
- if (!audio_buf || !audio_out)
- return; /* Should signal an error ! */
+ if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
+ fprintf(stderr, "Buffer sizes too large\n");
+ av_exit(1);
+ }
+
+ av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
+ av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
+ if (!audio_buf || !audio_out){
+ fprintf(stderr, "Out of memory in do_audio_out\n");
+ av_exit(1);
+ }
if (enc->channels != dec->channels)
ost->audio_resample = 1;
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
- if (!audio_out2)
- audio_out2 = av_malloc(audio_out_size);
- if (!audio_out2)
- av_exit(1);
if (ost->reformat_ctx)
av_audio_convert_free(ost->reformat_ctx);
ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
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 (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
const void *ibuf[6]= {buftmp};
- void *obuf[6]= {audio_out2};
+ void *obuf[6]= {audio_buf};
int istride[6]= {isize};
int ostride[6]= {osize};
int len= size_out/istride[0];
av_exit(1);
return;
}
- buftmp = audio_out2;
+ buftmp = audio_buf;
size_out = len*osize;
}
pkt.size= ret;
if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
ost->sync_opts += enc->frame_size;
}
} else {
AVPacket pkt;
- int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
av_init_packet(&pkt);
ost->sync_opts += size_out / (osize * enc->channels);
/* determine the size of the coded buffer */
size_out /= osize;
if (coded_bps)
- size_out *= coded_bps;
+ size_out = size_out*coded_bps/8;
+
+ if(size_out > audio_out_size){
+ fprintf(stderr, "Internal error, buffer size too small\n");
+ av_exit(1);
+ }
//FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
ret = avcodec_encode_audio(enc, audio_out, size_out,
pkt.size= ret;
if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
}
}
AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
AVFrame picture_crop_temp, picture_pad_temp;
AVCodecContext *enc, *dec;
+ double sync_ipts;
avcodec_get_frame_defaults(&picture_crop_temp);
avcodec_get_frame_defaults(&picture_pad_temp);
enc = ost->st->codec;
dec = ist->st->codec;
+ sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
+
/* by default, we output a single frame */
nb_frames = 1;
*frame_size = 0;
- if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
- double vdelta;
- vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
+ if(video_sync_method){
+ double vdelta = sync_ipts - ost->sync_opts;
//FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
if (vdelta < -1.1)
nb_frames = 0;
if(vdelta<=-0.6){
nb_frames=0;
}else if(vdelta>0.6)
- ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
+ ost->sync_opts= lrintf(sync_ipts);
}else if (vdelta > 1.1)
nb_frames = lrintf(vdelta);
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
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);
}
}else
- ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
+ ost->sync_opts= lrintf(sync_ipts);
- nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
+ nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
if (nb_frames <= 0)
return;
}
}
+ 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));
+ if(!ost->video_resample)
+ av_exit(1);
+ }
+
if (ost->video_resample) {
padding_src = NULL;
final_picture = &ost->pict_tmp;
|| (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;
pkt.data= (uint8_t *)final_picture;
pkt.size= sizeof(AVPicture);
pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
enc->coded_frame = old_frame;
/* better than nothing: use input picture interlaced
settings */
big_picture.interlaced_frame = in_picture->interlaced_frame;
- if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
+ if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
if(top_field_first == -1)
big_picture.top_field_first = in_picture->top_field_first;
else
pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
if(enc->coded_frame->key_frame)
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
*frame_size = ret;
video_size += ret;
}
enc = ost->st->codec;
- if (enc->codec_type == CODEC_TYPE_VIDEO) {
+ if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
frame_number = ost->frame_number;
fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
if (enc->flags&CODEC_FLAG_PSNR)
for(i=0;i<nb_ostreams;i++) {
ost = ost_table[i];
enc = ost->st->codec;
- if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
+ if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
!ost->st->stream_copy ?
enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
}
- if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
+ if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
float t = (av_gettime()-timer_start) / 1000000.0;
frame_number = ost->frame_number;
"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;
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;
//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 && verbose>0)
+ if(avpkt.size && avpkt.size != pkt->size &&
+ ((!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) {
- case CODEC_TYPE_AUDIO:{
+ case AVMEDIA_TYPE_AUDIO:{
if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
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/2 * 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;
+ case AVMEDIA_TYPE_VIDEO:
+ decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
/* XXX: allocate picture correctly */
avcodec_get_frame_defaults(&picture);
}
avpkt.size = 0;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
ret = avcodec_decode_subtitle2(ist->st->codec,
&subtitle, &got_subtitle, &avpkt);
if (ret < 0)
}
} else {
switch(ist->st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
ist->st->codec->sample_rate;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
if (ist->st->codec->time_base.num != 0) {
int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
ist->next_pts += ((int64_t)AV_TIME_BASE *
}
break;
}
- data_buf = avpkt.data;
- data_size = avpkt.size;
ret = avpkt.size;
avpkt.size = 0;
}
buffer_to_free = NULL;
- if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
pre_process_video_frame(ist, (AVPicture *)&picture,
&buffer_to_free);
}
// preprocess audio (volume)
- if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
+ if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
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);
+ case AVMEDIA_TYPE_AUDIO:
+ do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
do_video_out(os, ost, ist, &picture, &frame_size);
if (vstats_filename && frame_size)
do_video_stats(os, ost, frame_size);
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
do_subtitle_out(os, ost, ist, &subtitle,
pkt->pts);
break;
av_init_packet(&opkt);
- if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
+ if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
continue;
/* no reencoding needed : output the packet directly */
avcodec_get_frame_defaults(&avframe);
ost->st->codec->coded_frame= &avframe;
- avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
+ avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
- if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
+ if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
audio_size += data_size;
- else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
+ else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
video_size += data_size;
ost->sync_opts++;
}
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 & AV_PKT_FLAG_KEY))
+ opkt.destruct= av_destruct_packet;
} else {
opkt.data = data_buf;
opkt.size = data_size;
AVCodecContext *enc= ost->st->codec;
os = output_files[ost->file_index];
- if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
+ if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
continue;
- if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
+ if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
continue;
if (ost->encoding_needed) {
pkt.stream_index= ost->index;
switch(ost->st->codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
fifo_bytes = av_fifo_size(ost->fifo);
ret = 0;
/* encode any samples remaining in fifo */
av_exit(1);
}
audio_size += ret;
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
if (ret < 0) {
fprintf(stderr, "Video encoding failed\n");
}
video_size += ret;
if(enc->coded_frame && enc->coded_frame->key_frame)
- pkt.flags |= PKT_FLAG_KEY;
+ pkt.flags |= AV_PKT_FLAG_KEY;
if (ost->logfile && enc->stats_out) {
fprintf(ost->logfile, "%s", enc->stats_out);
}
fflush(stdout);
}
-static int stream_index_from_inputs(AVFormatContext **input_files,
- int nb_input_files,
- AVInputFile *file_table,
- AVInputStream **ist_table,
- enum CodecType type,
- int programid)
+static int copy_chapters(int infile, int outfile)
{
- int p, q, z;
- for(z=0; z<nb_input_files; z++) {
- AVFormatContext *ic = input_files[z];
- for(p=0; p<ic->nb_programs; p++) {
- AVProgram *program = ic->programs[p];
- if(program->id != programid)
- continue;
- for(q=0; q<program->nb_stream_indexes; q++) {
- int sidx = program->stream_index[q];
- int ris = file_table[z].ist_index + sidx;
- if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
- return ris;
- }
- }
- }
+ AVFormatContext *is = input_files[infile];
+ AVFormatContext *os = output_files[outfile];
+ int i;
- return -1;
+ for (i = 0; i < is->nb_chapters; i++) {
+ AVChapter *in_ch = is->chapters[i], *out_ch;
+ AVMetadataTag *t = NULL;
+ int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
+ 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);
+
+ while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
+ av_metadata_set2(&out_ch->metadata, t->key, t->value, 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;
}
/*
* The following code is the main loop of the file converter
*/
-static int av_encode(AVFormatContext **output_files,
- int nb_output_files,
- AVFormatContext **input_files,
- int nb_input_files,
- AVStreamMap *stream_maps, int nb_stream_maps)
+static int av_transcode(AVFormatContext **output_files,
+ int nb_output_files,
+ AVFormatContext **input_files,
+ int nb_input_files,
+ AVStreamMap *stream_maps, int nb_stream_maps)
{
int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
AVFormatContext *is, *os;
}
} else {
- if(opt_programid) {
- found = 0;
- j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
- if(j != -1) {
- ost->source_index = j;
- found = 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_istreams;j++) {
+ int skip=0;
ist = ist_table[j];
- if (ist->discard &&
+ if(opt_programid){
+ int pi,si;
+ AVFormatContext *f= input_files[ ist->file_index ];
+ 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) {
- ost->source_index = j;
- found = 1;
- break;
+ 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_istreams;j++) {
ist = ist_table[j];
- if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
+ if ( ist->st->codec->codec_type == ost->st->codec->codec_type
+ && ist->st->discard != AVDISCARD_ALL) {
ost->source_index = j;
found = 1;
}
/* for each output stream, we compute the right encoding parameters */
for(i=0;i<nb_ostreams;i++) {
- AVMetadataTag *lang;
+ AVMetadataTag *t = NULL, *lang = NULL;
ost = ost_table[i];
os = output_files[ost->file_index];
ist = ist_table[ost->source_index];
codec = ost->st->codec;
icodec = ist->st->codec;
- if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
- && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
- av_metadata_set(&ost->st->metadata, "language", lang->value);
+ if (av_metadata_get(ist->st->metadata, "language", NULL, 0))
+ lang = av_metadata_get(ost->st->metadata, "language", NULL, 0);
+ while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
+ if (lang && !strcmp(t->key, "language"))
+ continue;
+ av_metadata_set2(&ost->st->metadata, t->key, t->value, 0);
+ }
ost->st->disposition = ist->st->disposition;
codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
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;
}
}else
codec->time_base = ist->st->time_base;
switch(codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
if(audio_volume != 256) {
fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
av_exit(1);
if(codec->codec_id == CODEC_ID_AC3)
codec->block_align= 0;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
codec->pix_fmt = icodec->pix_fmt;
codec->width = icodec->width;
codec->height = icodec->height;
codec->has_b_frames = icodec->has_b_frames;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
codec->width = icodec->width;
codec->height = icodec->height;
break;
}
} else {
switch(codec->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
ost->fifo= av_fifo_alloc(1024);
if(!ost->fifo)
goto fail;
ist->decoding_needed = 1;
ost->encoding_needed = 1;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
- fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
+ fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
av_exit(1);
}
ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
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->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
+ ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
+ ost->resample_pix_fmt= icodec->pix_fmt;
ost->encoding_needed = 1;
ist->decoding_needed = 1;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
ost->encoding_needed = 1;
ist->decoding_needed = 1;
break;
(codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
char logfilename[1024];
FILE *f;
- int size;
- char *logbuffer;
snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
}
ost->logfile = f;
} else {
- /* read the log file */
- f = fopen(logfilename, "r");
- if (!f) {
- fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
- av_exit(1);
- }
- fseek(f, 0, SEEK_END);
- size = ftell(f);
- fseek(f, 0, SEEK_SET);
- logbuffer = av_malloc(size + 1);
- if (!logbuffer) {
- fprintf(stderr, "Could not allocate log buffer\n");
+ char *logbuffer;
+ size_t logbuffer_size;
+ if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
+ fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
av_exit(1);
}
- size = fread(logbuffer, 1, size, f);
- fclose(f);
- logbuffer[size] = '\0';
codec->stats_in = logbuffer;
}
}
}
- if(codec->codec_type == CODEC_TYPE_VIDEO){
+ if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
int size= codec->width * codec->height;
bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
}
ret = AVERROR(EINVAL);
goto dump_format;
}
- //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
+ //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
// ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
}
}
/* init pts */
for(i=0;i<nb_istreams;i++) {
+ AVStream *st;
ist = ist_table[i];
- ist->pts = 0;
+ st= ist->st;
+ ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
ist->next_pts = AV_NOPTS_VALUE;
ist->is_start = 1;
}
in_file->iformat->metadata_conv);
}
+ /* copy chapters from the first input file that has them*/
+ for (i = 0; i < nb_input_files; i++) {
+ if (!input_files[i]->nb_chapters)
+ continue;
+
+ for (j = 0; j < nb_output_files; j++)
+ if ((ret = copy_chapters(i, j)) < 0)
+ goto dump_format;
+ }
+
/* open files and write file headers */
for(i=0;i<nb_output_files;i++) {
os = output_files[i];
ost = ost_table[i];
os = output_files[ost->file_index];
ist = ist_table[ost->source_index];
- if(no_packet[ist->file_index])
+ if(ist->is_past_recording_time || 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){
break;
}
- /* finish if recording time exhausted */
- if (opts_min >= (recording_time / 1000000.0))
- break;
-
/* finish if limit size exhausted */
if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
break;
}
}
+ /* finish if recording time exhausted */
+ if (recording_time != INT64_MAX &&
+ av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
+ ist->is_past_recording_time = 1;
+ 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) {
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)
static int opt_bitrate(const char *opt, const char *arg)
{
- int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
+ int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
opt_default(opt, arg);
fprintf(stderr, "Incorrect frame size\n");
av_exit(1);
}
- if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
- fprintf(stderr, "Frame size must be a multiple of 2\n");
- av_exit(1);
- }
}
static void opt_pad_color(const char *arg) {
}
}
-static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
-{
- int i;
- char fmt_str[128];
- for (i=-1; i < nb_fmts; i++) {
- get_fmt_string (fmt_str, sizeof(fmt_str), i);
- fprintf(stdout, "%s\n", fmt_str);
- }
-}
-
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);
}
}
static void opt_audio_codec(const char *arg)
{
- opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
+ opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
}
static void opt_audio_tag(const char *arg)
static void opt_video_codec(const char *arg)
{
- opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
+ opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
}
static void opt_subtitle_codec(const char *arg)
{
- opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
+ opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
}
static void opt_subtitle_tag(const char *arg)
{
AVFormatContext *ic;
AVFormatParameters params, *ap = ¶ms;
+ AVInputFormat *file_iformat = NULL;
int err, i, ret, rfps, rfps_base;
int64_t timestamp;
+ if (last_asked_format) {
+ if (!(file_iformat = av_find_input_format(last_asked_format))) {
+ fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
+ av_exit(1);
+ }
+ last_asked_format = NULL;
+ }
+
if (!strcmp(filename, "-"))
filename = "pipe:";
// 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->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
- ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
- ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 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;
+ 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) {
av_exit(1);
}
if(opt_programid) {
- int i;
- for(i=0; i<ic->nb_programs; i++)
- if(ic->programs[i]->id != opt_programid)
- ic->programs[i]->discard = AVDISCARD_ALL;
+ int i, j;
+ int found=0;
+ for(i=0; i<ic->nb_streams; i++){
+ ic->streams[i]->discard= AVDISCARD_ALL;
+ }
+ for(i=0; i<ic->nb_programs; i++){
+ AVProgram *p= ic->programs[i];
+ if(p->id != opt_programid){
+ p->discard = AVDISCARD_ALL;
+ }else{
+ found=1;
+ for(j=0; j<p->nb_stream_indexes; j++){
+ ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
+ }
+ }
+ }
+ if(!found){
+ fprintf(stderr, "Specified program id not found\n");
+ av_exit(1);
+ }
+ opt_programid=0;
}
ic->loop_input = loop_input;
/* 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);
+ case AVMEDIA_TYPE_AUDIO:
+ set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
//fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
channel_layout = enc->channel_layout;
audio_channels = enc->channels;
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);
+ case AVMEDIA_TYPE_VIDEO:
+ set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
frame_height = enc->height;
frame_width = enc->width;
if(ic->streams[i]->sample_aspect_ratio.num)
frame_pix_fmt = enc->pix_fmt;
rfps = ic->streams[i]->r_frame_rate.num;
rfps_base = ic->streams[i]->r_frame_rate.den;
- if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
+ if(enc->lowres) {
+ enc->flags |= CODEC_FLAG_EMU_EDGE;
+ frame_height >>= enc->lowres;
+ frame_width >>= enc->lowres;
+ }
if(me_threshold)
enc->debug |= FF_DEBUG_MV;
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:
+ case AVMEDIA_TYPE_DATA:
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_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:
+ case AVMEDIA_TYPE_ATTACHMENT:
+ case AVMEDIA_TYPE_UNKNOWN:
nb_icodecs++;
break;
default:
dump_format(ic, nb_input_files, filename, 0);
nb_input_files++;
- file_iformat = NULL;
- file_oformat = NULL;
video_channel = 0;
for(i=0;i<ic->nb_streams;i++) {
AVCodecContext *enc = ic->streams[i]->codec;
switch(enc->codec_type) {
- case CODEC_TYPE_AUDIO:
+ case AVMEDIA_TYPE_AUDIO:
has_audio = 1;
break;
- case CODEC_TYPE_VIDEO:
+ case AVMEDIA_TYPE_VIDEO:
has_video = 1;
break;
- case CODEC_TYPE_SUBTITLE:
+ case AVMEDIA_TYPE_SUBTITLE:
has_subtitle = 1;
break;
- case CODEC_TYPE_DATA:
- case CODEC_TYPE_ATTACHMENT:
- case CODEC_TYPE_UNKNOWN:
+ case AVMEDIA_TYPE_DATA:
+ case AVMEDIA_TYPE_ATTACHMENT:
+ case AVMEDIA_TYPE_UNKNOWN:
break;
default:
abort();
fprintf(stderr, "Could not alloc stream\n");
av_exit(1);
}
- avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
+ avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
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( (video_global_header&1)
|| (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
+ avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
}
if(video_global_header&2){
video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
- avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
+ avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
}
if (video_stream_copy) {
st->stream_copy = 1;
- video_enc->codec_type = CODEC_TYPE_VIDEO;
+ video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
video_enc->sample_aspect_ratio =
st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
} else {
AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
if (video_codec_name) {
- codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
+ codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
codec = avcodec_find_encoder_by_name(video_codec_name);
output_codecs[nb_ocodecs] = codec;
} else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
codec = avcodec_find_encoder(codec_id);
}
video_enc->codec_id = codec_id;
- set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
+ set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
if (codec && codec->supported_framerates && !force_fps)
fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
video_enc->pix_fmt = frame_pix_fmt;
st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
- if(codec && codec->pix_fmts){
- const enum PixelFormat *p= codec->pix_fmts;
- for(; *p!=-1; p++){
- if(*p == video_enc->pix_fmt)
- break;
- }
- if(*p == -1)
- video_enc->pix_fmt = codec->pix_fmts[0];
- }
+ choose_pixel_fmt(st, codec);
if (intra_only)
video_enc->gop_size = 0;
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;
av_freep(&video_codec_name);
video_stream_copy = 0;
+ frame_pix_fmt = PIX_FMT_NONE;
}
static void new_audio_stream(AVFormatContext *oc)
fprintf(stderr, "Could not alloc stream\n");
av_exit(1);
}
- avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
+ avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
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->codec_type = AVMEDIA_TYPE_AUDIO;
if(audio_codec_tag)
audio_enc->codec_tag= audio_codec_tag;
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
+ avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
}
if (audio_stream_copy) {
st->stream_copy = 1;
} else {
AVCodec *codec;
- set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
+ set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
if (audio_codec_name) {
- codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
+ codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
codec = avcodec_find_encoder_by_name(audio_codec_name);
output_codecs[nb_ocodecs] = codec;
} else {
- codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
codec = avcodec_find_encoder(codec_id);
}
audio_enc->codec_id = codec_id;
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;
if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
audio_enc->channel_layout = 0;
-
- if(codec && codec->sample_fmts){
- const enum SampleFormat *p= codec->sample_fmts;
- for(; *p!=-1; p++){
- if(*p == audio_enc->sample_fmt)
- break;
- }
- if(*p == -1)
- audio_enc->sample_fmt = codec->sample_fmts[0];
- }
+ choose_sample_fmt(st, codec);
}
nb_ocodecs++;
audio_enc->sample_rate = audio_sample_rate;
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 */
fprintf(stderr, "Could not alloc stream\n");
av_exit(1);
}
- avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
+ avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
subtitle_bitstream_filters= NULL;
subtitle_enc = st->codec;
- subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
+ subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
if(subtitle_codec_tag)
subtitle_enc->codec_tag= subtitle_codec_tag;
if (subtitle_stream_copy) {
st->stream_copy = 1;
} else {
- set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
- subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
+ set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
+ subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
}
nb_ocodecs++;
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;
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:";
av_exit(1);
}
- if (!file_oformat) {
- file_oformat = guess_format(NULL, filename, NULL);
+ if (last_asked_format) {
+ 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 = av_guess_format(NULL, filename, NULL);
if (!file_oformat) {
fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
filename);
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 */
#endif
}
+static int64_t getmaxrss(void)
+{
+#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
+ struct rusage rusage;
+ getrusage(RUSAGE_SELF, &rusage);
+ return (int64_t)rusage.ru_maxrss * 1024;
+#elif HAVE_GETPROCESSMEMORYINFO
+ HANDLE proc;
+ PROCESS_MEMORY_COUNTERS memcounters;
+ proc = GetCurrentProcess();
+ memcounters.cb = sizeof(memcounters);
+ GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
+ return memcounters.PeakPagefileUsage;
+#else
+ return 0;
+#endif
+}
+
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
{
int i;
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) {
for(j = 0; j < nb_input_files; j++) {
for(i = 0; i < input_files[j]->nb_streams; i++) {
AVCodecContext *c = input_files[j]->streams[i]->codec;
- if(c->codec_type != CODEC_TYPE_VIDEO)
+ if(c->codec_type != AVMEDIA_TYPE_VIDEO)
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;
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");
}
static const OptionDef options[] = {
/* main options */
- { "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, ..." },
+#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" },
{ "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
{ "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
{ "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
- { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
+ { "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},
"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},
{ "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", "logging level number or string" },
{ "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", "" },
/* video options */
{ "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
{ "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
- { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
+ { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
{ "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
{ "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
{ "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
{ "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" },
/* audio options */
{ "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
- { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
+ { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
{ "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
{ "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
{ "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
{ "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 from indicated preset file", "filename" },
{ "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
{ NULL, },
url_set_interrupt_cb(decode_interrupt_cb);
#endif
- for(i=0; i<CODEC_TYPE_NB; i++){
+ for(i=0; i<AVMEDIA_TYPE_NB; i++){
avcodec_opts[i]= avcodec_alloc_context2(i);
}
avformat_opts = avformat_alloc_context();
/* parse options */
parse_options(argc, argv, options, opt_output_file);
+ 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) {
fprintf(stderr, "At least one output file must be specified\n");
}
ti = getutime();
- if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
- stream_maps, nb_stream_maps) < 0)
+ if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
+ stream_maps, nb_stream_maps) < 0)
av_exit(1);
ti = getutime() - ti;
if (do_benchmark) {
- printf("bench: utime=%0.3fs\n", ti / 1000000.0);
+ int maxrss = getmaxrss() / 1024;
+ printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
}
return av_exit(0);