return 0;
}
+static int match_format(const char *name, const char *names)
+{
+ const char *p;
+ int len, namelen;
+
+ if (!name || !names)
+ return 0;
+
+ namelen = strlen(name);
+ while ((p = strchr(names, ','))) {
+ len = FFMAX(p - names, namelen);
+ if (!strncasecmp(name, names, len))
+ return 1;
+ names = p+1;
+ }
+ return !strcasecmp(name, names);
+}
+
AVOutputFormat *guess_format(const char *short_name, const char *filename,
const char *mime_type)
{
{
AVInputFormat *fmt;
for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
- if (!strcmp(fmt->name, short_name))
+ if (match_format(short_name, fmt->name))
return fmt;
}
return NULL;
}
if(!ap->prealloced_context)
- ic = av_alloc_format_context();
+ ic = avformat_alloc_context();
else
ic = *ic_ptr;
if (!ic) {
*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);
+ *pnum = (*pnum) * (1 + pc->repeat_pict);
}
}
break;
case CODEC_ID_ASV2:
case CODEC_ID_VCR1:
case CODEC_ID_DNXHD:
+ case CODEC_ID_JPEG2000:
return 1;
default: break;
}
// we take the conservative approach and discard both
// Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
- av_log(s, AV_LOG_ERROR, "invalid dts/pts combination\n");
+ av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
pkt->dts= pkt->pts= AV_NOPTS_VALUE;
}
pkt->dts += offset;
}
+ if (pc && pc->dts_sync_point >= 0) {
+ // we have synchronization info from the parser
+ int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
+ if (den > 0) {
+ int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
+ if (pkt->dts != AV_NOPTS_VALUE) {
+ // got DTS from the stream, update reference timestamp
+ st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
+ pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
+ } else if (st->reference_dts != AV_NOPTS_VALUE) {
+ // compute DTS based on reference timestamp
+ pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
+ pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
+ }
+ if (pc->dts_sync_point > 0)
+ st->reference_dts = pkt->dts; // new reference
+ }
+ }
+
/* This may be redundant, but it should not hurt. */
if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
presentation_delayed = 1;
else if (pc) {
pkt->flags = 0;
/* keyframe computation */
- if (pc->pict_type == FF_I_TYPE)
- pkt->flags |= PKT_FLAG_KEY;
+ if (pc->key_frame == 1)
+ pkt->flags |= PKT_FLAG_KEY;
+ else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
+ pkt->flags |= PKT_FLAG_KEY;
}
+ if (pc)
+ pkt->convergence_duration = pc->convergence_duration;
}
void av_destruct_packet_nofree(AVPacket *pkt)
if (!st->need_parsing || !st->parser) {
/* no parsing needed: we just output the packet as is */
/* raw data support */
- *pkt = s->cur_pkt;
+ *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
compute_pkt_fields(s, st, NULL, pkt);
s->cur_st = NULL;
break;
- } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
+ } else if (st->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;
- s->cur_pkt.dts = AV_NOPTS_VALUE;
+ st->cur_ptr, st->cur_len,
+ st->cur_pkt.pts, st->cur_pkt.dts);
+ st->cur_pkt.pts = AV_NOPTS_VALUE;
+ st->cur_pkt.dts = AV_NOPTS_VALUE;
/* increment read pointer */
- s->cur_ptr += len;
- s->cur_len -= len;
+ st->cur_ptr += len;
+ st->cur_len -= len;
/* return packet if any */
if (pkt->size) {
+ pkt->pos = st->cur_pkt.pos; // Isn't quite accurate but close.
got_packet:
- pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
pkt->duration = 0;
pkt->stream_index = st->index;
pkt->pts = st->parser->pts;
}
} else {
/* free packet */
- av_free_packet(&s->cur_pkt);
+ av_free_packet(&st->cur_pkt);
s->cur_st = NULL;
}
} else {
+ AVPacket cur_pkt;
/* read next packet */
- ret = av_read_packet(s, &s->cur_pkt);
+ ret = av_read_packet(s, &cur_pkt);
if (ret < 0) {
if (ret == AVERROR(EAGAIN))
return ret;
/* no more packets: really terminate parsing */
return ret;
}
+ st = s->streams[cur_pkt.stream_index];
+ st->cur_pkt= cur_pkt;
- if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
- s->cur_pkt.dts != AV_NOPTS_VALUE &&
- s->cur_pkt.pts < s->cur_pkt.dts){
+ if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
+ st->cur_pkt.dts != AV_NOPTS_VALUE &&
+ st->cur_pkt.pts < st->cur_pkt.dts){
av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
- s->cur_pkt.stream_index,
- s->cur_pkt.pts,
- s->cur_pkt.dts,
- s->cur_pkt.size);
-// av_free_packet(&s->cur_pkt);
+ st->cur_pkt.stream_index,
+ st->cur_pkt.pts,
+ st->cur_pkt.dts,
+ st->cur_pkt.size);
+// av_free_packet(&st->cur_pkt);
// return -1;
}
- st = s->streams[s->cur_pkt.stream_index];
if(s->debug & FF_FDEBUG_TS)
av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
- s->cur_pkt.stream_index,
- s->cur_pkt.pts,
- s->cur_pkt.dts,
- s->cur_pkt.size,
- s->cur_pkt.flags);
+ st->cur_pkt.stream_index,
+ st->cur_pkt.pts,
+ st->cur_pkt.dts,
+ st->cur_pkt.size,
+ st->cur_pkt.flags);
s->cur_st = st;
- s->cur_ptr = s->cur_pkt.data;
- s->cur_len = s->cur_pkt.size;
+ st->cur_ptr = st->cur_pkt.data;
+ st->cur_len = st->cur_pkt.size;
if (st->need_parsing && !st->parser) {
st->parser = av_parser_init(st->codec->codec_id);
if (!st->parser) {
}
if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
st->parser->next_frame_offset=
- st->parser->cur_offset= s->cur_pkt.pos;
+ st->parser->cur_offset= st->cur_pkt.pos;
}
}
}
flush_packet_queue(s);
- /* free previous packet */
- if (s->cur_st) {
- if (s->cur_st->parser)
- av_free_packet(&s->cur_pkt);
- s->cur_st = NULL;
- }
- /* fail safe */
- s->cur_ptr = NULL;
- s->cur_len = 0;
+ s->cur_st = NULL;
/* for each stream, reset read state */
for(i = 0; i < s->nb_streams; i++) {
if (st->parser) {
av_parser_close(st->parser);
st->parser = NULL;
+ av_free_packet(&st->cur_pkt);
}
st->last_IP_pts = AV_NOPTS_VALUE;
st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
+ st->reference_dts = AV_NOPTS_VALUE;
+ /* fail safe */
+ st->cur_ptr = NULL;
+ st->cur_len = 0;
}
}
return ret;
}
for(i=0;; i++) {
- int ret = av_read_frame(s, &pkt);
+ int ret;
+ do{
+ ret = av_read_frame(s, &pkt);
+ }while(ret == AVERROR(EAGAIN));
if(ret<0)
break;
av_free_packet(&pkt);
int64_t end_time;
int64_t filesize, offset, duration;
- /* free previous packet */
- if (ic->cur_st && ic->cur_st->parser)
- av_free_packet(&ic->cur_pkt);
ic->cur_st = NULL;
/* flush packet queue */
if (st->parser) {
av_parser_close(st->parser);
st->parser= NULL;
+ av_free_packet(&st->cur_pkt);
}
}
if (i == ic->nb_streams)
break;
- ret = av_read_packet(ic, pkt);
+ do{
+ ret = av_read_packet(ic, pkt);
+ }while(ret == AVERROR(EAGAIN));
if (ret != 0)
break;
read_size += pkt->size;
if (read_size >= DURATION_MAX_READ_SIZE)
break;
- ret = av_read_packet(ic, pkt);
+ do{
+ ret = av_read_packet(ic, pkt);
+ }while(ret == AVERROR(EAGAIN));
if (ret != 0)
break;
read_size += pkt->size;
static int tb_unreliable(AVCodecContext *c){
if( c->time_base.den >= 101L*c->time_base.num
|| c->time_base.den < 5L*c->time_base.num
-/* || c->codec_tag == ff_get_fourcc("DIVX")
- || c->codec_tag == ff_get_fourcc("XVID")*/
- || c->codec_id == CODEC_ID_MPEG2VIDEO)
+/* || c->codec_tag == AV_RL32("DIVX")
+ || c->codec_tag == AV_RL32("XVID")*/
+ || c->codec_id == CODEC_ID_MPEG2VIDEO
+ || c->codec_id == CODEC_ID_H264
+ )
return 1;
return 0;
}
AVStream *st;
AVPacket pkt1, *pkt;
int64_t last_dts[MAX_STREAMS];
+ int64_t duration_gcd[MAX_STREAMS]={0};
int duration_count[MAX_STREAMS]={0};
double (*duration_error)[MAX_STD_TIMEBASES];
int64_t old_offset = url_ftell(ic->pb);
count = 0;
read_size = 0;
for(;;) {
+ if(url_interrupt_cb()){
+ ret= AVERROR(EINTR);
+ break;
+ }
+
/* check if one codec still needs to be handled */
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
/* NOTE: a new stream can be added there if no header in file
(AVFMTCTX_NOHEADER) */
ret = av_read_frame_internal(ic, &pkt1);
+ if(ret == AVERROR(EAGAIN))
+ continue;
if (ret < 0) {
/* EOF or error */
ret = -1; /* we could not have all the codec parameters before EOF */
duration_error[index][i] += error*error;
}
duration_count[index]++;
+ // ignore the first 4 values, they might have some random jitter
+ if (duration_count[index] > 3)
+ duration_gcd[index] = av_gcd(duration_gcd[index], duration);
}
if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
last_dts[pkt->stream_index]= pkt->dts;
if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
+ // the check for tb_unreliable() is not completely correct, since this is not about handling
+ // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
+ // ipmovie.c produces.
+ if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
+ av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
if(duration_count[i]
&& tb_unreliable(st->codec) /*&&
//FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
+ int num = 0;
double best_error= 2*av_q2d(st->time_base);
best_error= best_error*best_error*duration_count[i]*1000*12*30;
// av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
if(error < best_error){
best_error= error;
- av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
+ num = get_std_framerate(j);
}
}
+ // do not increase frame rate by more than 1 % in order to match a standard rate.
+ if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
+ av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
}
if (!st->r_frame_rate.num){
if( st->codec->time_base.den * (int64_t)st->time_base.num
- <= st->codec->time_base.num * (int64_t)st->time_base.den){
+ <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
st->r_frame_rate.num = st->codec->time_base.den;
- st->r_frame_rate.den = st->codec->time_base.num;
+ st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
}else{
st->r_frame_rate.num = st->time_base.den;
st->r_frame_rate.den = st->time_base.num;
int i;
AVStream *st;
- /* free previous packet */
- if (s->cur_st && s->cur_st->parser)
- av_free_packet(&s->cur_pkt);
-
if (s->iformat->read_close)
s->iformat->read_close(s);
for(i=0;i<s->nb_streams;i++) {
st = s->streams[i];
if (st->parser) {
av_parser_close(st->parser);
+ av_free_packet(&st->cur_pkt);
}
av_metadata_free(&st->metadata);
av_free(st->index_entries);
st->last_IP_pts = AV_NOPTS_VALUE;
for(i=0; i<MAX_REORDER_DELAY+1; i++)
st->pts_buffer[i]= AV_NOPTS_VALUE;
+ st->reference_dts = AV_NOPTS_VALUE;
st->sample_aspect_ratio = (AVRational){0,1};
return program;
}
-void av_set_program_name(AVProgram *program, char *provider_name, char *name)
-{
- assert(!provider_name == !name);
- if(name){
- av_free(program->provider_name);
- av_free(program-> name);
- program->provider_name = av_strdup(provider_name);
- program-> name = av_strdup( name);
- }
-}
-
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
{
AVChapter *chapter = NULL;
}else
st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
}
+
+ if(s->oformat->flags & AVFMT_GLOBALHEADER &&
+ !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
+ av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
}
if (!s->priv_data && s->oformat->priv_data_size > 0) {
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);
+ pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
}
}
return ret;
}
+void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
+ int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
+{
+ AVPacketList **next_point, *this_pktl;
+
+ this_pktl = av_mallocz(sizeof(AVPacketList));
+ this_pktl->pkt= *pkt;
+ if(pkt->destruct == av_destruct_packet)
+ pkt->destruct= NULL; // not 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){
+ if(compare(s, &(*next_point)->pkt, pkt))
+ break;
+ next_point= &(*next_point)->next;
+ }
+ this_pktl->next= *next_point;
+ *next_point= this_pktl;
+}
+
+int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
+{
+ AVStream *st = s->streams[ pkt ->stream_index];
+ AVStream *st2= s->streams[ next->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 (pkt->dts == AV_NOPTS_VALUE)
+ return 0;
+
+ return next->dts * left > pkt->dts * right; //FIXME this can overflow
+}
+
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
- AVPacketList *pktl, **next_point, *this_pktl;
+ AVPacketList *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;
- if(pkt->destruct == av_destruct_packet)
- pkt->destruct= NULL; // not 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;
+ ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
}
memset(streams, 0, sizeof(streams));
if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
return -1;
- if(pkt->dts == AV_NOPTS_VALUE)
+ if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
return -1;
for(;;){
}
}
+static void print_fps(double d, const char *postfix){
+ uint64_t v= lrintf(d*100);
+ if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
+ else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
+ else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
+}
+
/* "user interface" functions */
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
{
char buf[256];
int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
AVStream *st = ic->streams[i];
- int g = ff_gcd(st->time_base.num, st->time_base.den);
+ int g = av_gcd(st->time_base.num, st->time_base.den);
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 */
av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
av_log(NULL, AV_LOG_INFO, ": %s", buf);
+ if (st->sample_aspect_ratio.num && // default
+ av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
+ AVRational display_aspect_ratio;
+ av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
+ st->codec->width*st->sample_aspect_ratio.num,
+ st->codec->height*st->sample_aspect_ratio.den,
+ 1024*1024);
+ av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
+ st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
+ display_aspect_ratio.num, display_aspect_ratio.den);
+ }
if(st->codec->codec_type == CODEC_TYPE_VIDEO){
if(st->r_frame_rate.den && st->r_frame_rate.num)
- av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
-/* else if(st->time_base.den && st->time_base.num)
- av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
- else
- av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
+ print_fps(av_q2d(st->r_frame_rate), "tbr");
+ if(st->time_base.den && st->time_base.num)
+ print_fps(1/av_q2d(st->time_base), "tbn");
+ if(st->codec->time_base.den && st->codec->time_base.num)
+ print_fps(1/av_q2d(st->codec->time_base), "tbc");
}
av_log(NULL, AV_LOG_INFO, "\n");
}
p = datestr;
q = NULL;
if (!duration) {
+ if (!strncasecmp(datestr, "now", len))
+ return (int64_t) now * 1000000;
+
/* parse the year-month-day part */
for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
q = small_strptime(p, date_fmt[i], &dt);
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
int pts_num, int pts_den)
{
- unsigned int gcd= ff_gcd(pts_num, pts_den);
+ unsigned int gcd= av_gcd(pts_num, pts_den);
s->pts_wrap_bits = pts_wrap_bits;
s->time_base.num = pts_num/gcd;
s->time_base.den = pts_den/gcd;