pkt.data= audio_out;
pkt.size= ret;
if(enc->coded_frame)
- pkt.pts= enc->coded_frame->pts;
+ pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
pkt.flags |= PKT_FLAG_KEY;
av_interleaved_write_frame(s, &pkt);
pkt.data= audio_out;
pkt.size= ret;
if(enc->coded_frame)
- pkt.pts= enc->coded_frame->pts;
+ pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
pkt.flags |= PKT_FLAG_KEY;
av_interleaved_write_frame(s, &pkt);
}
if(video_sync_method){
double vdelta;
- vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
+ vdelta = ost->sync_ipts / av_q2d(enc->time_base) - ost->sync_opts;
//FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
if (vdelta < -1.1)
nb_frames = 0;
fprintf(stderr, "*** %d dup!\n", nb_frames-1);
}
}else
- ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
+ ost->sync_opts= lrintf(ost->sync_ipts / av_q2d(enc->time_base));
nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
if (nb_frames <= 0)
pkt.data= (uint8_t *)final_picture;
pkt.size= sizeof(AVPicture);
if(dec->coded_frame)
- pkt.pts= dec->coded_frame->pts;
+ pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
if(dec->coded_frame && dec->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
if(!me_threshold)
big_picture.pict_type = 0;
// big_picture.pts = AV_NOPTS_VALUE;
- big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
+ big_picture.pts= ost->sync_opts;
+// big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
ret = avcodec_encode_video(enc,
bit_buffer, bit_buffer_size,
pkt.data= bit_buffer;
pkt.size= ret;
if(enc->coded_frame)
- pkt.pts= enc->coded_frame->pts;
+ pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
- pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
- pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
+ pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
+ pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
if(enc->coded_frame && enc->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
fprintf(fvstats,"f_size= %6d ", frame_size);
/* compute pts value */
- ti1 = (double)ost->sync_opts *enc->frame_rate_base / enc->frame_rate;
+ ti1 = ost->sync_opts * av_q2d(enc->time_base);
if (ti1 < 0.01)
ti1 = 0.01;
- bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
+ bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
(double)video_size / 1024, ti1, bitrate, avg_bitrate);
if(!pkt){
ist->pts= ist->next_pts; // needed for last packet if vsync=0
} else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
- ist->next_pts = ist->pts = pkt->dts;
+ ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
} else {
// assert(ist->pts == ist->next_pts);
}
/* no picture yet */
goto discard_packet;
}
- if (ist->st->codec.frame_rate_base != 0) {
+ if (ist->st->codec.time_base.num != 0) {
ist->next_pts += ((int64_t)AV_TIME_BASE *
- ist->st->codec.frame_rate_base) /
- ist->st->codec.frame_rate;
+ ist->st->codec.time_base.num) /
+ ist->st->codec.time_base.den;
}
len = 0;
break;
(ist->st->codec.sample_rate * ist->st->codec.channels);
break;
case CODEC_TYPE_VIDEO:
- if (ist->st->codec.frame_rate_base != 0) {
+ if (ist->st->codec.time_base.num != 0) {
ist->next_pts += ((int64_t)AV_TIME_BASE *
- ist->st->codec.frame_rate_base) /
- ist->st->codec.frame_rate;
+ ist->st->codec.time_base.num) /
+ ist->st->codec.time_base.den;
}
break;
}
/* frame rate emulation */
if (ist->st->codec.rate_emu) {
- int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
+ int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.time_base.num, 1000000, ist->st->codec.time_base.den);
int64_t now = av_gettime() - ist->start;
if (pts > now)
usleep(pts - now);
opkt.data= data_buf;
opkt.size= data_size;
if(pkt->pts != AV_NOPTS_VALUE)
- opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
+ opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
else
opkt.pts= AV_NOPTS_VALUE;
- opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
+ opkt.dts= av_rescale_q(av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
opkt.flags= pkt->flags;
av_interleaved_write_frame(os, &opkt);
pkt.data= bit_buffer;
pkt.size= ret;
if(enc->coded_frame)
- pkt.pts= enc->coded_frame->pts;
+ pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
av_interleaved_write_frame(os, &pkt);
}
}
codec->block_align= icodec->block_align;
break;
case CODEC_TYPE_VIDEO:
- codec->frame_rate = icodec->frame_rate;
- codec->frame_rate_base = icodec->frame_rate_base;
+ codec->time_base = icodec->time_base;
codec->width = icodec->width;
codec->height = icodec->height;
codec->has_b_frames = icodec->has_b_frames;
ist = ist_table[i];
is = input_files[ist->file_index];
ist->pts = 0;
- ist->next_pts = ist->st->start_time;
+ ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
if(ist->next_pts == AV_NOPTS_VALUE)
ist->next_pts=0;
if(input_files_ts_offset[ist->file_index])
os = output_files[ost->file_index];
ist = ist_table[ost->source_index];
if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
- opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
+ opts = ost->sync_opts * av_q2d(ost->st->codec.time_base);
else
- opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
+ opts = ost->st->pts.val * av_q2d(ost->st->time_base);
ipts = (double)ist->pts;
if (!file_table[ist->file_index].eof_reached){
if(ipts < ipts_min) {
// fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec.codec_type);
if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
- int64_t delta= pkt.dts - ist->next_pts;
+ int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
input_files_ts_offset[ist->file_index]-= delta;
if (verbose > 2)
memset(ap, 0, sizeof(*ap));
ap->sample_rate = audio_sample_rate;
ap->channels = audio_channels;
- ap->frame_rate = frame_rate;
- ap->frame_rate_base = frame_rate_base;
+ ap->time_base.den = frame_rate;
+ ap->time_base.num = frame_rate_base;
ap->width = frame_width + frame_padleft + frame_padright;
ap->height = frame_height + frame_padtop + frame_padbottom;
ap->image_format = image_format;
frame_width = enc->width;
frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
frame_pix_fmt = enc->pix_fmt;
- rfps = ic->streams[i]->r_frame_rate;
- rfps_base = ic->streams[i]->r_frame_rate_base;
+ rfps = ic->streams[i]->r_frame_rate.num;
+ rfps_base = ic->streams[i]->r_frame_rate.den;
enc->workaround_bugs = workaround_bugs;
enc->error_resilience = error_resilience;
enc->error_concealment = error_concealment;
if(me_threshold)
enc->debug |= FF_DEBUG_MV;
- if (enc->frame_rate != rfps || enc->frame_rate_base != rfps_base) {
+ if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
if (verbose >= 0)
fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
- i, (float)enc->frame_rate / enc->frame_rate_base, enc->frame_rate, enc->frame_rate_base,
+ i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
(float)rfps / rfps_base, rfps, rfps_base);
}
video_enc->bit_rate = video_bit_rate;
video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
- video_enc->frame_rate = frame_rate;
- video_enc->frame_rate_base = frame_rate_base;
+ video_enc->time_base.den = frame_rate;
+ video_enc->time_base.num = frame_rate_base;
if(codec && codec->supported_framerates){
const AVRational *p= codec->supported_framerates;
AVRational req= (AVRational){frame_rate, frame_rate_base};
best= p;
}
}
- video_enc->frame_rate = best->num;
- video_enc->frame_rate_base= best->den;
+ video_enc->time_base.den= best->num;
+ video_enc->time_base.num= best->den;
}
video_enc->width = frame_width + frame_padright + frame_padleft;
has_audio = 0;
memset(ap, 0, sizeof(*ap));
memset(vp, 0, sizeof(*vp));
- vp->frame_rate_base= 1;
+ vp->time_base.num= 1;
for(j=0;j<nb_output_files;j++) {
oc = output_files[j];
for(i=0;i<oc->nb_streams;i++) {
if (enc->height > vp->height)
vp->height = enc->height;
- if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
- vp->frame_rate = enc->frame_rate;
- vp->frame_rate_base = enc->frame_rate_base;
+ if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
+ vp->time_base = enc->time_base;
}
has_video = 1;
break;
exit(1);
}
/* by now video grab has one stream */
- ic->streams[0]->r_frame_rate = vp->frame_rate;
- ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
+ ic->streams[0]->r_frame_rate.num = vp->time_base.den;
+ ic->streams[0]->r_frame_rate.den = vp->time_base.num;
input_files[nb_input_files] = ic;
if (verbose >= 0)
AVCodecContext *c = &input_files[j]->streams[i]->codec;
if(c->codec_type != CODEC_TYPE_VIDEO)
continue;
- fr = c->frame_rate * 1000 / c->frame_rate_base;
+ fr = c->time_base.den * 1000 / c->time_base.num;
if(fr == 25000) {
norm = 0;
break;
pts = is->video_clock;
}
/* update video clock for next frame */
- frame_delay = (double)is->video_st->codec.frame_rate_base /
- (double)is->video_st->codec.frame_rate;
+ frame_delay = av_q2d(is->video_st->codec.time_base);
/* for MPEG2, the frame can be repeated, so we update the
clock accordingly */
if (src_frame->repeat_pict) {
this packet, if any */
pts = 0;
if (pkt->dts != AV_NOPTS_VALUE)
- pts = (double)pkt->dts / AV_TIME_BASE;
+ pts = av_q2d(is->video_st->time_base)*pkt->dts;
SDL_LockMutex(is->video_decoder_mutex);
len1 = avcodec_decode_video(&is->video_st->codec,
/* if update the audio clock with the pts */
if (pkt->pts != AV_NOPTS_VALUE) {
- is->audio_clock = (double)pkt->pts / AV_TIME_BASE;
+ is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
}
}
}
case CODEC_TYPE_VIDEO:
type = "video";
snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec.width, st->codec.height,
- st->codec.qmin, st->codec.qmax, st->codec.frame_rate / st->codec.frame_rate_base);
+ st->codec.qmin, st->codec.qmax, st->codec.time_base.den / st->codec.time_base.num);
break;
default:
av_abort();
} else {
/* update first pts if needed */
if (c->first_pts == AV_NOPTS_VALUE) {
- c->first_pts = pkt.dts;
+ c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
c->start_time = cur_time;
}
/* send it to the appropriate stream */
AVStream *st;
/* compute send time and duration */
st = c->fmt_in->streams[pkt.stream_index];
- c->cur_pts = pkt.dts;
+ c->cur_pts = av_rescale_q(pkt.dts, st->time_base, AV_TIME_BASE_Q);
if (st->start_time != AV_NOPTS_VALUE)
- c->cur_pts -= st->start_time;
- c->cur_frame_duration = pkt.duration;
+ c->cur_pts -= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
+ c->cur_frame_duration = av_rescale_q(pkt.duration, st->time_base, AV_TIME_BASE_Q);
#if 0
printf("index=%d pts=%0.3f duration=%0.6f\n",
pkt.stream_index,
case CODEC_TYPE_VIDEO:
if (av1->width == av->width &&
av1->height == av->height &&
- av1->frame_rate == av->frame_rate &&
- av1->frame_rate_base == av->frame_rate_base &&
+ av1->time_base.den == av->time_base.den &&
+ av1->time_base.num == av->time_base.num &&
av1->gop_size == av->gop_size)
goto found;
break;
printf("Codec bitrates do not match for stream %d\n", i);
matches = 0;
} else if (ccf->codec_type == CODEC_TYPE_VIDEO) {
- if (CHECK_CODEC(frame_rate) ||
- CHECK_CODEC(frame_rate_base) ||
+ if (CHECK_CODEC(time_base.den) ||
+ CHECK_CODEC(time_base.num) ||
CHECK_CODEC(width) ||
CHECK_CODEC(height)) {
printf("Codec width, height and framerate do not match for stream %d\n", i);
case CODEC_TYPE_VIDEO:
if (av->bit_rate == 0)
av->bit_rate = 64000;
- if (av->frame_rate == 0){
- av->frame_rate = 5;
- av->frame_rate_base = 1;
+ if (av->time_base.num == 0){
+ av->time_base.den = 5;
+ av->time_base.num = 1;
}
if (av->width == 0 || av->height == 0) {
av->width = 160;
} else if (!strcasecmp(cmd, "VideoFrameRate")) {
get_arg(arg, sizeof(arg), &p);
if (stream) {
- video_enc.frame_rate_base= DEFAULT_FRAME_RATE_BASE;
- video_enc.frame_rate = (int)(strtod(arg, NULL) * video_enc.frame_rate_base);
+ video_enc.time_base.num= DEFAULT_FRAME_RATE_BASE;
+ video_enc.time_base.den = (int)(strtod(arg, NULL) * video_enc.time_base.num);
}
} else if (!strcasecmp(cmd, "VideoGopSize")) {
get_arg(arg, sizeof(arg), &p);
c->width = 352;
c->height = 288;
/* frames per second */
- c->frame_rate = 25;
- c->frame_rate_base= 1;
+ c->time_base= (AVRational){1,25};
c->gop_size = 10; /* emit one intra frame every ten frames */
c->max_b_frames=1;
#define FFMPEG_VERSION_INT 0x000409
#define FFMPEG_VERSION "0.4.9-pre1"
-#define LIBAVCODEC_BUILD 4753
+#define LIBAVCODEC_BUILD 4754
#define LIBAVCODEC_VERSION_INT FFMPEG_VERSION_INT
#define LIBAVCODEC_VERSION FFMPEG_VERSION
#define AV_NOPTS_VALUE int64_t_C(0x8000000000000000)
#define AV_TIME_BASE 1000000
+#define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE}
enum CodecID {
CODEC_ID_NONE,
int pict_type;\
\
/**\
- * presentation timestamp in AV_TIME_BASE (=micro seconds currently) (time when frame should be shown to user)\
- * if AV_NOPTS_VALUE then the frame_rate will be used as reference\
+ * presentation timestamp in time_base units (time when frame should be shown to user)\
+ * if AV_NOPTS_VALUE then frame_rate = 1/time_base will be assumed\
* - encoding: MUST be set by user\
* - decoding: set by lavc\
*/\
/* video only */
/**
- * frames per sec multiplied by frame_rate_base.
- * for variable fps this is the precission, so if the timestamps
- * can be specified in msec precssion then this is 1000*frame_rate_base
+ * time base in which the timestamps are specified.
* - encoding: MUST be set by user
- * - decoding: set by lavc. 0 or the frame_rate if available
+ * - decoding: set by lavc.
*/
- int frame_rate;
+ AVRational time_base;
/**
* picture width / height.
*/
int me_range;
- /**
- * frame_rate_base.
- * for variable fps this is 1
- * - encoding: set by user.
- * - decoding: set by lavc.
- * @todo move this after frame_rate
- */
-
- int frame_rate_base;
/**
* intra quantizer bias.
* - encoding: set by user.
*/
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding);
+/**
+ * rescale a 64bit integer by 2 rational numbers.
+ */
+int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq);
+
/* frame parsing */
typedef struct AVCodecParserContext {
void *priv_data;
put_bits(&s->pb, 20, 0x10); /* PSC */
- temp_ref= s->picture_number * (int64_t)30000 * s->avctx->frame_rate_base /
- (1001 * (int64_t)s->avctx->frame_rate);
+ temp_ref= s->picture_number * (int64_t)30000 * s->avctx->time_base.num /
+ (1001 * (int64_t)s->avctx->time_base.den); //FIXME maybe this should use a timestamp
put_bits(&s->pb, 5, temp_ref & 0x1f); /* TemporalReference */
put_bits(&s->pb, 1, 0); /* split screen off */
put_bits(&s->pb, 17, 1);
put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
- put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
- s->avctx->frame_rate) & 0xff); /* TemporalReference */
+ put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
+ s->avctx->time_base.den) & 0xff); /* TemporalReference */
if (s->width == 352 && s->height == 288)
format = 2;
else if (s->width == 176 && s->height == 144)
if(s->h263_plus){
for(i=0; i<2; i++){
int div, error;
- div= (s->avctx->frame_rate_base*1800000LL + 500LL*s->avctx->frame_rate) / ((1000LL+i)*s->avctx->frame_rate);
+ div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
div= clip(1, div, 127);
- error= ABS(s->avctx->frame_rate_base*1800000LL - (1000LL+i)*s->avctx->frame_rate*div);
+ error= ABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
if(error < best_error){
best_error= error;
best_divisor= div;
/* Update the pointer to last GOB */
s->ptr_lastgob = pbBufPtr(&s->pb);
put_bits(&s->pb, 22, 0x20); /* PSC */
- temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->frame_rate_base /
- (coded_frame_rate_base * (int64_t)s->avctx->frame_rate);
+ temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
+ (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
put_bits(&s->pb, 1, 1); /* marker */
int time_div, time_mod;
assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
- s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
+ s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
- time_div= s->time/s->time_increment_resolution;
- time_mod= s->time%s->time_increment_resolution;
+ time_div= s->time/s->avctx->time_base.den;
+ time_mod= s->time%s->avctx->time_base.den;
if(s->pict_type==B_TYPE){
s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
time= s->current_picture_ptr->pts;
if(s->reordered_input_picture[1])
time= FFMIN(time, s->reordered_input_picture[1]->pts);
- time= (time*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
+ time= time*s->avctx->time_base.num;
- seconds= time/s->time_increment_resolution;
+ seconds= time/s->avctx->time_base.den;
minutes= seconds/60; seconds %= 60;
hours= minutes/60; minutes %= 60;
hours%=24;
put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
put_bits(&s->pb, 1, 0); //broken link == NO
- s->last_time_base= time / s->time_increment_resolution;
+ s->last_time_base= time / s->avctx->time_base.den;
ff_mpeg4_stuffing(&s->pb);
}
put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
put_bits(&s->pb, 1, 1); /* marker bit */
- put_bits(&s->pb, 16, s->time_increment_resolution);
+ put_bits(&s->pb, 16, s->avctx->time_base.den);
if (s->time_increment_bits < 1)
s->time_increment_bits = 1;
put_bits(&s->pb, 1, 1); /* marker bit */
s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
-//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
+//printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
put_bits(&s->pb, 16, 0); /* vop header */
put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
- time_div= s->time/s->time_increment_resolution;
- time_mod= s->time%s->time_increment_resolution;
+ time_div= s->time/s->avctx->time_base.den;
+ time_mod= s->time%s->avctx->time_base.den;
time_incr= time_div - s->last_time_base;
assert(time_incr >= 0);
while(time_incr--)
s->width = width;
s->height = height;
s->avctx->sample_aspect_ratio= (AVRational){12,11};
- s->avctx->frame_rate = 30000;
- s->avctx->frame_rate_base= 1001;
+ s->avctx->time_base= (AVRational){1001, 30000};
} else {
int ufep;
if(s->custom_pcf){
int gcd;
- s->avctx->frame_rate= 1800000;
- s->avctx->frame_rate_base= 1000 + get_bits1(&s->gb);
- s->avctx->frame_rate_base*= get_bits(&s->gb, 7);
- if(s->avctx->frame_rate_base == 0){
+ s->avctx->time_base.den= 1800000;
+ s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
+ s->avctx->time_base.num*= get_bits(&s->gb, 7);
+ if(s->avctx->time_base.num == 0){
av_log(s, AV_LOG_ERROR, "zero framerate\n");
return -1;
}
- gcd= ff_gcd(s->avctx->frame_rate, s->avctx->frame_rate_base);
- s->avctx->frame_rate /= gcd;
- s->avctx->frame_rate_base /= gcd;
-// av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->frame_rate, s->avctx->frame_rate_base);
+ gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
+ s->avctx->time_base.den /= gcd;
+ s->avctx->time_base.num /= gcd;
+// av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
}else{
- s->avctx->frame_rate = 30000;
- s->avctx->frame_rate_base= 1001;
+ s->avctx->time_base= (AVRational){1001, 30000};
}
}
s->modified_quant ? " MQ" : "",
s->loop_filter ? " LOOP" : "",
s->h263_slice_structured ? " SS" : "",
- s->avctx->frame_rate, s->avctx->frame_rate_base
+ s->avctx->time_base.den, s->avctx->time_base.num
);
}
#if 1
check_marker(gb, "before time_increment_resolution");
- s->time_increment_resolution = get_bits(gb, 16);
+ s->avctx->time_base.den = get_bits(gb, 16);
- s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
+ s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
if (s->time_increment_bits < 1)
s->time_increment_bits = 1;
check_marker(gb, "before fixed_vop_rate");
if (get_bits1(gb) != 0) { /* fixed_vop_rate */
- skip_bits(gb, s->time_increment_bits);
- }
-
+ s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
+ }else
+ s->avctx->time_base.num = 1;
+
s->t_frame=0;
if (s->shape != BIN_ONLY_SHAPE) {
else
s->decode_mb= ff_mpeg4_decode_mb;
- if(s->time_increment_resolution==0){
- s->time_increment_resolution=1;
+ if(s->avctx->time_base.den==0){
+ s->avctx->time_base.den=1;
// fprintf(stderr, "time_increment_resolution is illegal\n");
}
time_incr=0;
if(s->pict_type!=B_TYPE){
s->last_time_base= s->time_base;
s->time_base+= time_incr;
- s->time= s->time_base*s->time_increment_resolution + time_increment;
+ s->time= s->time_base*s->avctx->time_base.den + time_increment;
if(s->workaround_bugs&FF_BUG_UMP4){
if(s->time < s->last_non_b_time){
// fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
s->time_base++;
- s->time+= s->time_increment_resolution;
+ s->time+= s->avctx->time_base.den;
}
}
s->pp_time= s->time - s->last_non_b_time;
s->last_non_b_time= s->time;
}else{
- s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
+ s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
// printf("messed up order, maybe after seeking? skipping current b frame\n");
}
//av_log(s->avctx, AV_LOG_DEBUG, "last nonb %Ld last_base %d time %Ld pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time);
- s->current_picture_ptr->pts= s->time*(int64_t)AV_TIME_BASE / s->time_increment_resolution;
+ s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
if(s->avctx->debug&FF_DEBUG_PTS)
- av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %f\n", s->current_picture_ptr->pts/(float)AV_TIME_BASE);
+ av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %f\n", s->current_picture_ptr->pts);
check_marker(gb, "before vop_coded");
av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
return FRAME_SKIPPED;
}
-//printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
+//printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
|| (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
s->avctx->sample_aspect_ratio.den = 1;
if(h->sps.timing_info_present_flag && h->sps.fixed_frame_rate_flag){
- s->avctx->frame_rate = h->sps.time_scale;
- s->avctx->frame_rate_base = h->sps.num_units_in_tick;
+ s->avctx->time_base= (AVRational){h->sps.num_units_in_tick, h->sps.time_scale};
}
}
int64_t d;
for(i=1;i<14;i++) {
- int64_t n0= 1001LL/frame_rate_tab[i].den*frame_rate_tab[i].num*s->avctx->frame_rate_base;
- int64_t n1= 1001LL*s->avctx->frame_rate;
+ int64_t n0= 1001LL/frame_rate_tab[i].den*frame_rate_tab[i].num*s->avctx->time_base.num;
+ int64_t n1= 1001LL*s->avctx->time_base.den;
if(s->avctx->strict_std_compliance >= 0 && i>=9) break;
d = ABS(n0 - n1);
if(find_frame_rate_index(s) < 0){
if(s->strict_std_compliance >=0){
- av_log(avctx, AV_LOG_ERROR, "MPEG1/2 does not support %d/%d fps\n", avctx->frame_rate, avctx->frame_rate_base);
+ av_log(avctx, AV_LOG_ERROR, "MPEG1/2 does not support %d/%d fps\n", avctx->time_base.den, avctx->time_base.num);
return -1;
}else{
- av_log(avctx, AV_LOG_INFO, "MPEG1/2 does not support %d/%d fps, there may be AV sync issues\n", avctx->frame_rate, avctx->frame_rate_base);
+ av_log(avctx, AV_LOG_INFO, "MPEG1/2 does not support %d/%d fps, there may be AV sync issues\n", avctx->time_base.den, avctx->time_base.num);
}
}
if(avctx->sub_id==1){//s->codec_id==avctx->codec_id==CODEC_ID
//mpeg1 fps
- avctx->frame_rate = frame_rate_tab[s->frame_rate_index].num;
- avctx->frame_rate_base= frame_rate_tab[s->frame_rate_index].den;
+ avctx->time_base.den = frame_rate_tab[s->frame_rate_index].num;
+ avctx->time_base.num= frame_rate_tab[s->frame_rate_index].den;
//mpeg1 aspect
avctx->sample_aspect_ratio= av_d2q(
1.0/mpeg1_aspect[s->aspect_ratio_info], 255);
}else{//mpeg2
//mpeg2 fps
av_reduce(
- &s->avctx->frame_rate,
- &s->avctx->frame_rate_base,
+ &s->avctx->time_base.den,
+ &s->avctx->time_base.num,
frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1<<30);
if(s->avctx->thread_count > 1)
s->rtp_mode= 1;
- if(!avctx->frame_rate || !avctx->frame_rate_base){
+ if(!avctx->time_base.den || !avctx->time_base.num){
av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
return -1;
}
return -1;
}
- i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
+ i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
if(i > 1){
av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
- avctx->frame_rate /= i;
- avctx->frame_rate_base /= i;
+ avctx->time_base.den /= i;
+ avctx->time_base.num /= i;
// return -1;
}
avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
- av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
- s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
+ if(s->avctx->time_base.den > (1<<16)-1){
+ av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
+ return -1;
+ }
+ s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
switch(avctx->codec->id) {
case CODEC_ID_MPEG1VIDEO:
if(pts != AV_NOPTS_VALUE){
if(s->user_specified_pts != AV_NOPTS_VALUE){
- int64_t time= av_rescale(pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
- int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
+ int64_t time= pts;
+ int64_t last= s->user_specified_pts;
if(time <= last){
av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pts, s->user_specified_pts);
}else{
if(s->user_specified_pts != AV_NOPTS_VALUE){
s->user_specified_pts=
- pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
+ pts= s->user_specified_pts + 1;
av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pts);
}else{
- pts= av_rescale(pic_arg->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
+ pts= pic_arg->display_picture_number;
}
}
}
int custom_pcf;
/* mpeg4 specific */
- int time_increment_resolution;
int time_increment_bits; ///< number of bits to represent the fractional part of time
int last_time_base;
int time_base; ///< time in seconds of last I,P,S Frame
void msmpeg4_encode_ext_header(MpegEncContext * s)
{
- put_bits(&s->pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
+ put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
op2->packet = context->buffer + sizeof(ogg_packet);
l= op2->bytes;
- avccontext->coded_frame->pts= av_rescale(op2->granulepos, AV_TIME_BASE, avccontext->sample_rate);
+ avccontext->coded_frame->pts= op2->granulepos;
memcpy(packets, op2->packet, l);
context->buffer_index -= l + sizeof(ogg_packet);
}
avccontext->channels = context->vi.channels;
avccontext->sample_rate = context->vi.rate;
+ avccontext->time_base= (AVRational){1, avccontext->sample_rate};
vorbis_synthesis_init(&context->vd, &context->vi);
vorbis_block_init(&context->vd, &context->vb);
25025,
};
+//FIXME move into mpeg12.c
static void mpegvideo_extract_headers(AVCodecParserContext *s,
AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
avcodec_set_dimensions(avctx, pc->width, pc->height);
frame_rate_index = buf[3] & 0xf;
- pc->frame_rate = avctx->frame_rate = frame_rate_tab[frame_rate_index];
- avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE;
+ pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
+ avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
avctx->codec_id = CODEC_ID_MPEG1VIDEO;
avctx->sub_id = 1;
pc->height |=( vert_size_ext << 12);
avctx->bit_rate += (bit_rate_ext << 18) * 400;
avcodec_set_dimensions(avctx, pc->width, pc->height);
- avctx->frame_rate = pc->frame_rate * (frame_rate_ext_n + 1);
- avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
+ avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
+ avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
avctx->codec_id = CODEC_ID_MPEG2VIDEO;
avctx->sub_id = 2; /* forces MPEG2 */
}
mpegvideo_extract_headers(s, avctx, buf, buf_size);
#if 0
printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
- s->pict_type, (double)avctx->frame_rate / avctx->frame_rate_base, s->repeat_pict);
+ s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
#endif
*poutbuf = (uint8_t *)buf;
bits= rce.i_tex_bits + rce.p_tex_bits;
q= get_qscale(s, &rce, rcc->pass1_wanted_bits/rcc->pass1_rc_eq_output_sum, i);
- rcc->pass1_wanted_bits+= s->bit_rate/(s->avctx->frame_rate / (double)s->avctx->frame_rate_base);
+ rcc->pass1_wanted_bits+= s->bit_rate/(1/av_q2d(s->avctx->time_base)); //FIXME missbehaves a little for variable fps
}
}
int ff_vbv_update(MpegEncContext *s, int frame_size){
RateControlContext *rcc= &s->rc_context;
- const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
+ const double fps= 1/av_q2d(s->avctx->time_base);
const int buffer_size= s->avctx->rc_buffer_size;
const double min_rate= s->avctx->rc_min_rate/fps;
const double max_rate= s->avctx->rc_max_rate/fps;
double bits;
const int pict_type= rce->new_pict_type;
const double buffer_size= s->avctx->rc_buffer_size;
- const double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
+ const double fps= 1/av_q2d(s->avctx->time_base);
const double min_rate= s->avctx->rc_min_rate / fps;
const double max_rate= s->avctx->rc_max_rate / fps;
get_qminmax(&qmin, &qmax, s, pict_type);
- fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
+ fps= 1/av_q2d(s->avctx->time_base);
//printf("input_pic_num:%d pic_num:%d frame_rate:%d\n", s->input_picture_number, s->picture_number, s->frame_rate);
/* update predictors */
if(picture_number>2){
RateControlContext *rcc= &s->rc_context;
AVCodecContext *a= s->avctx;
int i;
- double fps= (double)s->avctx->frame_rate / (double)s->avctx->frame_rate_base;
+ double fps= 1/av_q2d(s->avctx->time_base);
double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1
double avg_quantizer[5];
uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits
s->error_concealment= 3;
s->error_resilience= 1;
s->workaround_bugs= FF_BUG_AUTODETECT;
- s->frame_rate_base= 1;
- s->frame_rate = 25;
+ s->time_base= (AVRational){0,1};
s->gop_size= 50;
s->me_method= ME_EPZS;
s->get_buffer= avcodec_default_get_buffer;
snprintf(buf + strlen(buf), buf_size - strlen(buf),
", %dx%d, %0.2f fps",
enc->width, enc->height,
- (float)enc->frame_rate / enc->frame_rate_base);
+ 1/av_q2d(enc->time_base));
}
if (encode) {
snprintf(buf + strlen(buf), buf_size - strlen(buf),
return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
}
+int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq){
+ int64_t b= bq.num * (int64_t)cq.den;
+ int64_t c= cq.num * (int64_t)bq.den;
+ return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
+}
+
int64_t ff_gcd(int64_t a, int64_t b){
if(b) return ff_gcd(b, a%b);
else return a;
av_log(avctx, AV_LOG_ERROR,
"Reserved FRAMERATEDR %i not handled\n", dr);
}
- avctx->frame_rate_base = fps_nr[dr];
- avctx->frame_rate = fps_nr[nr];
+ avctx->time_base.num = fps_nr[dr];
+ avctx->time_base.den = fps_nr[nr];
}
else
{
nr = get_bits(gb, 16);
// 0.03125->2048Hz / 0.03125Hz
- avctx->frame_rate = 1000000;
- avctx->frame_rate_base = 31250*(1+nr);
+ avctx->time_base.den = 1000000;
+ avctx->time_base.num = 31250*(1+nr);
}
}
init_put_bits(&pb, s->avctx->extradata, s->avctx->extradata_size);
- put_bits(&pb, 5, s->avctx->frame_rate / s->avctx->frame_rate_base); //yes 29.97 -> 29
+ put_bits(&pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
put_bits(&pb, 11, FFMIN(s->bit_rate/1024, 2047));
put_bits(&pb, 1, w->mspel_bit=1);
x4->params.i_height = avctx->height;
x4->params.vui.i_sar_width = avctx->sample_aspect_ratio.num;
x4->params.vui.i_sar_height = avctx->sample_aspect_ratio.den;
- x4->params.i_fps_num = avctx->frame_rate;
- x4->params.i_fps_den = avctx->frame_rate_base;
+ x4->params.i_fps_num = avctx->time_base.den;
+ x4->params.i_fps_den = avctx->time_base.num;
x4->enc = x264_encoder_open(&x4->params);
if(!x4->enc)
/* Frame Rate and Key Frames */
xvid_correct_framerate(avctx);
- xvid_enc_create.fincr = avctx->frame_rate_base;
- xvid_enc_create.fbase = avctx->frame_rate;
+ xvid_enc_create.fincr = avctx->time_base.num;
+ xvid_enc_create.fbase = avctx->time_base.den;
if( avctx->gop_size > 0 )
xvid_enc_create.max_key_interval = avctx->gop_size;
else
int gcd;
float est_fps, fps;
- frate = avctx->frame_rate;
- fbase = avctx->frame_rate_base;
+ frate = avctx->time_base.den;
+ fbase = avctx->time_base.num;
gcd = ff_gcd(frate, fbase);
if( gcd > 1 ) {
}
if( frate <= 65000 && fbase <= 65000 ) {
- avctx->frame_rate = frate;
- avctx->frame_rate_base = fbase;
+ avctx->time_base.den = frate;
+ avctx->time_base.num = fbase;
return;
}
}
if( fbase > est_fbase ) {
- avctx->frame_rate = est_frate;
- avctx->frame_rate_base = est_fbase;
+ avctx->time_base.den = est_frate;
+ avctx->time_base.num = est_fbase;
av_log(avctx, AV_LOG_DEBUG,
"XviD: framerate re-estimated: %.2f, %.3f%% correction\n",
est_fps, (((est_fps - fps)/fps) * 100.0));
} else {
- avctx->frame_rate = frate;
- avctx->frame_rate_base = fbase;
+ avctx->time_base.den = frate;
+ avctx->time_base.num = fbase;
}
}
fourxm->video_stream_index = st->index;
- st->codec.frame_rate = fourxm->fps;
- st->codec.frame_rate_base = 1.0;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_4XM;
st->codec.codec_tag = 0; /* no fourcc */
duration = (codec->frame_number * (int64_t)codec->frame_size * int64_t_C(10000000)) /
codec->sample_rate;
} else {
- duration = av_rescale(codec->frame_number * (int64_t)codec->frame_rate_base, 10000000, codec->frame_rate);
+ duration = av_rescale(codec->frame_number * (int64_t)codec->time_base.num, 10000000, codec->time_base.den);
}
} else {
duration = pts * 10000;
if (!asf_st)
goto fail;
st->priv_data = asf_st;
- st->start_time = asf->hdr.preroll * (int64_t)AV_TIME_BASE / 1000;
+ st->start_time = asf->hdr.preroll;
st->duration = asf->hdr.send_time /
- (10000000 / AV_TIME_BASE) - st->start_time;
+ (10000000 / 1000) - st->start_time;
get_guid(pb, &g);
if (!memcmp(&g, &audio_stream, sizeof(GUID))) {
type = CODEC_TYPE_AUDIO;
get_le32(pb);
st->codec.codec_type = type;
- /* 1 fps default (XXX: put 0 fps instead) */
- st->codec.frame_rate = 1000;
- st->codec.frame_rate_base = 1;
if (type == CODEC_TYPE_AUDIO) {
get_wav_header(pb, &st->codec, type_specific_size);
st->need_parsing = 1;
extern "C" {
#endif
-#define LIBAVFORMAT_BUILD 4623
+#define LIBAVFORMAT_BUILD 4624
#define LIBAVFORMAT_VERSION_INT FFMPEG_VERSION_INT
#define LIBAVFORMAT_VERSION FFMPEG_VERSION
#define AVPROBE_SCORE_MAX 100
typedef struct AVFormatParameters {
- int frame_rate;
- int frame_rate_base;
+ AVRational time_base;
int sample_rate;
int channels;
int width;
int index; /* stream index in AVFormatContext */
int id; /* format specific stream id */
AVCodecContext codec; /* codec context */
- int r_frame_rate; /* real frame rate of the stream */
- int r_frame_rate_base;/* real frame rate base of the stream */
+ AVRational r_frame_rate; /* real frame rate of the stream */
void *priv_data;
/* internal data used in av_find_stream_info() */
int64_t codec_info_duration;
nb_frames = get_le32(pb);
st->start_time = 0;
- st->duration = av_rescale(nb_frames, ast->scale*(int64_t)AV_TIME_BASE, ast->rate);
+ st->duration = nb_frames;
get_le32(pb); /* buffer size */
get_le32(pb); /* quality */
ast->sample_size = get_le32(pb); /* sample ssize */
codec_type = CODEC_TYPE_VIDEO;
ast->sample_size = 0;
- st->codec.frame_rate = ast->rate;
- st->codec.frame_rate_base = ast->scale;
break;
case MKTAG('a', 'u', 'd', 's'):
codec_type = CODEC_TYPE_AUDIO;
*au_scale=stream->frame_size;
*au_rate= stream->sample_rate;
}else if(stream->codec_type == CODEC_TYPE_VIDEO){
- *au_scale= stream->frame_rate_base;
- *au_rate = stream->frame_rate;
+ *au_scale= stream->time_base.num;
+ *au_rate = stream->time_base.den;
}else{
*au_scale= stream->block_align ? stream->block_align*8 : 8;
*au_rate = stream->bit_rate;
nb_frames = 0;
if(video_enc){
- put_le32(pb, (uint32_t)(int64_t_C(1000000) * video_enc->frame_rate_base / video_enc->frame_rate));
+ put_le32(pb, (uint32_t)(int64_t_C(1000000) * video_enc->time_base.num / video_enc->time_base.den));
} else {
put_le32(pb, 0);
}
put_le16(pb, 0); /* language */
put_le32(pb, 0); /* initial frame */
- put_le32(pb, stream->frame_rate_base); /* scale */
- put_le32(pb, stream->frame_rate); /* rate */
- av_set_pts_info(s->streams[i], 64, stream->frame_rate_base, stream->frame_rate);
+ put_le32(pb, stream->time_base.num); /* scale */
+ put_le32(pb, stream->time_base.den); /* rate */
+ av_set_pts_info(s->streams[i], 64, stream->time_base.num, stream->time_base.den);
put_le32(pb, 0); /* start */
avi->frames_hdr_strm[i] = url_ftell(pb); /* remember this offset to fill later */
break;
for (fps = dc1394_frame_rates; fps->frame_rate; fps++)
- if (fps->frame_rate == av_rescale(1000, ap->frame_rate, ap->frame_rate_base))
+ if (fps->frame_rate == av_rescale(1000, ap->time_base.den, ap->time_base.num))
break;
/* create a video stream */
av_set_pts_info(vst, 64, 1, 1000);
vst->codec.codec_type = CODEC_TYPE_VIDEO;
vst->codec.codec_id = CODEC_ID_RAWVIDEO;
- vst->codec.frame_rate = fps->frame_rate;
- vst->codec.frame_rate_base = 1000;
+ vst->codec.time_base.den = fps->frame_rate;
+ vst->codec.time_base.num = 1000;
vst->codec.width = fmt->width;
vst->codec.height = fmt->height;
vst->codec.pix_fmt = fmt->pix_fmt;
if (sys) {
avctx = &c->vst->codec;
- avctx->frame_rate = sys->frame_rate;
- avctx->frame_rate_base = sys->frame_rate_base;
av_set_pts_info(c->vst, 64, sys->frame_rate_base, sys->frame_rate);
+ avctx->time_base= (AVRational){sys->frame_rate_base, sys->frame_rate};
avctx->width = sys->width;
avctx->height = sys->height;
avctx->pix_fmt = sys->pix_fmt;
/* specific info */
switch(codec->codec_type) {
case CODEC_TYPE_VIDEO:
- put_be32(pb, codec->frame_rate_base);
- put_be32(pb, codec->frame_rate);
+ put_be32(pb, codec->time_base.num);
+ put_be32(pb, codec->time_base.den);
put_be16(pb, codec->width);
put_be16(pb, codec->height);
put_be16(pb, codec->gop_size);
if (st->codec.codec_type == CODEC_TYPE_AUDIO) {
duration = ((float)st->codec.frame_size / st->codec.sample_rate * 1000000.0);
} else {
- duration = (1000000.0 * st->codec.frame_rate_base / (float)st->codec.frame_rate);
+ duration = (1000000.0 * st->codec.time_base.num / (float)st->codec.time_base.den);
}
pts = fst->pts;
/* specific info */
switch(codec->codec_type) {
case CODEC_TYPE_VIDEO:
- codec->frame_rate_base = get_be32(pb);
- codec->frame_rate = get_be32(pb);
+ codec->time_base.num = get_be32(pb);
+ codec->time_base.den = get_be32(pb);
codec->width = get_be16(pb);
codec->height = get_be16(pb);
codec->gop_size = get_be16(pb);
return AVERROR_NOMEM;
av_set_pts_info(st, 24, 1, 1000); /* 24 bit pts in ms */
- st->codec.frame_rate_base= 1;
- st->codec.frame_rate= 1000;
+ st->codec.time_base= (AVRational){1,1000};
}
// av_log(NULL, AV_LOG_DEBUG, "%d %X %d \n", is_audio, flags, st->discard);
if( (st->discard >= AVDISCARD_NONKEY && !((flags >> 4)==1 || is_audio))
} else {
width = video_enc->width;
height = video_enc->height;
-// rate = video_enc->frame_rate;
+// rate = video_enc->time_base.den;
}
/* XXX: is it allowed ? seems to work so far... */
/* XXX: should use delay, in order to be more accurate */
/* instead of using the same rounded value each time */
/* XXX: don't even remember if I really use it for now */
- jiffies = (70*enc->frame_rate_base/enc->frame_rate) - 1;
+ jiffies = (70*enc->time_base.num/enc->time_base.den) - 1;
put_le16(pb, jiffies);
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_RAWVIDEO;
- st->codec.frame_rate = 5;
- st->codec.frame_rate_base = 1;
+ st->codec.time_base.den = 5;
+ st->codec.time_base.num = 1;
/* XXX: check if screen size is always valid */
st->codec.width = s->screen_width;
st->codec.height = s->screen_height;
const char *video_device;
int j;
- if (!ap || ap->width <= 0 || ap->height <= 0 || ap->frame_rate <= 0)
+ if (!ap || ap->width <= 0 || ap->height <= 0 || ap->time_base.den <= 0)
return -1;
width = ap->width;
height = ap->height;
- frame_rate = ap->frame_rate;
- frame_rate_base = ap->frame_rate_base;
+ frame_rate = ap->time_base.den;
+ frame_rate_base = ap->time_base.num;
if((unsigned)width > 32767 || (unsigned)height > 32767)
return -1;
st->codec.codec_id = CODEC_ID_RAWVIDEO;
st->codec.width = width;
st->codec.height = height;
- st->codec.frame_rate = frame_rate;
- st->codec.frame_rate_base = frame_rate_base;
+ st->codec.time_base.den = frame_rate;
+ st->codec.time_base.num = frame_rate_base;
return 0;
fail:
s->is_pipe = 0;
else
s->is_pipe = 1;
-
- if (!ap || !ap->frame_rate) {
- st->codec.frame_rate = 25;
- st->codec.frame_rate_base = 1;
+
+ if (!ap || !ap->time_base.num) {
+ st->codec.time_base= (AVRational){1,25};
} else {
- st->codec.frame_rate = ap->frame_rate;
- st->codec.frame_rate_base = ap->frame_rate_base;
+ st->codec.time_base= ap->time_base;
}
-
+
if (!s->is_pipe) {
if (find_image_range(&first_index, &last_index, s->path) < 0)
goto fail;
s->img_number = first_index;
/* compute duration */
st->start_time = 0;
- st->duration = ((int64_t)AV_TIME_BASE *
- (last_index - first_index + 1) *
- st->codec.frame_rate_base) / st->codec.frame_rate;
+ st->duration = last_index - first_index + 1;
if (get_frame_filename(buf, sizeof(buf), s->path, s->img_number) < 0)
goto fail;
if (url_fopen(f, buf, URL_RDONLY) < 0)
} else {
/* XXX: computing this pts is not necessary as it is done in
the generic code too */
- pkt->pts = av_rescale((int64_t)s->img_count * s1->streams[0]->codec.frame_rate_base, s1->streams[0]->time_base.den, s1->streams[0]->codec.frame_rate) / s1->streams[0]->time_base.num;
+ pkt->pts = av_rescale((int64_t)s->img_count * s1->streams[0]->codec.time_base.num, s1->streams[0]->time_base.den, s1->streams[0]->codec.time_base.den) / s1->streams[0]->time_base.num;
s->img_count++;
s->img_number++;
return 0;
st->need_parsing= 1;
}
- if (!ap || !ap->frame_rate) {
- st->codec.frame_rate = 25;
- st->codec.frame_rate_base = 1;
+ if (!ap || !ap->time_base.num) {
+ av_set_pts_info(st, 60, 1, 25);
} else {
- st->codec.frame_rate = ap->frame_rate;
- st->codec.frame_rate_base = ap->frame_rate_base;
+ av_set_pts_info(st, 60, ap->time_base.num, ap->time_base.den);
}
if(ap && ap->width && ap->height){
s->img_number = first_index;
/* compute duration */
st->start_time = 0;
- st->duration = ((int64_t)AV_TIME_BASE *
- (last_index - first_index + 1) *
- st->codec.frame_rate_base) / st->codec.frame_rate;
+ st->duration = last_index - first_index + 1;
}
if(ap->video_codec_id){
st->codec.color_table_id = get_be16(pb); /* colortable id */
/* These are set in mov_read_stts and might already be set!
- st->codec.frame_rate = 25;
- st->codec.frame_rate_base = 1;
+ st->codec.time_base.den = 25;
+ st->codec.time_base.num = 1;
*/
size -= (16+8*4+2+32+2*2);
#if 0
#if 0 //We calculate an average instead, needed by .mp4-files created with nec e606 3g phone
if (!i && st->codec.codec_type==CODEC_TYPE_VIDEO) {
- st->codec.frame_rate_base = sample_duration ? sample_duration : 1;
- st->codec.frame_rate = c->streams[c->fc->nb_streams-1]->time_scale;
+ st->codec.time_base.num = sample_duration ? sample_duration : 1;
+ st->codec.time_base.den = c->streams[c->fc->nb_streams-1]->time_scale;
#ifdef DEBUG
- av_log(NULL, AV_LOG_DEBUG, "VIDEO FRAME RATE= %i (sd= %i)\n", st->codec.frame_rate, sample_duration);
+ av_log(NULL, AV_LOG_DEBUG, "VIDEO FRAME RATE= %i (sd= %i)\n", st->codec.time_base.den, sample_duration);
#endif
}
#endif
if(duration>0)
{
av_reduce(
- &st->codec.frame_rate,
- &st->codec.frame_rate_base,
+ &st->codec.time_base.den,
+ &st->codec.time_base.num,
c->streams[c->fc->nb_streams-1]->time_scale * total_sample_count,
duration,
INT_MAX
);
#ifdef DEBUG
- av_log(NULL, AV_LOG_DEBUG, "FRAME RATE average (video or audio)= %f (tot sample count= %i ,tot dur= %i timescale=%d)\n", (float)st->codec.frame_rate/st->codec.frame_rate_base,total_sample_count,duration,c->streams[c->fc->nb_streams-1]->time_scale);
+ av_log(NULL, AV_LOG_DEBUG, "FRAME RATE average (video or audio)= %f (tot sample count= %i ,tot dur= %i timescale=%d)\n", (float)st->codec.time_base.den/st->codec.time_base.num,total_sample_count,duration,c->streams[c->fc->nb_streams-1]->time_scale);
#endif
}
else
{
- st->codec.frame_rate_base = 1;
- st->codec.frame_rate = c->streams[c->fc->nb_streams-1]->time_scale;
+ st->codec.time_base.num = 1;
+ st->codec.time_base.den = c->streams[c->fc->nb_streams-1]->time_scale;
}
return 0;
}
if(mov->tracks[i].entry <= 0) continue;
if(mov->tracks[i].enc->codec_type == CODEC_TYPE_VIDEO) {
- mov->tracks[i].timescale = mov->tracks[i].enc->frame_rate;
- mov->tracks[i].sampleDuration = mov->tracks[i].enc->frame_rate_base;
+ mov->tracks[i].timescale = mov->tracks[i].enc->time_base.den;
+ mov->tracks[i].sampleDuration = mov->tracks[i].enc->time_base.num;
}
else if(mov->tracks[i].enc->codec_type == CODEC_TYPE_AUDIO) {
/* If AMR, track timescale = 8000, AMR_WB = 16000 */
static void mov_write_uuidprof_tag(ByteIOContext *pb, AVFormatContext *s)
{
int AudioRate = s->streams[1]->codec.sample_rate;
- int FrameRate = ((s->streams[0]->codec.frame_rate) * (0x10000))/ (s->streams[0]->codec.frame_rate_base);
+ int FrameRate = ((s->streams[0]->codec.time_base.den) * (0x10000))/ (s->streams[0]->codec.time_base.num);
//printf("audiorate = %d\n",AudioRate);
- //printf("framerate = %d / %d = 0x%x\n",s->streams[0]->codec.frame_rate,s->streams[0]->codec.frame_rate_base,FrameRate);
+ //printf("framerate = %d / %d = 0x%x\n",s->streams[0]->codec.time_base.den,s->streams[0]->codec.time_base.num,FrameRate);
put_be32(pb, 0x94 ); /* size */
put_tag(pb, "uuid");
ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0];
s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr;
st->codec.bit_rate = s->bit_rate;
- st->start_time = ts->cur_pcr * 1000000.0 / 27.0e6;
+ st->start_time = ts->cur_pcr;
#if 0
printf("start=%0.3f pcr=%0.3f incr=%d\n",
st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
PRINT(("NSV NSVf chunk_size %ld\n", size));
PRINT(("NSV NSVf file_size %Ld\n", file_size));
- duration = get_le32(pb); /* in ms */
- nsv->duration = duration * AV_TIME_BASE / 1000; /* convert */
+ nsv->duration = duration = get_le32(pb); /* in ms */
PRINT(("NSV NSVf duration %Ld ms\n", duration));
// XXX: store it in AVStreams
st->codec.bits_per_sample = 24; /* depth XXX */
av_set_pts_info(st, 64, framerate.den, framerate.num);
- st->codec.frame_rate = framerate.num;
- st->codec.frame_rate_base = framerate.den;
st->start_time = 0;
- st->duration = nsv->duration;
+ st->duration = av_rescale(nsv->duration, framerate.num, 1000*framerate.den);
}
if (atag != T_NONE) {
#ifndef DISABLE_AUDIO
st->codec.codec_tag = atag;
st->codec.codec_id = codec_get_id(nsv_codec_audio_tags, atag);
st->start_time = 0;
- st->duration = nsv->duration;
+// st->duration = nsv->duration; //FIXME
st->need_parsing = 1; /* for PCM we will read a chunk later and put correct info */
/* XXX:FIXME */
if (codec->codec_type == CODEC_TYPE_VIDEO)
{
- nom = codec->frame_rate;
- denom = codec->frame_rate_base;
+ nom = codec->time_base.den;
+ denom = codec->time_base.num;
}
else
{
st->codec.sample_aspect_ratio.num= get_v(bc);
st->codec.sample_aspect_ratio.den= get_v(bc);
get_v(bc); /* csp type */
-
- st->codec.frame_rate = nom;
- st->codec.frame_rate_base = denom;
}
if (class == 32) /* AUDIO */
{
av_set_pts_info(st, 64, 1, st->codec.sample_rate);
break;
case CODEC_TYPE_VIDEO:
- st->codec.frame_rate = ap->frame_rate;
- st->codec.frame_rate_base = ap->frame_rate_base;
+ av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
st->codec.width = ap->width;
st->codec.height = ap->height;
st->codec.pix_fmt = ap->pix_fmt;
/* for mpeg4 specify it too (most mpeg4 streams dont have the fixed_vop_rate set ...)*/
if (st->codec.codec_id == CODEC_ID_MJPEG ||
st->codec.codec_id == CODEC_ID_MPEG4) {
- if (ap && ap->frame_rate) {
- st->codec.frame_rate = ap->frame_rate;
- st->codec.frame_rate_base = ap->frame_rate_base;
+ if (ap && ap->time_base.num) {
+ av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
} else {
- st->codec.frame_rate = 25;
- st->codec.frame_rate_base = 1;
+ av_set_pts_info(st, 64, 1, 25);
}
}
return 0;
break;
case CODEC_TYPE_VIDEO:
rm->video_stream = stream;
- stream->frame_rate = (float)codec->frame_rate / (float)codec->frame_rate_base;
+ stream->frame_rate = (float)codec->time_base.den / (float)codec->time_base.num;
/* XXX: dummy values */
stream->packet_max_size = 4096;
stream->nb_packets = 0;
start_time = get_be32(pb); /* start time */
get_be32(pb); /* preroll */
duration = get_be32(pb); /* duration */
- st->start_time = start_time * (AV_TIME_BASE / 1000);
- st->duration = duration * (AV_TIME_BASE / 1000);
+ st->start_time = start_time;
+ st->duration = duration;
get_str8(pb, buf, sizeof(buf)); /* desc */
get_str8(pb, buf, sizeof(buf)); /* mimetype */
codec_data_size = get_be32(pb);
goto fail1;
st->codec.width = get_be16(pb);
st->codec.height = get_be16(pb);
- st->codec.frame_rate_base= 1;
+ st->codec.time_base.num= 1;
fps= get_be16(pb);
st->codec.codec_type = CODEC_TYPE_VIDEO;
get_be32(pb);
get_buffer(pb, st->codec.extradata, st->codec.extradata_size);
// av_log(NULL, AV_LOG_DEBUG, "fps= %d fps2= %d\n", fps, fps2);
- st->codec.frame_rate = fps * st->codec.frame_rate_base;
+ st->codec.time_base.den = fps * st->codec.time_base.num;
/* modification of h263 codec version (!) */
#ifdef WORDS_BIGENDIAN
h263_hack_version = ((uint32_t*)st->codec.extradata)[1];
/* 90 KHz time stamp */
s->timestamp = s->base_timestamp +
- av_rescale((int64_t)s->cur_timestamp * st->codec.frame_rate_base, 90000, st->codec.frame_rate);
+ av_rescale((int64_t)s->cur_timestamp * st->codec.time_base.num, 90000, st->codec.time_base.den); //FIXME pass timestamps
rtp_send_data(s1, s->buf, q - s->buf);
buf1 += len;
/* 90 KHz time stamp */
s->timestamp = s->base_timestamp +
- av_rescale((int64_t)s->cur_timestamp * st->codec.frame_rate_base, 90000, st->codec.frame_rate);
+ av_rescale((int64_t)s->cur_timestamp * st->codec.time_base.num, 90000, st->codec.time_base.den); //FIXME pass timestamps
rtp_send_data(s1, buf1, len);
buf1 += len;
swf->video_type = video_enc->codec_id;
width = video_enc->width;
height = video_enc->height;
- rate = video_enc->frame_rate;
- rate_base = video_enc->frame_rate_base;
+ rate = video_enc->time_base.den;
+ rate_base = video_enc->time_base.num;
}
if (!audio_enc ) {
if (tag < 0) {
if ( ast || vst ) {
if ( vst && ast ) {
- vst->codec.frame_rate = ast->codec.sample_rate / swf->samples_per_frame;
- vst->codec.frame_rate_base = 1;
+ vst->codec.time_base.den = ast->codec.sample_rate / swf->samples_per_frame;
+ vst->codec.time_base.num = 1;
}
break;
}
vst->codec.codec_type = CODEC_TYPE_VIDEO;
vst->codec.codec_id = CODEC_ID_FLV1;
if ( swf->samples_per_frame ) {
- vst->codec.frame_rate = 1000. / swf->ms_per_frame;
- vst->codec.frame_rate_base = 1;
+ vst->codec.time_base.den = 1000. / swf->ms_per_frame;
+ vst->codec.time_base.num = 1;
}
}
} else if ( ( tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2 ) && !ast) {
*pden = 0;
switch(st->codec.codec_type) {
case CODEC_TYPE_VIDEO:
- *pnum = st->codec.frame_rate_base;
- *pden = st->codec.frame_rate;
+ if(st->codec.time_base.num*1000 <= st->codec.time_base.den){
+ *pnum = st->time_base.num;
+ *pden = st->time_base.den;
+ }else{
+ *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);
AVCodecParserContext *pc, AVPacket *pkt)
{
int num, den, presentation_delayed;
-
/* handle wrapping */
if(st->cur_dts != AV_NOPTS_VALUE){
if(pkt->pts != AV_NOPTS_VALUE)
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);
}
void av_destruct_packet_nofree(AVPacket *pkt)
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);
compute 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;
}
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);
}
}
}
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;
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);
}
int64_t last_dts[MAX_STREAMS];
int64_t best_duration[MAX_STREAMS];
+ 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;
+ }
+ }
+
for(i=0;i<MAX_STREAMS;i++){
last_dts[i]= AV_NOPTS_VALUE;
best_duration[i]= INT64_MAX;
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)
+ if( st->codec.time_base.den >= 1000LL*st->codec.time_base.num
+ && best_duration[i]== INT64_MAX && st->codec.codec_type == CODEC_TYPE_VIDEO)
break;
}
if (i == ic->nb_streams) {
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){
+ if(best_duration[i] < INT64_MAX && st->codec.time_base.num*1000 <= st->codec.time_base.den){
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);
+ st->r_frame_rate.num= st->time_base.den;
+ st->r_frame_rate.den= st->time_base.num*best_duration[i];
+ av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->r_frame_rate.num, st->r_frame_rate.den, 1<<15);
- int_fps= av_rescale(st->r_frame_rate, 1, st->r_frame_rate_base);
+ int_fps= av_rescale(st->r_frame_rate.num, 1, st->r_frame_rate.den); // 1/0
- 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;
+ if(int_fps>0 && av_rescale(st->r_frame_rate.num, 1, int_fps) == st->r_frame_rate.den){
+ st->r_frame_rate.num= int_fps;
+ st->r_frame_rate.den= 1;
}
}
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 = 24000;
- 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;
}
}
}
break;
case CODEC_TYPE_VIDEO:
av_frac_init(&st->pts, 0, 0,
- (int64_t)st->time_base.num * st->codec.frame_rate);
+ (int64_t)st->time_base.num * st->codec.time_base.den);
break;
default:
break;
/* 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) {
}
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;
* @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);
width = st->codec.width;
height = st->codec.height;
- av_reduce(&raten, &rated, st->codec.frame_rate, st->codec.frame_rate_base, (1UL<<31)-1);
+ av_reduce(&raten, &rated, st->codec.time_base.den, st->codec.time_base.num, (1UL<<31)-1);
aspectn = st->codec.sample_aspect_ratio.num;
aspectd = st->codec.sample_aspect_ratio.den;
st->codec.width = width;
st->codec.height = height;
av_reduce(&raten, &rated, raten, rated, (1UL<<31)-1);
- st->codec.frame_rate = raten;
- st->codec.frame_rate_base = rated;
+ av_set_pts_info(st, 64, rated, raten);
st->codec.pix_fmt = pix_fmt;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_RAWVIDEO;
c->width = 352;
c->height = 288;
/* frames per second */
- c->frame_rate = STREAM_FRAME_RATE;
- c->frame_rate_base = 1;
+ c->time_base.den = STREAM_FRAME_RATE;
+ c->time_base.num = 1;
c->gop_size = 12; /* emit one intra frame every twelve frames at most */
if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
/* just for testing, we also add B frames */
// Hack to correct wrong frame rates that seem to be generated by some
// codecs
- if (ci->pCodecCtx->frame_rate>1000 && ci->pCodecCtx->frame_rate_base==1)
- ci->pCodecCtx->frame_rate_base=1000;
+ if (ci->pCodecCtx->time_base.den>1000 && ci->pCodecCtx->time_base.num==1)
+ ci->pCodecCtx->time_base.num=1000;
/*
* Allocate a video frame to store the decoded images in.
projects / ffmpeg / commitdiff