#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];
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 {
{
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; //safety factors for the deprecated resampling API
audio_buf_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);
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 */
decoded_data_buf = NULL; /* fail safe */
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( 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 {
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 (av_compare_ts(pkt.pts, ist->st->time_base, recording_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) {
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) {
for(i=0;i<ic->nb_streams;i++) {
AVStream *st = ic->streams[i];
AVCodecContext *enc = st->codec;
- if(thread_count>1)
- avcodec_thread_init(enc, thread_count);
+ 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);
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;
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;
projects / ffmpeg / blobdiff