static int64_t timer_start;
+static uint8_t *audio_buf;
+static uint8_t *audio_out;
+static uint8_t *audio_out2;
+
+static short *samples;
+
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
powerpc_display_perf_report();
#endif /* CONFIG_POWERPC_PERF */
+ for (i=0;i<CODEC_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);
+ av_free(samples);
+
if (received_sigterm) {
fprintf(stderr,
"Received signal %d: terminating.\n",
unsigned char *buf, int size)
{
uint8_t *buftmp;
- static uint8_t *audio_buf = NULL;
- static uint8_t *audio_out = NULL;
- static uint8_t *audio_out2 = NULL;
const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
int size_out, frame_bytes, ret;
{
char buf[1024];
AVOutputStream *ost;
- AVFormatContext *oc, *os;
+ AVFormatContext *oc;
int64_t total_size;
AVCodecContext *enc;
int frame_number, vid, i;
vid = 0;
for(i=0;i<nb_ostreams;i++) {
ost = ost_table[i];
- os = output_files[ost->file_index];
enc = ost->st->codec;
if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
{
AVFormatContext *os;
AVOutputStream *ost;
- uint8_t *ptr;
- int len, ret, i;
+ int ret, i;
uint8_t *data_buf;
int data_size, got_picture;
AVFrame picture;
void *buffer_to_free;
static unsigned int samples_size= 0;
- static short *samples= NULL;
AVSubtitle subtitle, *subtitle_to_free;
int got_subtitle;
+ AVPacket avpkt;
if(ist->next_pts == AV_NOPTS_VALUE)
ist->next_pts= ist->pts;
if (pkt == NULL) {
/* EOF handling */
- ptr = NULL;
- len = 0;
+ av_init_packet(&avpkt);
+ avpkt.data = NULL;
+ avpkt.size = 0;
goto handle_eof;
+ } else {
+ avpkt = *pkt;
}
if(pkt->dts != AV_NOPTS_VALUE)
ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
- len = pkt->size;
- ptr = pkt->data;
-
//while we have more to decode or while the decoder did output something on EOF
- while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
+ while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
handle_eof:
ist->pts= ist->next_pts;
- if(len && len != pkt->size && verbose>0)
+ if(avpkt.size && avpkt.size != pkt->size && verbose>0)
fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
/* decode the packet if needed */
data_size= samples_size;
/* XXX: could avoid copy if PCM 16 bits with same
endianness as CPU */
- ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
- ptr, len);
+ ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
+ &avpkt);
if (ret < 0)
goto fail_decode;
- ptr += ret;
- len -= ret;
+ avpkt.data += ret;
+ avpkt.size -= ret;
/* Some bug in mpeg audio decoder gives */
/* data_size < 0, it seems they are overflows */
if (data_size <= 0) {
/* XXX: allocate picture correctly */
avcodec_get_frame_defaults(&picture);
- ret = avcodec_decode_video(ist->st->codec,
- &picture, &got_picture, ptr, len);
+ ret = avcodec_decode_video2(ist->st->codec,
+ &picture, &got_picture, &avpkt);
ist->st->quality= picture.quality;
if (ret < 0)
goto fail_decode;
ist->st->codec->time_base.num * ticks) /
ist->st->codec->time_base.den;
}
- len = 0;
+ avpkt.size = 0;
break;
case CODEC_TYPE_SUBTITLE:
- ret = avcodec_decode_subtitle(ist->st->codec,
- &subtitle, &got_subtitle, ptr, len);
+ ret = avcodec_decode_subtitle2(ist->st->codec,
+ &subtitle, &got_subtitle, &avpkt);
if (ret < 0)
goto fail_decode;
if (!got_subtitle) {
goto discard_packet;
}
subtitle_to_free = &subtitle;
- len = 0;
+ avpkt.size = 0;
break;
default:
goto fail_decode;
}
break;
}
- data_buf = ptr;
- data_size = len;
- ret = len;
- len = 0;
+ data_buf = avpkt.data;
+ data_size = avpkt.size;
+ ret = avpkt.size;
+ avpkt.size = 0;
}
buffer_to_free = NULL;
} else {
AVFrame avframe; //FIXME/XXX remove this
AVPacket opkt;
+ int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
+
av_init_packet(&opkt);
if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
opkt.stream_index= ost->index;
if(pkt->pts != AV_NOPTS_VALUE)
- opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
+ opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
else
opkt.pts= AV_NOPTS_VALUE;
opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
else
opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
+ opkt.dts -= ost_tb_start_time;
opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
opkt.flags= pkt->flags;
ret = 0;
/* encode any samples remaining in fifo */
if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
+ int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
int fs_tmp = enc->frame_size;
- enc->frame_size = fifo_bytes / (2 * enc->channels);
+ enc->frame_size = fifo_bytes / (osize * enc->channels);
av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
- ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
+ ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
+ pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
+ ost->st->time_base.num, enc->sample_rate);
enc->frame_size = fs_tmp;
}
if(ret <= 0) {
/* init pts */
for(i=0;i<nb_istreams;i++) {
ist = ist_table[i];
- is = input_files[ist->file_index];
ist->pts = 0;
ist->next_pts = AV_NOPTS_VALUE;
ist->is_start = 1;
}
term_init();
- key = -1;
timer_start = av_gettime();
for(; received_sigterm == 0;) {
/* read a frame from it and output it in the fifo */
is = input_files[file_index];
ret= av_read_frame(is, &pkt);
- if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm")){
+ if(ret == AVERROR(EAGAIN)){
no_packet[file_index]=1;
no_packet_count++;
continue;
return 0;
}
+static void 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);
+}
+
static int opt_verbose(const char *opt, const char *arg)
{
verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
- av_log_set_level(verbose);
return 0;
}
static void opt_frame_pix_fmt(const char *arg)
{
- if (strcmp(arg, "list"))
+ if (strcmp(arg, "list")) {
frame_pix_fmt = avcodec_get_pix_fmt(arg);
- else {
+ 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);
av_exit(0);
}
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;
filename[1] == ':' ||
av_strstart(filename, "file:", NULL))) {
if (url_exist(filename)) {
- int c;
-
if (!using_stdin) {
fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
fflush(stderr);
- c = getchar();
- if (toupper(c) != 'Y') {
+ if (!read_yesno()) {
fprintf(stderr, "Not overwriting - exiting\n");
av_exit(1);
}
{ "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
{ "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 the logging verbosity level", "number" },
+ { "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" },
{ "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", "" },