#undef NDEBUG
#include <assert.h>
-AVInputFormat *first_iformat;
-AVOutputFormat *first_oformat;
-AVImageFormat *first_image_format;
+/**
+ * @file libavformat/utils.c
+ * Various utility functions for using ffmpeg library.
+ */
+
+/** head of registered input format linked list. */
+AVInputFormat *first_iformat = NULL;
+/** head of registered output format linked list. */
+AVOutputFormat *first_oformat = NULL;
+/** head of registered image format linked list. */
+AVImageFormat *first_image_format = NULL;
void av_register_input_format(AVInputFormat *format)
{
p = extensions;
for(;;) {
q = ext1;
- while (*p != '\0' && *p != ',')
+ while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
*q++ = *p++;
*q = '\0';
if (!strcasecmp(ext1, ext))
int score_max, score;
/* specific test for image sequences */
+ if (!short_name && filename &&
+ filename_number_test(filename) >= 0 &&
+ av_guess_image2_codec(filename) != CODEC_ID_NONE) {
+ return guess_format("image2", NULL, NULL);
+ }
if (!short_name && filename &&
filename_number_test(filename) >= 0 &&
guess_image_format(filename)) {
return fmt;
}
+/**
+ * Guesses the codec id based upon muxer and filename.
+ */
+enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
+ const char *filename, const char *mime_type, enum CodecType type){
+ if(type == CODEC_TYPE_VIDEO){
+ enum CodecID codec_id= CODEC_ID_NONE;
+
+ if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
+ codec_id= av_guess_image2_codec(filename);
+ }
+ if(codec_id == CODEC_ID_NONE)
+ codec_id= fmt->video_codec;
+ return codec_id;
+ }else if(type == CODEC_TYPE_AUDIO)
+ return fmt->audio_codec;
+ else
+ return CODEC_ID_NONE;
+}
+
+/**
+ * finds AVInputFormat based on input format's short name.
+ */
AVInputFormat *av_find_input_format(const char *short_name)
{
AVInputFormat *fmt;
/* memory handling */
/**
- * Default packet destructor
+ * Default packet destructor.
*/
-static void av_destruct_packet(AVPacket *pkt)
+void av_destruct_packet(AVPacket *pkt)
{
av_free(pkt->data);
pkt->data = NULL; pkt->size = 0;
*/
int av_new_packet(AVPacket *pkt, int size)
{
- void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
+ void *data;
+ if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
+ return AVERROR_NOMEM;
+ data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
if (!data)
return AVERROR_NOMEM;
memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
return 0;
}
+/**
+ * Allocate and read the payload of a packet and intialized its fields to default values.
+ *
+ * @param pkt packet
+ * @param size wanted payload size
+ * @return >0 (read size) if OK. AVERROR_xxx otherwise.
+ */
+int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
+{
+ int ret= av_new_packet(pkt, size);
+
+ if(ret<0)
+ return ret;
+
+ pkt->pos= url_ftell(s);
+
+ ret= get_buffer(s, pkt->data, size);
+ if(ret<=0)
+ av_free_packet(pkt);
+ else
+ pkt->size= ret;
+
+ return ret;
+}
+
/* This is a hack - the packet memory allocation stuff is broken. The
packet is allocated if it was not really allocated */
int av_dup_packet(AVPacket *pkt)
uint8_t *data;
/* we duplicate the packet and don't forget to put the padding
again */
+ if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
+ return AVERROR_NOMEM;
data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
if (!data) {
return AVERROR_NOMEM;
int fifo_size(FifoBuffer *f, uint8_t *rptr)
{
int size;
+
+ if(!rptr)
+ rptr= f->rptr;
if (f->wptr >= rptr) {
size = f->wptr - rptr;
return size;
}
-/* get data from the fifo (return -1 if not enough data) */
+/**
+ * Get data from the fifo (returns -1 if not enough data).
+ */
int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
{
- uint8_t *rptr = *rptr_ptr;
+ uint8_t *rptr;
int size, len;
+ if(!rptr_ptr)
+ rptr_ptr= &f->rptr;
+ rptr = *rptr_ptr;
+
if (f->wptr >= rptr) {
size = f->wptr - rptr;
} else {
return 0;
}
+/**
+ * Resizes a FIFO.
+ */
+void fifo_realloc(FifoBuffer *f, unsigned int new_size){
+ unsigned int old_size= f->end - f->buffer;
+
+ if(old_size < new_size){
+ uint8_t *old= f->buffer;
+
+ f->buffer= av_realloc(f->buffer, new_size);
+
+ f->rptr += f->buffer - old;
+ f->wptr += f->buffer - old;
+
+ if(f->wptr < f->rptr){
+ memmove(f->rptr + new_size - old_size, f->rptr, f->buffer + old_size - f->rptr);
+ f->rptr += new_size - old_size;
+ }
+ f->end= f->buffer + new_size;
+ }
+}
+
void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
{
int len;
uint8_t *wptr;
+
+ if(!wptr_ptr)
+ wptr_ptr= &f->wptr;
wptr = *wptr_ptr;
+
while (size > 0) {
len = f->end - wptr;
if (len > size)
*wptr_ptr = wptr;
}
+/* get data from the fifo (return -1 if not enough data) */
+int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
+{
+ uint8_t *rptr = *rptr_ptr;
+ int size, len;
+
+ if (f->wptr >= rptr) {
+ size = f->wptr - rptr;
+ } else {
+ size = (f->end - rptr) + (f->wptr - f->buffer);
+ }
+
+ if (size < buf_size)
+ return -1;
+ while (buf_size > 0) {
+ len = f->end - rptr;
+ if (len > buf_size)
+ len = buf_size;
+ put_buffer(pb, rptr, len);
+ rptr += len;
+ if (rptr >= f->end)
+ rptr = f->buffer;
+ buf_size -= len;
+ }
+ *rptr_ptr = rptr;
+ return 0;
+}
+
int filename_number_test(const char *filename)
{
char buf[1024];
return get_frame_filename(buf, sizeof(buf), filename, 1);
}
-/* guess file format */
+/**
+ * Guess file format.
+ */
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
{
AVInputFormat *fmt1, *fmt;
/* input media file */
/**
- * open a media file from an IO stream. 'fmt' must be specified.
+ * Open a media file from an IO stream. 'fmt' must be specified.
*/
-
static const char* format_to_name(void* ptr)
{
AVFormatContext* fc = (AVFormatContext*) ptr;
return ic;
}
+/**
+ * Allocates all the structures needed to read an input stream.
+ * This does not open the needed codecs for decoding the stream[s].
+ */
int av_open_input_stream(AVFormatContext **ic_ptr,
ByteIOContext *pb, const char *filename,
AVInputFormat *fmt, AVFormatParameters *ap)
return err;
}
+/** Size of probe buffer, for guessing file type from file contents. */
#define PROBE_BUF_SIZE 2048
/**
must_open_file = 1;
if (fmt && (fmt->flags & AVFMT_NOFILE)) {
must_open_file = 0;
+ pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
}
if (!fmt || must_open_file) {
if (!fmt) {
/* read probe data */
pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
- url_fseek(pb, 0, SEEK_SET);
+ if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
+ url_fclose(pb);
+ if (url_fopen(pb, filename, URL_RDONLY) < 0) {
+ err = AVERROR_IO;
+ goto fail;
+ }
+ }
}
}
/*******************************************************/
/**
- * Read a transport packet from a media file. This function is
- * absolete and should never be used. Use av_read_frame() instead.
+ * Read a transport packet from a media file.
+ *
+ * This function is absolete and should never be used.
+ * Use av_read_frame() instead.
*
* @param s media file handle
* @param pkt is filled
/**********************************************************/
-/* get the number of samples of an audio frame. Return (-1) if error */
+/**
+ * Get the number of samples of an audio frame. Return (-1) if error.
+ */
static int get_audio_frame_size(AVCodecContext *enc, int size)
{
int frame_size;
}
-/* return the frame duration in seconds, return 0 if not available */
+/**
+ * Return the frame duration in seconds, return 0 if not available.
+ */
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
AVCodecParserContext *pc, AVPacket *pkt)
{
*pnum = 0;
*pden = 0;
- switch(st->codec.codec_type) {
+ switch(st->codec->codec_type) {
case CODEC_TYPE_VIDEO:
- *pnum = st->codec.frame_rate_base;
- *pden = st->codec.frame_rate;
- if (pc && pc->repeat_pict) {
- *pden *= 2;
- *pnum = (*pnum) * (2 + pc->repeat_pict);
+ if(st->time_base.num*1000LL > st->time_base.den){
+ *pnum = st->time_base.num;
+ *pden = st->time_base.den;
+ }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
+ *pnum = st->codec->time_base.num;
+ *pden = st->codec->time_base.den;
+ if (pc && pc->repeat_pict) {
+ *pden *= 2;
+ *pnum = (*pnum) * (2 + pc->repeat_pict);
+ }
}
break;
case CODEC_TYPE_AUDIO:
- frame_size = get_audio_frame_size(&st->codec, pkt->size);
+ frame_size = get_audio_frame_size(st->codec, pkt->size);
if (frame_size < 0)
break;
*pnum = frame_size;
- *pden = st->codec.sample_rate;
+ *pden = st->codec->sample_rate;
break;
default:
break;
}
}
+static int is_intra_only(AVCodecContext *enc){
+ if(enc->codec_type == CODEC_TYPE_AUDIO){
+ return 1;
+ }else if(enc->codec_type == CODEC_TYPE_VIDEO){
+ switch(enc->codec_id){
+ case CODEC_ID_MJPEG:
+ case CODEC_ID_MJPEGB:
+ case CODEC_ID_LJPEG:
+ case CODEC_ID_RAWVIDEO:
+ case CODEC_ID_DVVIDEO:
+ case CODEC_ID_HUFFYUV:
+ case CODEC_ID_FFVHUFF:
+ case CODEC_ID_ASV1:
+ case CODEC_ID_ASV2:
+ case CODEC_ID_VCR1:
+ return 1;
+ default: break;
+ }
+ }
+ return 0;
+}
+
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
int64_t delta= last_ts - mask/2;
AVCodecParserContext *pc, AVPacket *pkt)
{
int num, den, presentation_delayed;
-
/* handle wrapping */
if(st->cur_dts != AV_NOPTS_VALUE){
if(pkt->pts != AV_NOPTS_VALUE)
}
}
+ if(is_intra_only(st->codec))
+ pkt->flags |= PKT_FLAG_KEY;
+
/* do we have a video B frame ? */
presentation_delayed = 0;
- if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
+ if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
/* XXX: need has_b_frame, but cannot get it if the codec is
not initialized */
- if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
- st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
- st->codec.codec_id == CODEC_ID_MPEG4 ||
- st->codec.codec_id == CODEC_ID_H264) &&
+ if (( st->codec->codec_id == CODEC_ID_H264
+ || st->codec->has_b_frames) &&
pc && pc->pict_type != FF_B_TYPE)
presentation_delayed = 1;
/* this may be redundant, but it shouldnt hurt */
st->last_IP_pts= pkt->pts;
/* cannot compute PTS if not present (we can compute it only
by knowing the futur */
- } else {
+ } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
+ if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
+ int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
+ int64_t new_diff= ABS(st->cur_dts - pkt->pts);
+ if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
+ pkt->pts += pkt->duration;
+// av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
+ }
+ }
+
/* presentation is not delayed : PTS and DTS are the same */
if (pkt->pts == AV_NOPTS_VALUE) {
if (pkt->dts == AV_NOPTS_VALUE) {
if (pc) {
pkt->flags = 0;
/* key frame computation */
- switch(st->codec.codec_type) {
+ switch(st->codec->codec_type) {
case CODEC_TYPE_VIDEO:
if (pc->pict_type == FF_I_TYPE)
pkt->flags |= PKT_FLAG_KEY;
break;
}
}
-
- /* convert the packet time stamp units */
- if(pkt->pts != AV_NOPTS_VALUE)
- pkt->pts = av_rescale(pkt->pts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
- if(pkt->dts != AV_NOPTS_VALUE)
- pkt->dts = av_rescale(pkt->dts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
-
- /* duration field */
- pkt->duration = av_rescale(pkt->duration, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
}
-static void av_destruct_packet_nofree(AVPacket *pkt)
+void av_destruct_packet_nofree(AVPacket *pkt)
{
pkt->data = NULL; pkt->size = 0;
}
/* select current input stream component */
st = s->cur_st;
if (st) {
- if (!st->parser) {
+ if (!st->need_parsing || !st->parser) {
/* no parsing needed: we just output the packet as is */
/* raw data support */
*pkt = s->cur_pkt;
compute_pkt_fields(s, st, NULL, pkt);
s->cur_st = NULL;
return 0;
- } else if (s->cur_len > 0) {
- len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size,
+ } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
+ len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
s->cur_ptr, s->cur_len,
s->cur_pkt.pts, s->cur_pkt.dts);
s->cur_pkt.pts = AV_NOPTS_VALUE;
/* return the last frames, if any */
for(i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
- if (st->parser) {
- av_parser_parse(st->parser, &st->codec,
+ if (st->parser && st->need_parsing) {
+ av_parser_parse(st->parser, st->codec,
&pkt->data, &pkt->size,
NULL, 0,
AV_NOPTS_VALUE, AV_NOPTS_VALUE);
s->cur_ptr = s->cur_pkt.data;
s->cur_len = s->cur_pkt.size;
if (st->need_parsing && !st->parser) {
- st->parser = av_parser_init(st->codec.codec_id);
+ st->parser = av_parser_init(st->codec->codec_id);
if (!st->parser) {
/* no parser available : just output the raw packets */
st->need_parsing = 0;
}
/**
- * Return the next frame of a stream. The returned packet is valid
+ * Return the next frame of a stream.
+ *
+ * The returned packet is valid
* until the next av_read_frame() or until av_close_input_file() and
* must be freed with av_free_packet. For video, the packet contains
* exactly one frame. For audio, it contains an integer number of
* has B frames, so it is better to rely on pkt->dts if you do not
* decompress the payload.
*
- * Return 0 if OK, < 0 if error or end of file.
+ * @return 0 if OK, < 0 if error or end of file.
*/
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
{
return -1;
for(i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
- if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
+ if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
return i;
}
}
return 0;
}
-/* flush the frame reader */
+/**
+ * Flush the frame reader.
+ */
static void av_read_frame_flush(AVFormatContext *s)
{
AVStream *st;
}
/**
- * add a index entry into a sorted list updateing if it is already there.
+ * Updates cur_dts of all streams based on given timestamp and AVStream.
+ *
+ * Stream ref_st unchanged, others set cur_dts in their native timebase
+ * only needed for timestamp wrapping or if (dts not set and pts!=dts)
+ * @param timestamp new dts expressed in time_base of param ref_st
+ * @param ref_st reference stream giving time_base of param timestamp
+ */
+static void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
+ int i;
+
+ for(i = 0; i < s->nb_streams; i++) {
+ AVStream *st = s->streams[i];
+
+ st->cur_dts = av_rescale(timestamp,
+ st->time_base.den * (int64_t)ref_st->time_base.num,
+ st->time_base.num * (int64_t)ref_st->time_base.den);
+ }
+}
+
+/**
+ * Add a index entry into a sorted list updateing if it is already there.
+ *
* @param timestamp timestamp in the timebase of the given stream
*/
int av_add_index_entry(AVStream *st,
AVIndexEntry *entries, *ie;
int index;
+ if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
+ return -1;
+
entries = av_fast_realloc(st->index_entries,
&st->index_entries_allocated_size,
(st->nb_index_entries + 1) *
sizeof(AVIndexEntry));
+ if(!entries)
+ return -1;
+
st->index_entries= entries;
- if(st->nb_index_entries){
- index= av_index_search_timestamp(st, timestamp);
- ie= &entries[index];
+ index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
- if(ie->timestamp != timestamp){
- if(ie->timestamp < timestamp){
- index++; //index points to next instead of previous entry, maybe nonexistant
- ie= &st->index_entries[index];
- }else
- assert(index==0);
-
- if(index != st->nb_index_entries){
- assert(index < st->nb_index_entries);
- memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
- }
- st->nb_index_entries++;
- }else{
- if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
- distance= ie->min_distance;
- }
- }else{
+ if(index<0){
index= st->nb_index_entries++;
ie= &entries[index];
+ assert(index==0 || ie[-1].timestamp < timestamp);
+ }else{
+ ie= &entries[index];
+ if(ie->timestamp != timestamp){
+ if(ie->timestamp <= timestamp)
+ return -1;
+ memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
+ st->nb_index_entries++;
+ }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
+ distance= ie->min_distance;
}
-
+
ie->pos = pos;
ie->timestamp = timestamp;
ie->min_distance= distance;
return index;
}
-/* build an index for raw streams using a parser */
+/**
+ * build an index for raw streams using a parser.
+ */
static void av_build_index_raw(AVFormatContext *s)
{
AVPacket pkt1, *pkt = &pkt1;
break;
if (pkt->stream_index == 0 && st->parser &&
(pkt->flags & PKT_FLAG_KEY)) {
- int64_t dts= av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
- av_add_index_entry(st, st->parser->frame_offset, dts,
+ av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
0, AVINDEX_KEYFRAME);
}
av_free_packet(pkt);
}
}
-/* return TRUE if we deal with a raw stream (raw codec data and
- parsing needed) */
+/**
+ * Returns TRUE if we deal with a raw stream.
+ *
+ * Raw codec data and parsing needed.
+ */
static int is_raw_stream(AVFormatContext *s)
{
AVStream *st;
return 1;
}
-/* return the largest index entry whose timestamp is <=
- wanted_timestamp */
-int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
+/**
+ * Gets the index for a specific timestamp.
+ * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
+ * the timestamp which is <= the requested one, if backward is 0
+ * then it will be >=
+ * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
+ * @return < 0 if no such timestamp could be found
+ */
+int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
+ int flags)
{
AVIndexEntry *entries= st->index_entries;
int nb_entries= st->nb_index_entries;
int a, b, m;
int64_t timestamp;
- if (nb_entries <= 0)
- return -1;
-
- a = 0;
- b = nb_entries - 1;
+ a = - 1;
+ b = nb_entries;
- while (a < b) {
- m = (a + b + 1) >> 1;
+ while (b - a > 1) {
+ m = (a + b) >> 1;
timestamp = entries[m].timestamp;
- if (timestamp > wanted_timestamp) {
- b = m - 1;
- } else {
+ if(timestamp >= wanted_timestamp)
+ b = m;
+ if(timestamp <= wanted_timestamp)
a = m;
+ }
+ m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
+
+ if(!(flags & AVSEEK_FLAG_ANY)){
+ while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
+ m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
}
}
- return a;
+
+ if(m == nb_entries)
+ return -1;
+ return m;
}
#define DEBUG_SEEK
* @param target_ts target timestamp in the time base of the given stream
* @param stream_index stream number
*/
-int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts){
+int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
AVInputFormat *avif= s->iformat;
int64_t pos_min, pos_max, pos, pos_limit;
int64_t ts_min, ts_max, ts;
- int64_t start_pos;
- int index, no_change, i;
+ int64_t start_pos, filesize;
+ int index, no_change;
AVStream *st;
if (stream_index < 0)
if(st->index_entries){
AVIndexEntry *e;
- index= av_index_search_timestamp(st, target_ts);
+ index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non keyframe entries in index case, especially read_timestamp()
+ index= FFMAX(index, 0);
e= &st->index_entries[index];
if(e->timestamp <= target_ts || e->pos == e->min_distance){
}else{
assert(index==0);
}
- index++;
- if(index < st->nb_index_entries){
+
+ index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
+ assert(index < st->nb_index_entries);
+ if(index >= 0){
e= &st->index_entries[index];
assert(e->timestamp >= target_ts);
pos_max= e->pos;
if(ts_max == AV_NOPTS_VALUE){
int step= 1024;
- pos_max = url_filesize(url_fileno(&s->pb)) - 1;
+ filesize = url_fsize(&s->pb);
+ pos_max = filesize - 1;
do{
pos_max -= step;
ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
break;
ts_max= tmp_ts;
pos_max= tmp_pos;
+ if(tmp_pos >= filesize)
+ break;
}
pos_limit= pos_max;
}
if(no_change==0){
int64_t approximate_keyframe_distance= pos_max - pos_limit;
// interpolate position (better than dichotomy)
- pos = (int64_t)((double)(pos_max - pos_min) *
- (double)(target_ts - ts_min) /
- (double)(ts_max - ts_min)) + pos_min - approximate_keyframe_distance;
+ pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
+ + pos_min - approximate_keyframe_distance;
}else if(no_change==1){
// bisection, if interpolation failed to change min or max pos last time
pos = (pos_min + pos_limit)>>1;
av_log(s, AV_LOG_DEBUG, "%Ld %Ld %Ld / %Ld %Ld %Ld target:%Ld limit:%Ld start:%Ld noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
#endif
assert(ts != AV_NOPTS_VALUE);
- if (target_ts < ts) {
+ if (target_ts <= ts) {
pos_limit = start_pos - 1;
pos_max = pos;
ts_max = ts;
- } else {
+ }
+ if (target_ts >= ts) {
pos_min = pos;
ts_min = ts;
- /* check if we are lucky */
- if (target_ts == ts)
- break;
}
}
- pos = pos_min;
+ pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
+ ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
#ifdef DEBUG_SEEK
pos_min = pos;
ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
/* do the seek */
url_fseek(&s->pb, pos, SEEK_SET);
- ts= av_rescale(ts_min, AV_TIME_BASE*(int64_t)st->time_base.num, st->time_base.den);
- for(i = 0; i < s->nb_streams; i++) {
- st = s->streams[i];
+ av_update_cur_dts(s, st, ts);
- st->cur_dts = av_rescale(ts, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
- }
+ return 0;
+}
+
+static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
+ int64_t pos_min, pos_max;
+#if 0
+ AVStream *st;
+
+ if (stream_index < 0)
+ return -1;
+
+ st= s->streams[stream_index];
+#endif
+
+ pos_min = s->data_offset;
+ pos_max = url_fsize(&s->pb) - 1;
+ if (pos < pos_min) pos= pos_min;
+ else if(pos > pos_max) pos= pos_max;
+
+ url_fseek(&s->pb, pos, SEEK_SET);
+
+#if 0
+ av_update_cur_dts(s, st, ts);
+#endif
return 0;
}
static int av_seek_frame_generic(AVFormatContext *s,
- int stream_index, int64_t timestamp)
+ int stream_index, int64_t timestamp, int flags)
{
- int index, i;
+ int index;
AVStream *st;
AVIndexEntry *ie;
}
st = s->streams[stream_index];
- index = av_index_search_timestamp(st, timestamp);
+ index = av_index_search_timestamp(st, timestamp, flags);
if (index < 0)
return -1;
ie = &st->index_entries[index];
av_read_frame_flush(s);
url_fseek(&s->pb, ie->pos, SEEK_SET);
-
- timestamp= av_rescale(ie->timestamp, AV_TIME_BASE*(int64_t)st->time_base.num, st->time_base.den);
- for(i = 0; i < s->nb_streams; i++) {
- st = s->streams[i];
- st->cur_dts = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
- }
+ av_update_cur_dts(s, st, ie->timestamp);
return 0;
}
/**
- * Seek to the key frame just before the frame at timestamp
+ * Seek to the key frame at timestamp.
* 'timestamp' in 'stream_index'.
* @param stream_index If stream_index is (-1), a default
- * stream is selected
- * @param timestamp timestamp in AV_TIME_BASE units
+ * stream is selected, and timestamp is automatically converted
+ * from AV_TIME_BASE units to the stream specific time_base.
+ * @param timestamp timestamp in AVStream.time_base units
+ * or if there is no stream specified then in AV_TIME_BASE units
+ * @param flags flags which select direction and seeking mode
* @return >= 0 on success
*/
-int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
+int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
{
int ret;
AVStream *st;
av_read_frame_flush(s);
+ if(flags & AVSEEK_FLAG_BYTE)
+ return av_seek_frame_byte(s, stream_index, timestamp, flags);
+
if(stream_index < 0){
stream_index= av_find_default_stream_index(s);
if(stream_index < 0)
return -1;
+
+ st= s->streams[stream_index];
+ /* timestamp for default must be expressed in AV_TIME_BASE units */
+ timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
}
st= s->streams[stream_index];
- timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
-
/* first, we try the format specific seek */
if (s->iformat->read_seek)
- ret = s->iformat->read_seek(s, stream_index, timestamp);
+ ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
else
ret = -1;
if (ret >= 0) {
}
if(s->iformat->read_timestamp)
- return av_seek_frame_binary(s, stream_index, timestamp);
+ return av_seek_frame_binary(s, stream_index, timestamp, flags);
else
- return av_seek_frame_generic(s, stream_index, timestamp);
+ return av_seek_frame_generic(s, stream_index, timestamp, flags);
}
/*******************************************************/
-/* return TRUE if the stream has accurate timings for at least one component */
+/**
+ * Returns TRUE if the stream has accurate timings in any stream.
+ *
+ * @return TRUE if the stream has accurate timings for at least one component.
+ */
static int av_has_timings(AVFormatContext *ic)
{
int i;
return 0;
}
-/* estimate the stream timings from the one of each components. Also
- compute the global bitrate if possible */
+/**
+ * Estimate the stream timings from the one of each components.
+ *
+ * Also computes the global bitrate if possible.
+ */
static void av_update_stream_timings(AVFormatContext *ic)
{
- int64_t start_time, end_time, end_time1;
+ int64_t start_time, start_time1, end_time, end_time1;
int i;
AVStream *st;
for(i = 0;i < ic->nb_streams; i++) {
st = ic->streams[i];
if (st->start_time != AV_NOPTS_VALUE) {
- if (st->start_time < start_time)
- start_time = st->start_time;
+ start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
+ if (start_time1 < start_time)
+ start_time = start_time1;
if (st->duration != AV_NOPTS_VALUE) {
- end_time1 = st->start_time + st->duration;
+ end_time1 = start_time1
+ + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
if (end_time1 > end_time)
end_time = end_time1;
}
}
if (start_time != MAXINT64) {
ic->start_time = start_time;
- if (end_time != MAXINT64) {
+ if (end_time != MININT64) {
ic->duration = end_time - start_time;
if (ic->file_size > 0) {
/* compute the bit rate */
for(i = 0;i < ic->nb_streams; i++) {
st = ic->streams[i];
if (st->start_time == AV_NOPTS_VALUE) {
- st->start_time = ic->start_time;
- st->duration = ic->duration;
+ if(ic->start_time != AV_NOPTS_VALUE)
+ st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
+ if(ic->duration != AV_NOPTS_VALUE)
+ st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
}
}
}
bit_rate = 0;
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
- bit_rate += st->codec.bit_rate;
+ bit_rate += st->codec->bit_rate;
}
ic->bit_rate = bit_rate;
}
ic->file_size != 0) {
filesize = ic->file_size;
if (filesize > 0) {
- duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
for(i = 0; i < ic->nb_streams; i++) {
st = ic->streams[i];
+ duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
if (st->start_time == AV_NOPTS_VALUE ||
st->duration == AV_NOPTS_VALUE) {
st->start_time = 0;
AVPacket pkt1, *pkt = &pkt1;
AVStream *st;
int read_size, i, ret;
- int64_t start_time, end_time, end_time1;
+ int64_t end_time;
int64_t filesize, offset, duration;
/* free previous packet */
st = ic->streams[pkt->stream_index];
if (pkt->pts != AV_NOPTS_VALUE) {
if (st->start_time == AV_NOPTS_VALUE)
- st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
+ st->start_time = pkt->pts;
}
av_free_packet(pkt);
}
- /* we compute the minimum start_time and use it as default */
- start_time = MAXINT64;
- for(i = 0; i < ic->nb_streams; i++) {
- st = ic->streams[i];
- if (st->start_time != AV_NOPTS_VALUE &&
- st->start_time < start_time)
- start_time = st->start_time;
- }
- if (start_time != MAXINT64)
- ic->start_time = start_time;
-
/* estimate the end time (duration) */
/* XXX: may need to support wrapping */
filesize = ic->file_size;
read_size += pkt->size;
st = ic->streams[pkt->stream_index];
if (pkt->pts != AV_NOPTS_VALUE) {
- end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
+ end_time = pkt->pts;
duration = end_time - st->start_time;
if (duration > 0) {
if (st->duration == AV_NOPTS_VALUE ||
av_free_packet(pkt);
}
- /* estimate total duration */
- end_time = MININT64;
- for(i = 0;i < ic->nb_streams; i++) {
- st = ic->streams[i];
- if (st->duration != AV_NOPTS_VALUE) {
- end_time1 = st->start_time + st->duration;
- if (end_time1 > end_time)
- end_time = end_time1;
- }
- }
-
- /* update start_time (new stream may have been created, so we do
- it at the end */
- if (ic->start_time != AV_NOPTS_VALUE) {
- for(i = 0; i < ic->nb_streams; i++) {
- st = ic->streams[i];
- if (st->start_time == AV_NOPTS_VALUE)
- st->start_time = ic->start_time;
- }
- }
-
- if (end_time != MININT64) {
- /* put dummy values for duration if needed */
- for(i = 0;i < ic->nb_streams; i++) {
- st = ic->streams[i];
- if (st->duration == AV_NOPTS_VALUE &&
- st->start_time != AV_NOPTS_VALUE)
- st->duration = end_time - st->start_time;
- }
- ic->duration = end_time - ic->start_time;
- }
+ fill_all_stream_timings(ic);
url_fseek(&ic->pb, 0, SEEK_SET);
}
static void av_estimate_timings(AVFormatContext *ic)
{
- URLContext *h;
int64_t file_size;
/* get the file size, if possible */
if (ic->iformat->flags & AVFMT_NOFILE) {
file_size = 0;
} else {
- h = url_fileno(&ic->pb);
- file_size = url_filesize(h);
+ file_size = url_fsize(&ic->pb);
if (file_size < 0)
file_size = 0;
}
ic->file_size = file_size;
- if (ic->iformat == &mpegps_demux) {
+ if ((ic->iformat == &mpegps_demux || ic->iformat == &mpegts_demux) && file_size && !ic->pb.is_streamed) {
/* get accurate estimate from the PTSes */
av_estimate_timings_from_pts(ic);
} else if (av_has_timings(ic)) {
val = enc->sample_rate;
break;
case CODEC_TYPE_VIDEO:
- val = enc->width;
+ val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
break;
default:
val = 1;
{
int16_t *samples;
AVCodec *codec;
- int got_picture, ret;
+ int got_picture, ret=0;
AVFrame picture;
- codec = avcodec_find_decoder(st->codec.codec_id);
+ if(!st->codec->codec){
+ codec = avcodec_find_decoder(st->codec->codec_id);
if (!codec)
return -1;
- ret = avcodec_open(&st->codec, codec);
+ ret = avcodec_open(st->codec, codec);
if (ret < 0)
return ret;
- switch(st->codec.codec_type) {
+ }
+
+ if(!has_codec_parameters(st->codec)){
+ switch(st->codec->codec_type) {
case CODEC_TYPE_VIDEO:
- ret = avcodec_decode_video(&st->codec, &picture,
+ ret = avcodec_decode_video(st->codec, &picture,
&got_picture, (uint8_t *)data, size);
break;
case CODEC_TYPE_AUDIO:
samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
if (!samples)
goto fail;
- ret = avcodec_decode_audio(&st->codec, samples,
+ ret = avcodec_decode_audio(st->codec, samples,
&got_picture, (uint8_t *)data, size);
av_free(samples);
break;
default:
break;
}
+ }
fail:
- avcodec_close(&st->codec);
return ret;
}
#define MAX_READ_SIZE 5000000
/* maximum duration until we stop analysing the stream */
-#define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
+#define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 2.0))
/**
* Read the beginning of a media file to get stream information. This
*
* @param ic media file handle
* @return >=0 if OK. AVERROR_xxx if error.
+ * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
*/
int av_find_stream_info(AVFormatContext *ic)
{
AVStream *st;
AVPacket pkt1, *pkt;
AVPacketList *pktl=NULL, **ppktl;
+ int64_t last_dts[MAX_STREAMS];
+ int64_t duration_sum[MAX_STREAMS];
+ int duration_count[MAX_STREAMS]={0};
+ for(i=0;i<ic->nb_streams;i++) {
+ st = ic->streams[i];
+ if(st->codec->codec_type == CODEC_TYPE_VIDEO){
+/* if(!st->time_base.num)
+ st->time_base= */
+ if(!st->codec->time_base.num)
+ st->codec->time_base= st->time_base;
+ }
+ //only for the split stuff
+ if (!st->parser) {
+ st->parser = av_parser_init(st->codec->codec_id);
+ }
+ }
+
+ for(i=0;i<MAX_STREAMS;i++){
+ last_dts[i]= AV_NOPTS_VALUE;
+ duration_sum[i]= INT64_MAX;
+ }
+
count = 0;
read_size = 0;
ppktl = &ic->packet_buffer;
/* check if one codec still needs to be handled */
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
- if (!has_codec_parameters(&st->codec))
+ if (!has_codec_parameters(st->codec))
+ break;
+ /* variable fps and no guess at the real fps */
+ if( st->codec->time_base.den >= 1000LL*st->codec->time_base.num
+ && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
+ break;
+ if(st->parser && st->parser->parser->split && !st->codec->extradata)
break;
}
if (i == ic->nb_streams) {
if (ret < 0) {
/* EOF or error */
ret = -1; /* we could not have all the codec parameters before EOF */
- if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
- i == ic->nb_streams)
+ for(i=0;i<ic->nb_streams;i++) {
+ st = ic->streams[i];
+ if (!has_codec_parameters(st->codec))
+ break;
+ }
+ if (i == ic->nb_streams)
ret = 0;
break;
}
if (pkt->duration != 0)
st->codec_info_nb_frames++;
+ {
+ int index= pkt->stream_index;
+ int64_t last= last_dts[index];
+ int64_t duration= pkt->dts - last;
+
+ if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
+ if(duration*duration_count[index]*10/9 < duration_sum[index]){
+ duration_sum[index]= duration;
+ duration_count[index]=1;
+ }else{
+ int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
+ duration_sum[index] += duration;
+ duration_count[index]+= factor;
+ }
+ if(st->codec_info_nb_frames == 0 && 0)
+ st->codec_info_duration += duration;
+ }
+ last_dts[pkt->stream_index]= pkt->dts;
+ }
+ if(st->parser && st->parser->parser->split && !st->codec->extradata){
+ int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
+ if(i){
+ st->codec->extradata_size= i;
+ st->codec->extradata= av_malloc(st->codec->extradata_size);
+ memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
+ }
+ }
+
/* if still no information, we try to open the codec and to
decompress the frame. We try to avoid that in most cases as
it takes longer and uses more memory. For MPEG4, we need to
decompress for Quicktime. */
- if (!has_codec_parameters(&st->codec) &&
- (st->codec.codec_id == CODEC_ID_FLV1 ||
- st->codec.codec_id == CODEC_ID_H264 ||
- st->codec.codec_id == CODEC_ID_H263 ||
- st->codec.codec_id == CODEC_ID_VORBIS ||
- (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
+ if (!has_codec_parameters(st->codec) /*&&
+ (st->codec->codec_id == CODEC_ID_FLV1 ||
+ st->codec->codec_id == CODEC_ID_H264 ||
+ st->codec->codec_id == CODEC_ID_H263 ||
+ st->codec->codec_id == CODEC_ID_H261 ||
+ st->codec->codec_id == CODEC_ID_VORBIS ||
+ st->codec->codec_id == CODEC_ID_MJPEG ||
+ st->codec->codec_id == CODEC_ID_PNG ||
+ st->codec->codec_id == CODEC_ID_PAM ||
+ st->codec->codec_id == CODEC_ID_PGM ||
+ st->codec->codec_id == CODEC_ID_PGMYUV ||
+ st->codec->codec_id == CODEC_ID_PBM ||
+ st->codec->codec_id == CODEC_ID_PPM ||
+ st->codec->codec_id == CODEC_ID_SHORTEN ||
+ (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
try_decode_frame(st, pkt->data, pkt->size);
- if (st->codec_info_duration >= MAX_STREAM_DURATION) {
+ if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
break;
}
count++;
}
- /* set real frame rate info */
+ // close codecs which where opened in try_decode_frame()
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
- if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
+ if(st->codec->codec)
+ avcodec_close(st->codec);
+ }
+ for(i=0;i<ic->nb_streams;i++) {
+ st = ic->streams[i];
+ if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+ if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
+ st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
+
+ if(duration_count[i] && st->codec->time_base.num*1000LL <= st->codec->time_base.den &&
+ st->time_base.num*duration_sum[i]/duration_count[i]*1000LL > st->time_base.den){
+ AVRational fps1;
+ int64_t num, den;
+
+ num= st->time_base.den*duration_count[i];
+ den= st->time_base.num*duration_sum[i];
+
+ av_reduce(&fps1.num, &fps1.den, num*1001, den*1000, FFMAX(st->time_base.den, st->time_base.num)/4);
+ av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, den, FFMAX(st->time_base.den, st->time_base.num)/4);
+ if(fps1.num < st->r_frame_rate.num && fps1.den == 1 && (fps1.num==24 || fps1.num==30)){ //FIXME better decission
+ st->r_frame_rate.num= fps1.num*1000;
+ st->r_frame_rate.den= fps1.den*1001;
+ }
+ }
+
+ /* set real frame rate info */
/* compute the real frame rate for telecine */
- if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
- st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
- st->codec.sub_id == 2) {
+ if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
+ st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
+ st->codec->sub_id == 2) {
if (st->codec_info_nb_frames >= 20) {
float coded_frame_rate, est_frame_rate;
est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
(double)st->codec_info_duration ;
- coded_frame_rate = (double)st->codec.frame_rate /
- (double)st->codec.frame_rate_base;
+ coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
#if 0
printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
coded_frame_rate, est_frame_rate);
higher level as it can change in a film */
if (coded_frame_rate >= 24.97 &&
(est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
- st->r_frame_rate = 24024;
- st->r_frame_rate_base = 1001;
+ st->r_frame_rate = (AVRational){24000, 1001};
}
}
}
/* if no real frame rate, use the codec one */
- if (!st->r_frame_rate){
- st->r_frame_rate = st->codec.frame_rate;
- st->r_frame_rate_base = st->codec.frame_rate_base;
+ if (!st->r_frame_rate.num){
+ st->r_frame_rate.num = st->codec->time_base.den;
+ st->r_frame_rate.den = st->codec->time_base.num;
}
}
}
/* correct DTS for b frame streams with no timestamps */
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
- if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
+ if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
if(b-frames){
ppktl = &ic->packet_buffer;
while(ppkt1){
}
/**
- * pause a network based stream (e.g. RTSP stream). Use av_read_play()
- * to resume it.
+ * Pause a network based stream (e.g. RTSP stream).
+ *
+ * Use av_read_play() to resume it.
*/
int av_read_pause(AVFormatContext *s)
{
}
/**
- * Close a media file (but not its codecs)
+ * Close a media file (but not its codecs).
*
* @param s media file handle
*/
av_parser_close(st->parser);
}
av_free(st->index_entries);
+ av_free(st->codec);
av_free(st);
}
flush_packet_queue(s);
}
/**
- * Add a new stream to a media file. Can only be called in the
- * read_header function. If the flag AVFMTCTX_NOHEADER is in the
- * format context, then new streams can be added in read_packet too.
+ * Add a new stream to a media file.
*
+ * Can only be called in the read_header() function. If the flag
+ * AVFMTCTX_NOHEADER is in the format context, then new streams
+ * can be added in read_packet too.
*
* @param s media file handle
* @param id file format dependent stream id
st = av_mallocz(sizeof(AVStream));
if (!st)
return NULL;
- avcodec_get_context_defaults(&st->codec);
+
+ st->codec= avcodec_alloc_context();
if (s->iformat) {
/* no default bitrate if decoding */
- st->codec.bit_rate = 0;
+ st->codec->bit_rate = 0;
}
st->index = s->nb_streams;
st->id = id;
int ret, i;
AVStream *st;
+ // some sanity checks
+ for(i=0;i<s->nb_streams;i++) {
+ st = s->streams[i];
+
+ switch (st->codec->codec_type) {
+ case CODEC_TYPE_AUDIO:
+ if(st->codec->sample_rate<=0){
+ av_log(s, AV_LOG_ERROR, "sample rate not set\n");
+ return -1;
+ }
+ break;
+ case CODEC_TYPE_VIDEO:
+ if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
+ av_log(s, AV_LOG_ERROR, "time base not set\n");
+ return -1;
+ }
+ if(st->codec->width<=0 || st->codec->height<=0){
+ av_log(s, AV_LOG_ERROR, "dimensions not set\n");
+ return -1;
+ }
+ break;
+ }
+ }
+
ret = s->oformat->write_header(s);
if (ret < 0)
return ret;
/* init PTS generation */
for(i=0;i<s->nb_streams;i++) {
+ int64_t den = AV_NOPTS_VALUE;
st = s->streams[i];
- switch (st->codec.codec_type) {
+ switch (st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
- av_frac_init(&st->pts, 0, 0,
- (int64_t)st->time_base.num * st->codec.sample_rate);
+ den = (int64_t)st->time_base.num * st->codec->sample_rate;
break;
case CODEC_TYPE_VIDEO:
- av_frac_init(&st->pts, 0, 0,
- (int64_t)st->time_base.num * st->codec.frame_rate);
+ den = (int64_t)st->time_base.num * st->codec->time_base.den;
break;
default:
break;
}
+ if (den != AV_NOPTS_VALUE) {
+ if (den <= 0)
+ return AVERROR_INVALIDDATA;
+ av_frac_init(&st->pts, 0, 0, den);
+ }
}
return 0;
}
//FIXME merge with compute_pkt_fields
-static void compute_pkt_fields2(AVStream *st, AVPacket *pkt){
- int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
+static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
+ int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
int num, den, frame_size;
// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, b_frames, pkt->size, pkt->stream_index);
/* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
return -1;*/
- if(pkt->pts != AV_NOPTS_VALUE)
- pkt->pts = av_rescale(pkt->pts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
- if(pkt->dts != AV_NOPTS_VALUE)
- pkt->dts = av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
-
/* duration field */
- pkt->duration = av_rescale(pkt->duration, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
if (pkt->duration == 0) {
compute_frame_duration(&num, &den, st, NULL, pkt);
if (den && num) {
pkt->dts= pkt->pts;
}
+ if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
+ av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %Ld >= %Ld\n", st->cur_dts, pkt->dts);
+ return -1;
+ }
+ if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
+ av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
+ return -1;
+ }
+
// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
st->cur_dts= pkt->dts;
st->pts.val= pkt->dts;
/* update pts */
- switch (st->codec.codec_type) {
+ switch (st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
- frame_size = get_audio_frame_size(&st->codec, pkt->size);
+ frame_size = get_audio_frame_size(st->codec, pkt->size);
/* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
but it would be better if we had the real timestamps from the encoder */
}
break;
case CODEC_TYPE_VIDEO:
- av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
+ av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
break;
default:
break;
}
+ return 0;
}
static void truncate_ts(AVStream *st, AVPacket *pkt){
int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
- if(pkt->dts < 0)
- pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
+// if(pkt->dts < 0)
+// pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
pkt->pts &= pts_mask;
pkt->dts &= pts_mask;
}
/**
- * Write a packet to an output media file. The packet shall contain
- * one audio or video frame.
+ * Write a packet to an output media file.
+ *
+ * The packet shall contain one audio or video frame.
*
* @param s media file handle
* @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
*/
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
{
- compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
+ int ret;
+
+ ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
+ if(ret<0)
+ return ret;
truncate_ts(s->streams[pkt->stream_index], pkt);
- return s->oformat->write_packet(s, pkt);
+ ret= s->oformat->write_packet(s, pkt);
+ if(!ret)
+ ret= url_ferror(&s->pb);
+ return ret;
}
/**
- * Writes a packet to an output media file ensuring correct interleaving.
- * The packet shall contain one audio or video frame.
- * If the packets are already correctly interleaved the application should
- * call av_write_frame() instead as its slightly faster, its also important
- * to keep in mind that non interlaved input will need huge amounts
- * of memory to interleave with this, so its prefereable to interleave at the
- * demuxer level
- *
- * @param s media file handle
- * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
- * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
+ * interleave_packet implementation which will interleave per DTS.
+ * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
+ * so they cannot be used after it, note calling av_free_packet() on them is still safe
*/
-int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
+static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
AVPacketList *pktl, **next_point, *this_pktl;
int stream_count=0;
int streams[MAX_STREAMS];
- AVStream *st= s->streams[ pkt->stream_index];
- compute_pkt_fields2(st, pkt);
-
- //FIXME/XXX/HACK drop zero sized packets
- if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
- return 0;
+ if(pkt){
+ AVStream *st= s->streams[ pkt->stream_index];
- if(pkt->dts == AV_NOPTS_VALUE)
- return -1;
-
- assert(pkt->destruct != av_destruct_packet); //FIXME
-
- this_pktl = av_mallocz(sizeof(AVPacketList));
- this_pktl->pkt= *pkt;
- av_dup_packet(&this_pktl->pkt);
-
- next_point = &s->packet_buffer;
- while(*next_point){
- AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
- int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
- int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
- if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
- break;
- next_point= &(*next_point)->next;
+// assert(pkt->destruct != av_destruct_packet); //FIXME
+
+ this_pktl = av_mallocz(sizeof(AVPacketList));
+ this_pktl->pkt= *pkt;
+ if(pkt->destruct == av_destruct_packet)
+ pkt->destruct= NULL; // non shared -> must keep original from being freed
+ else
+ av_dup_packet(&this_pktl->pkt); //shared -> must dup
+
+ next_point = &s->packet_buffer;
+ while(*next_point){
+ AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
+ int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
+ int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
+ if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
+ break;
+ next_point= &(*next_point)->next;
+ }
+ this_pktl->next= *next_point;
+ *next_point= this_pktl;
}
- this_pktl->next= *next_point;
- *next_point= this_pktl;
memset(streams, 0, sizeof(streams));
pktl= s->packet_buffer;
streams[ pktl->pkt.stream_index ]++;
pktl= pktl->next;
}
-
- while(s->nb_streams == stream_count){
- int ret;
-
+
+ if(s->nb_streams == stream_count || (flush && stream_count)){
pktl= s->packet_buffer;
-//av_log(s, AV_LOG_DEBUG, "write st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
- truncate_ts(s->streams[pktl->pkt.stream_index], &pktl->pkt);
- ret= s->oformat->write_packet(s, &pktl->pkt);
+ *out= pktl->pkt;
s->packet_buffer= pktl->next;
- if((--streams[ pktl->pkt.stream_index ]) == 0)
- stream_count--;
-
- av_free_packet(&pktl->pkt);
av_freep(&pktl);
+ return 1;
+ }else{
+ av_init_packet(out);
+ return 0;
+ }
+}
+
+/**
+ * Interleaves a AVPacket correctly so it can be muxed.
+ * @param out the interleaved packet will be output here
+ * @param in the input packet
+ * @param flush 1 if no further packets are available as input and all
+ * remaining packets should be output
+ * @return 1 if a packet was output, 0 if no packet could be output,
+ * < 0 if an error occured
+ */
+static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
+ if(s->oformat->interleave_packet)
+ return s->oformat->interleave_packet(s, out, in, flush);
+ else
+ return av_interleave_packet_per_dts(s, out, in, flush);
+}
+
+/**
+ * Writes a packet to an output media file ensuring correct interleaving.
+ *
+ * The packet must contain one audio or video frame.
+ * If the packets are already correctly interleaved the application should
+ * call av_write_frame() instead as its slightly faster, its also important
+ * to keep in mind that completly non interleaved input will need huge amounts
+ * of memory to interleave with this, so its prefereable to interleave at the
+ * demuxer level
+ *
+ * @param s media file handle
+ * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
+ * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
+ */
+int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
+ AVStream *st= s->streams[ pkt->stream_index];
+
+ //FIXME/XXX/HACK drop zero sized packets
+ if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
+ return 0;
+
+//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
+ if(compute_pkt_fields2(st, pkt) < 0)
+ return -1;
+
+ if(pkt->dts == AV_NOPTS_VALUE)
+ return -1;
+
+ for(;;){
+ AVPacket opkt;
+ int ret= av_interleave_packet(s, &opkt, pkt, 0);
+ if(ret<=0) //FIXME cleanup needed for ret<0 ?
+ return ret;
+
+ truncate_ts(s->streams[opkt.stream_index], &opkt);
+ ret= s->oformat->write_packet(s, &opkt);
+
+ av_free_packet(&opkt);
+ pkt= NULL;
if(ret<0)
return ret;
+ if(url_ferror(&s->pb))
+ return url_ferror(&s->pb);
}
- return 0;
}
/**
- * write the stream trailer to an output media file and and free the
- * file private data.
+ * @brief Write the stream trailer to an output media file and
+ * free the file private data.
*
* @param s media file handle
- * @return 0 if OK. AVERROR_xxx if error. */
+ * @return 0 if OK. AVERROR_xxx if error.
+ */
int av_write_trailer(AVFormatContext *s)
{
- int ret;
+ int ret, i;
- while(s->packet_buffer){
- int ret;
- AVPacketList *pktl= s->packet_buffer;
-
-//av_log(s, AV_LOG_DEBUG, "write_trailer st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
- truncate_ts(s->streams[pktl->pkt.stream_index], &pktl->pkt);
- ret= s->oformat->write_packet(s, &pktl->pkt);
+ for(;;){
+ AVPacket pkt;
+ ret= av_interleave_packet(s, &pkt, NULL, 1);
+ if(ret<0) //FIXME cleanup needed for ret<0 ?
+ goto fail;
+ if(!ret)
+ break;
- s->packet_buffer= pktl->next;
-
- av_free_packet(&pktl->pkt);
- av_freep(&pktl);
+ truncate_ts(s->streams[pkt.stream_index], &pkt);
+ ret= s->oformat->write_packet(s, &pkt);
+
+ av_free_packet(&pkt);
if(ret<0)
- return ret;
+ goto fail;
+ if(url_ferror(&s->pb))
+ goto fail;
}
ret = s->oformat->write_trailer(s);
+fail:
+ if(ret == 0)
+ ret=url_ferror(&s->pb);
+ for(i=0;i<s->nb_streams;i++)
+ av_freep(&s->streams[i]->priv_data);
av_freep(&s->priv_data);
return ret;
}
int i, flags;
char buf[256];
- av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n",
+ av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
is_output ? "Output" : "Input",
index,
is_output ? ic->oformat->name : ic->iformat->name,
is_output ? "to" : "from", url);
if (!is_output) {
- av_log(NULL, AV_LOG_DEBUG, " Duration: ");
+ av_log(NULL, AV_LOG_INFO, " Duration: ");
if (ic->duration != AV_NOPTS_VALUE) {
int hours, mins, secs, us;
secs = ic->duration / AV_TIME_BASE;
secs %= 60;
hours = mins / 60;
mins %= 60;
- av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs,
+ av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
(10 * us) / AV_TIME_BASE);
} else {
- av_log(NULL, AV_LOG_DEBUG, "N/A");
+ av_log(NULL, AV_LOG_INFO, "N/A");
+ }
+ if (ic->start_time != AV_NOPTS_VALUE) {
+ int secs, us;
+ av_log(NULL, AV_LOG_INFO, ", start: ");
+ secs = ic->start_time / AV_TIME_BASE;
+ us = ic->start_time % AV_TIME_BASE;
+ av_log(NULL, AV_LOG_INFO, "%d.%06d",
+ secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
}
- av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
+ av_log(NULL, AV_LOG_INFO, ", bitrate: ");
if (ic->bit_rate) {
- av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
+ av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
} else {
- av_log(NULL, AV_LOG_DEBUG, "N/A");
+ av_log(NULL, AV_LOG_INFO, "N/A");
}
- av_log(NULL, AV_LOG_DEBUG, "\n");
+ av_log(NULL, AV_LOG_INFO, "\n");
}
for(i=0;i<ic->nb_streams;i++) {
AVStream *st = ic->streams[i];
- avcodec_string(buf, sizeof(buf), &st->codec, is_output);
- av_log(NULL, AV_LOG_DEBUG, " Stream #%d.%d", index, i);
+ avcodec_string(buf, sizeof(buf), st->codec, is_output);
+ av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
/* the pid is an important information, so we display it */
/* XXX: add a generic system */
if (is_output)
else
flags = ic->iformat->flags;
if (flags & AVFMT_SHOW_IDS) {
- av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
+ av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
+ }
+ if (strlen(st->language) > 0) {
+ av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
}
- av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
+ av_log(NULL, AV_LOG_INFO, ": %s\n", buf);
}
}
{ "4cif", 704, 576, 0, 0 },
};
+/**
+ * parses width and height out of string str.
+ */
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
{
int i;
return 0;
}
+/**
+ * Converts frame rate from string to a fraction.
+ *
+ * First we try to get an exact integer or fractional frame rate.
+ * If this fails we convert the frame rate to a double and return
+ * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
+ */
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
{
int i;
/* Then, we try to parse it as fraction */
cp = strchr(arg, '/');
+ if (!cp)
+ cp = strchr(arg, ':');
if (cp) {
char* cpp;
*frame_rate = strtol(arg, &cpp, 10);
return 0;
}
-/* Syntax:
+/**
+ * Converts date string to number of seconds since Jan 1st, 1970.
+ *
+ * @code
+ * Syntax:
* - If not a duration:
* [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
* Time is localtime unless Z is suffixed to the end. In this case GMT
* Return the date in micro seconds since 1970
- * - If duration:
+ *
+ * - If a duration:
* HH[:MM[:SS[.m...]]]
* S+[.m...]
+ * @endcode
*/
int64_t parse_date(const char *datestr, int duration)
{
return negative ? -t : t;
}
-/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
- 1 if found */
+/**
+ * Attempts to find a specific tag in a URL.
+ *
+ * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
+ * Return 1 if found.
+ */
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
{
const char *p;
return 0;
}
-/* Return in 'buf' the path with '%d' replaced by number. Also handles
- the '%0nd' format where 'n' is the total number of digits and
- '%%'. Return 0 if OK, and -1 if format error */
+/**
+ * Returns in 'buf' the path with '%d' replaced by number.
+ *
+ * Also handles the '%0nd' format where 'n' is the total number
+ * of digits and '%%'. Return 0 if OK, and -1 if format error.
+ */
int get_frame_filename(char *buf, int buf_size,
const char *path, int number)
{
* @param pkt packet to dump
* @param dump_payload true if the payload must be displayed too
*/
+ //FIXME needs to know the time_base
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
{
fprintf(f, "stream #%d:\n", pkt->stream_index);
}
void url_split(char *proto, int proto_size,
+ char *authorization, int authorization_size,
char *hostname, int hostname_size,
int *port_ptr,
char *path, int path_size,
}
if (proto_size > 0)
*q = '\0';
+ if (authorization_size > 0)
+ authorization[0] = '\0';
if (*p == '\0') {
if (proto_size > 0)
proto[0] = '\0';
hostname[0] = '\0';
p = url;
} else {
+ char *at,*slash; // PETR: position of '@' character and '/' character
+
p++;
if (*p == '/')
p++;
if (*p == '/')
p++;
- q = hostname;
- while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
- if ((q - hostname) < hostname_size - 1)
+ at = strchr(p,'@'); // PETR: get the position of '@'
+ slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
+ if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
+
+ q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
+
+ while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
+ if (*p == '@') { // PETR: passed '@'
+ if (authorization_size > 0)
+ *q = '\0';
+ q = hostname;
+ at = NULL;
+ } else if (!at) { // PETR: hostname
+ if ((q - hostname) < hostname_size - 1)
+ *q++ = *p;
+ } else {
+ if ((q - authorization) < authorization_size - 1)
*q++ = *p;
+ }
p++;
}
if (hostname_size > 0)
}
/**
- * Set the pts for a given stream
+ * Set the pts for a given stream.
+ *
* @param s stream
* @param pts_wrap_bits number of bits effectively used by the pts
* (used for wrap control, 33 is the value for MPEG)
/* fraction handling */
/**
- * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
- * as 0 <= num < den.
+ * f = val + (num / den) + 0.5.
+ *
+ * 'num' is normalized so that it is such as 0 <= num < den.
*
* @param f fractional number
* @param val integer value
f->den = den;
}
-/* set f to (val + 0.5) */
+/**
+ * Set f to (val + 0.5).
+ */
void av_frac_set(AVFrac *f, int64_t val)
{
f->val = val;
}
/**
- * Fractionnal addition to f: f = f + (incr / f->den)
+ * Fractionnal addition to f: f = f + (incr / f->den).
*
* @param f fractional number
* @param incr increment, can be positive or negative
img_fmt->next = NULL;
}
-/* guess image format */
+/**
+ * Guesses image format based on data in the image.
+ */
AVImageFormat *av_probe_image_format(AVProbeData *pd)
{
AVImageFormat *fmt1, *fmt;
return fmt;
}
+/**
+ * Guesses image format based on file name extensions.
+ */
AVImageFormat *guess_image_format(const char *filename)
{
AVImageFormat *fmt1;