#undef NDEBUG
#include <assert.h>
-AVInputFormat *first_iformat;
-AVOutputFormat *first_oformat;
-AVImageFormat *first_image_format;
+AVInputFormat *first_iformat = NULL;
+AVOutputFormat *first_oformat = NULL;
+AVImageFormat *first_image_format = NULL;
void av_register_input_format(AVInputFormat *format)
{
const char *ext, *p;
char ext1[32], *q;
+ if(!filename)
+ return 0;
+
ext = strrchr(filename, '.');
if (ext) {
ext++;
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;
+}
+
AVInputFormat *av_find_input_format(const char *short_name)
{
AVInputFormat *fmt;
*/
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);
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;
/* get data from the fifo (return -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;
}
+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];
+ if(!filename)
+ return -1;
return get_frame_filename(buf, sizeof(buf), filename, 1);
}
ic->priv_data = NULL;
}
- /* default pts settings is MPEG like */
- av_set_pts_info(ic, 33, 1, 90000);
- ic->last_pkt_pts = AV_NOPTS_VALUE;
- ic->last_pkt_dts = AV_NOPTS_VALUE;
- ic->last_pkt_stream_pts = AV_NOPTS_VALUE;
- ic->last_pkt_stream_dts = AV_NOPTS_VALUE;
-
err = ic->iformat->read_header(ic, ap);
if (err < 0)
goto fail;
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;
+ }
+ }
}
}
/**********************************************************/
-/* convert the packet time stamp units and handle wrapping. The
- wrapping is handled by considering the next PTS/DTS as a delta to
- the previous value. We handle the delta as a fraction to avoid any
- rounding errors. */
-static inline int64_t convert_timestamp_units(AVFormatContext *s,
- int64_t *plast_pkt_pts,
- int *plast_pkt_pts_frac,
- int64_t *plast_pkt_stream_pts,
- int64_t pts)
-{
- int64_t stream_pts;
- int64_t delta_pts;
- int shift, pts_frac;
-
- if (pts != AV_NOPTS_VALUE) {
- stream_pts = pts;
- if (*plast_pkt_stream_pts != AV_NOPTS_VALUE) {
- shift = 64 - s->pts_wrap_bits;
- delta_pts = ((stream_pts - *plast_pkt_stream_pts) << shift) >> shift;
- /* XXX: overflow possible but very unlikely as it is a delta */
- delta_pts = delta_pts * AV_TIME_BASE * s->pts_num;
- pts = *plast_pkt_pts + (delta_pts / s->pts_den);
- pts_frac = *plast_pkt_pts_frac + (delta_pts % s->pts_den);
- if (pts_frac >= s->pts_den) {
- pts_frac -= s->pts_den;
- pts++;
- }
- } else {
- /* no previous pts, so no wrapping possible */
- pts = (int64_t)(((double)stream_pts * AV_TIME_BASE * s->pts_num) /
- (double)s->pts_den);
- pts_frac = 0;
- }
- *plast_pkt_stream_pts = stream_pts;
- *plast_pkt_pts = pts;
- *plast_pkt_pts_frac = pts_frac;
- }
- return pts;
-}
-
/* get the number of samples of an audio frame. Return (-1) if error */
static int get_audio_frame_size(AVCodecContext *enc, int size)
{
/* return the frame duration in seconds, return 0 if not available */
-static void compute_frame_duration(int *pnum, int *pden,
- AVFormatContext *s, AVStream *st,
+static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
AVCodecParserContext *pc, AVPacket *pkt)
{
int frame_size;
}
}
+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;
+ return ((lsb - delta)&mask) + delta;
+}
+
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
AVCodecParserContext *pc, AVPacket *pkt)
{
int num, den, presentation_delayed;
+ /* handle wrapping */
+ if(st->cur_dts != AV_NOPTS_VALUE){
+ if(pkt->pts != AV_NOPTS_VALUE)
+ pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
+ if(pkt->dts != AV_NOPTS_VALUE)
+ pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
+ }
+
if (pkt->duration == 0) {
- compute_frame_duration(&num, &den, s, st, pc, pkt);
+ compute_frame_duration(&num, &den, st, pc, pkt);
if (den && num) {
- pkt->duration = (num * (int64_t)AV_TIME_BASE) / den;
+ pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
}
}
+ 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) {
/* 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 */
+ if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
+ presentation_delayed = 1;
+ }
+
+ if(st->cur_dts == AV_NOPTS_VALUE){
+ if(presentation_delayed) st->cur_dts = -pkt->duration;
+ else st->cur_dts = 0;
}
+// av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
/* interpolate PTS and DTS if they are not present */
if (presentation_delayed) {
/* DTS = decompression time stamp */
/* PTS = presentation time stamp */
if (pkt->dts == AV_NOPTS_VALUE) {
- pkt->dts = st->cur_dts;
+ /* if we know the last pts, use it */
+ if(st->last_IP_pts != AV_NOPTS_VALUE)
+ st->cur_dts = pkt->dts = st->last_IP_pts;
+ else
+ pkt->dts = st->cur_dts;
} else {
st->cur_dts = pkt->dts;
}
else
st->cur_dts += st->last_IP_duration;
st->last_IP_duration = pkt->duration;
+ 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) {
}
st->cur_dts += pkt->duration;
}
+// av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
/* update flags */
if (pc) {
}
}
+ /* 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;
}
compute_pkt_fields(s, st, NULL, pkt);
s->cur_st = NULL;
return 0;
- } else if (s->cur_len > 0) {
+ } 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);
/* no more packets: really terminates parsing */
return ret;
}
-
- /* convert the packet time stamp units and handle wrapping */
- s->cur_pkt.pts = convert_timestamp_units(s,
- &s->last_pkt_pts, &s->last_pkt_pts_frac,
- &s->last_pkt_stream_pts,
- s->cur_pkt.pts);
- s->cur_pkt.dts = convert_timestamp_units(s,
- &s->last_pkt_dts, &s->last_pkt_dts_frac,
- &s->last_pkt_stream_dts,
- s->cur_pkt.dts);
-#if 0
- if (s->cur_pkt.stream_index == 0) {
- if (s->cur_pkt.pts != AV_NOPTS_VALUE)
- printf("PACKET pts=%0.3f\n",
- (double)s->cur_pkt.pts / AV_TIME_BASE);
- if (s->cur_pkt.dts != AV_NOPTS_VALUE)
- printf("PACKET dts=%0.3f\n",
- (double)s->cur_pkt.dts / AV_TIME_BASE);
- }
-#endif
- /* duration field */
- if (s->cur_pkt.duration != 0) {
- s->cur_pkt.duration = ((int64_t)s->cur_pkt.duration * AV_TIME_BASE * s->pts_num) /
- s->pts_den;
- }
-
st = s->streams[s->cur_pkt.stream_index];
+
s->cur_st = st;
s->cur_ptr = s->cur_pkt.data;
s->cur_len = s->cur_pkt.size;
av_parser_close(st->parser);
st->parser = NULL;
}
+ st->last_IP_pts = AV_NOPTS_VALUE;
st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
}
}
-/* 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,
int64_t pos, int64_t timestamp, int distance, int flags)
{
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(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;
break;
if (pkt->stream_index == 0 && st->parser &&
(pkt->flags & PKT_FLAG_KEY)) {
- av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
+ 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,
0, AVINDEX_KEYFRAME);
}
av_free_packet(pkt);
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
+
+/**
+ * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
+ * this isnt supposed to be called directly by a user application, but by demuxers
+ * @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 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;
+ AVStream *st;
+
+ if (stream_index < 0)
+ return -1;
+
+#ifdef DEBUG_SEEK
+ av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
+#endif
+
+ ts_max=
+ ts_min= AV_NOPTS_VALUE;
+ pos_limit= -1; //gcc falsely says it may be uninitalized
+
+ st= s->streams[stream_index];
+ if(st->index_entries){
+ AVIndexEntry *e;
+
+ 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){
+ pos_min= e->pos;
+ ts_min= e->timestamp;
+#ifdef DEBUG_SEEK
+ av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%llx dts_min=%lld\n",
+ pos_min,ts_min);
+#endif
+ }else{
+ assert(index==0);
+ }
+
+ 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;
+ ts_max= e->timestamp;
+ pos_limit= pos_max - e->min_distance;
+#ifdef DEBUG_SEEK
+ av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld\n",
+ pos_max,pos_limit, ts_max);
+#endif
+ }
+ }
+
+ if(ts_min == AV_NOPTS_VALUE){
+ pos_min = s->data_offset;
+ ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
+ if (ts_min == AV_NOPTS_VALUE)
+ return -1;
+ }
+
+ if(ts_max == AV_NOPTS_VALUE){
+ int step= 1024;
+ pos_max = url_filesize(url_fileno(&s->pb)) - 1;
+ do{
+ pos_max -= step;
+ ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
+ step += step;
+ }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
+ if (ts_max == AV_NOPTS_VALUE)
+ return -1;
+
+ for(;;){
+ int64_t tmp_pos= pos_max + 1;
+ int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
+ if(tmp_ts == AV_NOPTS_VALUE)
+ break;
+ ts_max= tmp_ts;
+ pos_max= tmp_pos;
+ }
+ pos_limit= pos_max;
+ }
+
+ no_change=0;
+ while (pos_min < pos_limit) {
+#ifdef DEBUG_SEEK
+ av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n",
+ pos_min, pos_max,
+ ts_min, ts_max);
+#endif
+ assert(pos_limit <= pos_max);
+
+ if(no_change==0){
+ int64_t approximate_keyframe_distance= pos_max - pos_limit;
+ // interpolate position (better than dichotomy)
+ 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;
+ }else{
+ // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
+ pos=pos_min;
+ }
+ if(pos <= pos_min)
+ pos= pos_min + 1;
+ else if(pos > pos_limit)
+ pos= pos_limit;
+ start_pos= pos;
+
+ ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
+ if(pos == pos_max)
+ no_change++;
+ else
+ no_change=0;
+#ifdef DEBUG_SEEK
+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) {
+ pos_limit = start_pos - 1;
+ pos_max = pos;
+ ts_max = ts;
+ }
+ if (target_ts >= ts) {
+ pos_min = pos;
+ ts_min = ts;
+ }
+ }
+
+ 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);
+ pos_min++;
+ ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
+ av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n",
+ pos, ts_min, target_ts, ts_max);
+#endif
+ /* do the seek */
+ url_fseek(&s->pb, pos, SEEK_SET);
+
+ av_update_cur_dts(s, st, ts);
+
+ 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_filesize(url_fileno(&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;
AVStream *st;
s->index_built = 1;
}
- if (stream_index < 0)
- stream_index = 0;
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);
- st->cur_dts = ie->timestamp;
+
+ av_update_cur_dts(s, st, ie->timestamp);
+
return 0;
}
/**
- * Seek to the key frame just before the frame at timestamp
- * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
- * stream is selected
+ * Seek to the key frame at timestamp.
+ * 'timestamp' in 'stream_index'.
+ * @param stream_index If stream_index is (-1), a default
+ * 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
+ * @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];
/* 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) {
return 0;
}
-
- return av_seek_frame_generic(s, stream_index, timestamp);
+
+ if(s->iformat->read_timestamp)
+ return av_seek_frame_binary(s, stream_index, timestamp, flags);
+ else
+ return av_seek_frame_generic(s, stream_index, timestamp, flags);
}
/*******************************************************/
/* flush packet queue */
flush_packet_queue(ic);
-
+ for(i=0;i<ic->nb_streams;i++) {
+ st = ic->streams[i];
+ if (st->parser) {
+ av_parser_close(st->parser);
+ st->parser= NULL;
+ }
+ }
+
/* we read the first packets to get the first PTS (not fully
accurate, but it is enough now) */
url_fseek(&ic->pb, 0, SEEK_SET);
st = ic->streams[pkt->stream_index];
if (pkt->pts != AV_NOPTS_VALUE) {
if (st->start_time == AV_NOPTS_VALUE)
- st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
+ st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
}
av_free_packet(pkt);
}
read_size += pkt->size;
st = ic->streams[pkt->stream_index];
if (pkt->pts != AV_NOPTS_VALUE) {
- end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
+ end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
duration = end_time - st->start_time;
if (duration > 0) {
if (st->duration == AV_NOPTS_VALUE ||
}
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)) {
AVStream *st;
AVPacket pkt1, *pkt;
AVPacketList *pktl=NULL, **ppktl;
+ int64_t last_dts[MAX_STREAMS];
+ int64_t best_duration[MAX_STREAMS];
+ for(i=0;i<MAX_STREAMS;i++){
+ last_dts[i]= AV_NOPTS_VALUE;
+ best_duration[i]= INT64_MAX;
+ }
+
count = 0;
read_size = 0;
ppktl = &ic->packet_buffer;
st = ic->streams[i];
if (!has_codec_parameters(&st->codec))
break;
+ /* variable fps and no guess at the real fps */
+ if( st->codec.frame_rate >= 1000LL*st->codec.frame_rate_base
+ && best_duration[i]== INT64_MAX)
+ break;
}
if (i == ic->nb_streams) {
/* NOTE: if the format has no header, then we need to read
if (ret < 0) {
/* EOF or error */
ret = -1; /* we could not have all the codec parameters before EOF */
+ for(i=0;i<ic->nb_streams;i++) {
+ st = ic->streams[i];
+ if (!has_codec_parameters(&st->codec))
+ break;
+ }
if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
i == ic->nb_streams)
ret = 0;
if (pkt->duration != 0)
st->codec_info_nb_frames++;
+ if(st->codec.codec_type == CODEC_TYPE_VIDEO){
+ int64_t last= last_dts[pkt->stream_index];
+
+ if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && last < pkt->dts &&
+ best_duration[pkt->stream_index] > pkt->dts - last){
+ best_duration[pkt->stream_index] = pkt->dts - last;
+ }
+ last_dts[pkt->stream_index]= pkt->dts;
+ }
/* 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
(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);
count++;
}
- /* set real frame rate info */
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(best_duration[i] < INT64_MAX && st->codec.frame_rate_base*1000 <= st->codec.frame_rate){
+ int int_fps;
+
+ st->r_frame_rate= st->codec.frame_rate;
+ st->r_frame_rate_base= av_rescale(best_duration[i], st->codec.frame_rate, AV_TIME_BASE);
+ av_reduce(&st->r_frame_rate, &st->r_frame_rate_base, st->r_frame_rate, st->r_frame_rate_base, 1<<15);
+
+ int_fps= av_rescale(st->r_frame_rate, 1, st->r_frame_rate_base);
+
+ if(int_fps>0 && av_rescale(st->r_frame_rate, 1, int_fps) == st->r_frame_rate_base){
+ st->r_frame_rate= int_fps;
+ st->r_frame_rate_base= 1;
+ }
+ }
+
+ /* 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) &&
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 = 24000;
st->r_frame_rate_base = 1001;
}
}
}
av_estimate_timings(ic);
+#if 0
+ /* 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(b-frames){
+ ppktl = &ic->packet_buffer;
+ while(ppkt1){
+ if(ppkt1->stream_index != i)
+ continue;
+ if(ppkt1->pkt->dts < 0)
+ break;
+ if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
+ break;
+ ppkt1->pkt->dts -= delta;
+ ppkt1= ppkt1->next;
+ }
+ if(ppkt1)
+ continue;
+ st->cur_dts -= delta;
+ }
+ }
+ }
+#endif
return ret;
}
st->id = id;
st->start_time = AV_NOPTS_VALUE;
st->duration = AV_NOPTS_VALUE;
+ st->cur_dts = AV_NOPTS_VALUE;
+
+ /* default pts settings is MPEG like */
+ av_set_pts_info(st, 33, 1, 90000);
+ st->last_IP_pts = AV_NOPTS_VALUE;
+
s->streams[s->nb_streams++] = st;
return st;
}
int ret, i;
AVStream *st;
- /* default pts settings is MPEG like */
- av_set_pts_info(s, 33, 1, 90000);
ret = s->oformat->write_header(s);
if (ret < 0)
return ret;
switch (st->codec.codec_type) {
case CODEC_TYPE_AUDIO:
av_frac_init(&st->pts, 0, 0,
- (int64_t)s->pts_num * st->codec.sample_rate);
+ (int64_t)st->time_base.num * st->codec.sample_rate);
break;
case CODEC_TYPE_VIDEO:
av_frac_init(&st->pts, 0, 0,
- (int64_t)s->pts_num * st->codec.frame_rate);
+ (int64_t)st->time_base.num * st->codec.frame_rate);
break;
default:
break;
return 0;
}
-/**
- * Write a packet to an output media file. The packet shall contain
- * one audio or video frame.
- *
- * @param s media file handle
- * @param stream_index stream index
- * @param buf buffer containing the frame data
- * @param size size of buffer
- * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
- */
-int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
- int size)
-{
- AVStream *st;
- int64_t pts_mask;
- int ret, frame_size;
+//FIXME merge with compute_pkt_fields
+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;
- st = s->streams[stream_index];
- pts_mask = (1LL << s->pts_wrap_bits) - 1;
- ret = s->oformat->write_packet(s, stream_index, buf, size,
- st->pts.val & pts_mask);
- if (ret < 0)
- return ret;
+// 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->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
+ }
+ }
+
+ //XXX/FIXME this is a temporary hack until all encoders output pts
+ if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
+ pkt->dts=
+// pkt->pts= st->cur_dts;
+ pkt->pts= st->pts.val;
+ }
+
+ //calculate dts from pts
+ if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
+ if(b_frames){
+ if(st->last_IP_pts == AV_NOPTS_VALUE){
+ st->last_IP_pts= -pkt->duration;
+ }
+ if(st->last_IP_pts < pkt->pts){
+ pkt->dts= st->last_IP_pts;
+ st->last_IP_pts= pkt->pts;
+ }else
+ pkt->dts= pkt->pts;
+ }else
+ 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) {
case CODEC_TYPE_AUDIO:
- frame_size = get_audio_frame_size(&st->codec, size);
- if (frame_size >= 0) {
- av_frac_add(&st->pts,
- (int64_t)s->pts_den * frame_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 */
+ if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
+ av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
}
break;
case CODEC_TYPE_VIDEO:
- av_frac_add(&st->pts,
- (int64_t)s->pts_den * st->codec.frame_rate_base);
+ av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
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
+
+ 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.
+ *
+ * @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_write_frame(AVFormatContext *s, AVPacket *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);
+
+ ret= s->oformat->write_packet(s, pkt);
+ if(!ret)
+ ret= url_ferror(&s->pb);
return ret;
}
+/**
+ * interleave_packet implementation which will interleave per DTS.
+ */
+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];
+
+ if(pkt){
+ AVStream *st= s->streams[ pkt->stream_index];
+
+ 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;
+ }
+ this_pktl->next= *next_point;
+ *next_point= this_pktl;
+ }
+
+ memset(streams, 0, sizeof(streams));
+ pktl= s->packet_buffer;
+ while(pktl){
+//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
+ if(streams[ pktl->pkt.stream_index ] == 0)
+ stream_count++;
+ streams[ pktl->pkt.stream_index ]++;
+ pktl= pktl->next;
+ }
+
+ if(s->nb_streams == stream_count || (flush && stream_count)){
+ pktl= s->packet_buffer;
+ *out= pktl->pkt;
+
+ s->packet_buffer= pktl->next;
+ 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 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 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);
+ }
+}
+
/**
* write the stream trailer to an output media file and and free the
* file private data.
* @return 0 if OK. AVERROR_xxx if error. */
int av_write_trailer(AVFormatContext *s)
{
- int ret;
+ int ret, i;
+
+ 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;
+
+ truncate_ts(s->streams[pkt.stream_index], &pkt);
+ ret= s->oformat->write_packet(s, &pkt);
+
+ av_free_packet(&pkt);
+
+ if(ret<0)
+ 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;
}
} else {
av_log(NULL, AV_LOG_DEBUG, "N/A");
}
+ if (ic->start_time != AV_NOPTS_VALUE) {
+ int secs, us;
+ av_log(NULL, AV_LOG_DEBUG, ", start: ");
+ secs = ic->start_time / AV_TIME_BASE;
+ us = ic->start_time % AV_TIME_BASE;
+ av_log(NULL, AV_LOG_DEBUG, "%d.%06d",
+ secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
+ }
av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
if (ic->bit_rate) {
av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
/* 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);
}
else {
/* Finally we give up and parse it as double */
- *frame_rate_base = DEFAULT_FRAME_RATE_BASE;
+ *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
*frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
}
if (!*frame_rate || !*frame_rate_base)
const char *q;
int is_utc, len;
char lastch;
+ int negative = 0;
+
+#undef time
time_t now = time(0);
len = strlen(datestr);
}
}
} else {
+ if (p[0] == '-') {
+ negative = 1;
+ ++p;
+ }
q = small_strptime(p, time_fmt[0], &dt);
if (!q) {
dt.tm_sec = strtol(p, (char **)&q, 10);
}
t += val;
}
- return t;
+ return negative ? -t : t;
}
/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
}
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)
* @param pts_num numerator to convert to seconds (MPEG: 1)
* @param pts_den denominator to convert to seconds (MPEG: 90000)
*/
-void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
+void av_set_pts_info(AVStream *s, int pts_wrap_bits,
int pts_num, int pts_den)
{
s->pts_wrap_bits = pts_wrap_bits;
- s->pts_num = pts_num;
- s->pts_den = pts_den;
+ s->time_base.num = pts_num;
+ s->time_base.den = pts_den;
}
/* fraction handling */