It's supposed to be called only from (de)muxers.
#include <alsa/asoundlib.h>
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#include "libavutil/opt.h"
#include "alsa-audio.h"
st->codec->codec_id = codec_id;
st->codec->sample_rate = s->sample_rate;
st->codec->channels = s->channels;
- av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
+ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
return 0;
*/
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "libavutil/parseutils.h"
ret = AVERROR(ENOMEM);
goto out;
}
- av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in use */
+ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in use */
s->width = width;
s->height = height;
#include "libavutil/parseutils.h"
#include "libavutil/pixdesc.h"
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
struct rgb_pixfmt_map_entry {
int bits_per_pixel;
if (!(st = avformat_new_stream(avctx, NULL)))
return AVERROR(ENOMEM);
- av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in microseconds */
+ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in microseconds */
/* NONBLOCK is ignored by the fbdev driver, only set for consistency */
if (avctx->flags & AVFMT_FLAG_NONBLOCK)
#include "libavutil/opt.h"
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#include "timefilter.h"
/**
stream->codec->sample_rate = self->sample_rate;
stream->codec->channels = self->nports;
- av_set_pts_info(stream, 64, 1, 1000000); /* 64 bits pts in us */
+ avpriv_set_pts_info(stream, 64, 1, 1000000); /* 64 bits pts in us */
return 0;
}
st->duration = s->drive->audio_last_sector - s->drive->audio_first_sector;
else if (s->drive->tracks)
st->duration = s->drive->disc_toc[s->drive->tracks].dwStartSector;
- av_set_pts_info(st, 64, CDIO_CD_FRAMESIZE_RAW, 2*st->codec->channels*st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, CDIO_CD_FRAMESIZE_RAW, 2*st->codec->channels*st->codec->sample_rate);
for (i = 0; i < s->drive->tracks; i++) {
char title[16];
#include "config.h"
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#include "libavutil/log.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
ret = AVERROR(ENOMEM);
goto out;
}
- av_set_pts_info(vst, 64, 1, 1000);
+ avpriv_set_pts_info(vst, 64, 1, 1000);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_RAWVIDEO;
vst->codec->time_base.den = framerate.num;
#include "libavutil/opt.h"
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#define AUDIO_BLOCK_SIZE 4096
st->codec->sample_rate = s->sample_rate;
st->codec->channels = s->channels;
- av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
+ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
return 0;
}
#include <pulse/error.h>
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#include "libavutil/opt.h"
#define DEFAULT_CODEC_ID AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE)
st->codec->codec_id = codec_id;
st->codec->sample_rate = pd->sample_rate;
st->codec->channels = pd->channels;
- av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
+ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
pd->pts = AV_NOPTS_VALUE;
pd->frame_duration = (pd->frame_size * 1000000LL * 8) /
#include <sndio.h>
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#include "libavutil/opt.h"
#include "sndio_common.h"
st->codec->sample_rate = s->sample_rate;
st->codec->channels = s->channels;
- av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
+ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
return 0;
}
#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#include "libavcodec/dsputil.h"
#include <unistd.h>
#include <fcntl.h>
st = avformat_new_stream(s1, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
+ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
video_fd = open(s1->filename, O_RDWR);
if (video_fd < 0) {
#undef __STRICT_ANSI__ //workaround due to broken kernel headers
#include "config.h"
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
res = AVERROR(ENOMEM);
goto out;
}
- av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
+ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
if (s->video_size && (res = av_parse_video_size(&s->width, &s->height, s->video_size)) < 0) {
av_log(s1, AV_LOG_ERROR, "Could not parse video size '%s'.\n", s->video_size);
*/
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "libavutil/parseutils.h"
}
}
- av_set_pts_info(st, 32, 1, 1000);
+ avpriv_set_pts_info(st, 32, 1, 1000);
ctx->mutex = CreateMutex(NULL, 0, NULL);
if(!ctx->mutex) {
#include "config.h"
#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "libavutil/parseutils.h"
ret = AVERROR(ENOMEM);
goto out;
}
- av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
+ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
screen = DefaultScreen(dpy);
#include "libavutil/intreadwrite.h"
#include "libavutil/intfloat_readwrite.h"
#include "avformat.h"
+#include "internal.h"
#define RIFF_TAG MKTAG('R', 'I', 'F', 'F')
#define FOURXMV_TAG MKTAG('4', 'X', 'M', 'V')
ret= AVERROR(ENOMEM);
goto fail;
}
- av_set_pts_info(st, 60, 1, fourxm->fps);
+ avpriv_set_pts_info(st, 60, 1, fourxm->fps);
fourxm->video_stream_index = st->index;
}
st->id = current_track;
- av_set_pts_info(st, 60, 1, fourxm->tracks[current_track].sample_rate);
+ avpriv_set_pts_info(st, 60, 1, fourxm->tracks[current_track].sample_rate);
fourxm->tracks[current_track].stream_index = st->index;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "rawdec.h"
#include "id3v1.h"
ff_id3v1_read(s);
//LCM of all possible ADTS sample rates
- av_set_pts_info(st, 64, 1, 28224000);
+ avpriv_set_pts_info(st, 64, 1, 28224000);
return 0;
}
#include "libavutil/intreadwrite.h"
#include "libavcodec/adx.h"
#include "avformat.h"
+#include "internal.h"
#define BLOCK_SIZE 18
#define BLOCK_SAMPLES 32
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = s->iformat->value;
- av_set_pts_info(st, 64, BLOCK_SAMPLES, avctx->sample_rate);
+ avpriv_set_pts_info(st, 64, BLOCK_SAMPLES, avctx->sample_rate);
return 0;
}
#include "libavutil/intfloat_readwrite.h"
#include "libavutil/dict.h"
#include "avformat.h"
+#include "internal.h"
#include "pcm.h"
#include "aiff.h"
got_sound:
/* Now positioned, get the sound data start and end */
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
st->start_time = 0;
st->duration = st->codec->frame_size ?
st->nb_frames * st->codec->frame_size : st->nb_frames;
#include "libavutil/intfloat_readwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "aiff.h"
#include "avio_internal.h"
avio_wb32(pb, 0); /* Data offset */
avio_wb32(pb, 0); /* Block-size (block align) */
- av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);
+ avpriv_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);
/* Data is starting here */
avio_flush(pb);
*/
#include "avformat.h"
+#include "internal.h"
static const char AMR_header [] = "#!AMR\n";
static const char AMRWB_header [] = "#!AMR-WB\n";
}
st->codec->channels = 1;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
return 0;
}
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
typedef struct {
int base_record;
avio_skip(pb, 32); /* record_types */
st->nb_frames = avio_rl32(pb);
- av_set_pts_info(st, 64, 1, avio_rl16(pb));
+ avpriv_set_pts_info(st, 64, 1, avio_rl16(pb));
avio_skip(pb, 58);
/* color cycling and palette data */
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "apetag.h"
/* The earliest and latest file formats supported by this library */
st->nb_frames = ape->totalframes;
st->start_time = 0;
st->duration = total_blocks / MAC_SUBFRAME_SIZE;
- av_set_pts_info(st, 64, MAC_SUBFRAME_SIZE, ape->samplerate);
+ avpriv_set_pts_info(st, 64, MAC_SUBFRAME_SIZE, ape->samplerate);
st->codec->extradata = av_malloc(APE_EXTRADATA_SIZE);
st->codec->extradata_size = APE_EXTRADATA_SIZE;
#include "libavutil/mathematics.h"
#include "libavcodec/mpegaudio.h"
#include "avformat.h"
+#include "internal.h"
#include "avio_internal.h"
#include "riff.h"
#include "asf.h"
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
+ avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
asf_st = av_mallocz(sizeof(ASFStream));
if (!asf_st)
return AVERROR(ENOMEM);
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#include "asf.h"
#include "avio_internal.h"
for(n=0;n<s->nb_streams;n++) {
enc = s->streams[n]->codec;
- av_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */
+ avpriv_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */
bit_rate += enc->bit_rate;
}
st = avformat_new_stream(s, NULL);
if (!st)
return -1;
- av_set_pts_info(st, 64, 1, 100);
+ avpriv_set_pts_info(st, 64, 1, 100);
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_id= CODEC_ID_SSA;
*/
#include "avformat.h"
+#include "internal.h"
#include "avio_internal.h"
#include "pcm.h"
#include "riff.h"
st->codec->codec_id = codec;
st->codec->channels = channels;
st->codec->sample_rate = rate;
- av_set_pts_info(st, 64, 1, rate);
+ avpriv_set_pts_info(st, 64, 1, rate);
return 0;
}
AVProgram *av_new_program(AVFormatContext *s, int id);
+#if FF_API_SET_PTS_INFO
/**
- * Set the pts for a given stream. If the new values would be invalid
- * (<= 0), it leaves the AVStream unchanged.
- *
- * @param s stream
- * @param pts_wrap_bits number of bits effectively used by the pts
- * (used for wrap control, 33 is the value for MPEG)
- * @param pts_num numerator to convert to seconds (MPEG: 1)
- * @param pts_den denominator to convert to seconds (MPEG: 90000)
+ * @deprecated this function is not supposed to be called outside of lavf
*/
+attribute_deprecated
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
unsigned int pts_num, unsigned int pts_den);
+#endif
#define AVSEEK_FLAG_BACKWARD 1 ///< seek backward
#define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes
#include "libavutil/dict.h"
#include "libavutil/avstring.h"
#include "avformat.h"
+#include "internal.h"
#include "avi.h"
#include "dv.h"
#include "riff.h"
ast->scale = 1;
}
}
- av_set_pts_info(st, 64, ast->scale, ast->rate);
+ avpriv_set_pts_info(st, 64, ast->scale, ast->rate);
ast->cum_len=avio_rl32(pb); /* start */
st->nb_frames = avio_rl32(pb);
*st->codec = *ast->sub_ctx->streams[0]->codec;
ast->sub_ctx->streams[0]->codec->extradata = NULL;
time_base = ast->sub_ctx->streams[0]->time_base;
- av_set_pts_info(st, 64, time_base.num, time_base.den);
+ avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
}
ast->sub_buffer = pkt->data;
memset(pkt, 0, sizeof(*pkt));
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avformat.h"
+#include "internal.h"
#include "avi.h"
#include "avio_internal.h"
#include "riff.h"
avio_wl32(pb, au_scale); /* scale */
avio_wl32(pb, au_byterate); /* rate */
- av_set_pts_info(s->streams[i], 64, au_scale, au_byterate);
+ avpriv_set_pts_info(s->streams[i], 64, au_scale, au_byterate);
avio_wl32(pb, 0); /* start */
avist->frames_hdr_strm = avio_tell(pb); /* remember this offset to fill later */
*/
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#include <windows.h>
st->codec->stream_codec_tag = stream->info.fccHandler;
- av_set_pts_info(st, 64, info.dwScale, info.dwRate);
+ avpriv_set_pts_info(st, 64, info.dwScale, info.dwRate);
st->start_time = stream->info.dwStart;
}
}
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "libavcodec/bethsoftvideo.h"
typedef struct BVID_DemuxContext
stream = avformat_new_stream(s, NULL);
if (!stream)
return AVERROR(ENOMEM);
- av_set_pts_info(stream, 32, 1, 60); // 16 ms increments, i.e. 60 fps
+ avpriv_set_pts_info(stream, 32, 1, 60); // 16 ms increments, i.e. 60 fps
stream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
stream->codec->codec_id = CODEC_ID_BETHSOFTVID;
stream->codec->width = avio_rl16(pb);
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
typedef struct BFIContext {
int nframes;
astream->codec->sample_rate = avio_rl32(pb);
/* Set up the video codec... */
- av_set_pts_info(vstream, 32, 1, fps);
+ avpriv_set_pts_info(vstream, 32, 1, fps);
vstream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vstream->codec->codec_id = CODEC_ID_BFI;
vstream->codec->pix_fmt = PIX_FMT_PAL8;
astream->codec->bit_rate =
astream->codec->sample_rate * astream->codec->bits_per_coded_sample;
avio_seek(pb, chunk_header - 3, SEEK_SET);
- av_set_pts_info(astream, 64, 1, astream->codec->sample_rate);
+ avpriv_set_pts_info(astream, 64, 1, astream->codec->sample_rate);
return 0;
}
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
enum BinkAudFlags {
BINK_AUD_16BITS = 0x4000, ///< prefer 16-bit output
av_log(s, AV_LOG_ERROR, "invalid header: invalid fps (%d/%d)\n", fps_num, fps_den);
return AVERROR(EIO);
}
- av_set_pts_info(vst, 64, fps_den, fps_num);
+ avpriv_set_pts_info(vst, 64, fps_den, fps_num);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_BINKVIDEO;
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_tag = 0;
ast->codec->sample_rate = avio_rl16(pb);
- av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
+ avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
flags = avio_rl16(pb);
ast->codec->codec_id = flags & BINK_AUD_USEDCT ?
CODEC_ID_BINKAUDIO_DCT : CODEC_ID_BINKAUDIO_RDFT;
*/
#include "avformat.h"
+#include "internal.h"
enum BMVFlags {
BMV_NOP = 0,
st->codec->width = 640;
st->codec->height = 429;
st->codec->pix_fmt = PIX_FMT_PAL8;
- av_set_pts_info(st, 16, 1, 12);
+ avpriv_set_pts_info(st, 16, 1, 12);
ast = avformat_new_stream(s, 0);
if (!ast)
return AVERROR(ENOMEM);
ast->codec->codec_id = CODEC_ID_BMV_AUDIO;
ast->codec->channels = 2;
ast->codec->sample_rate = 22050;
- av_set_pts_info(ast, 16, 1, 22050);
+ avpriv_set_pts_info(ast, 16, 1, 22050);
c->get_next = 1;
c->audio_pos = 0;
*/
#include "avformat.h"
+#include "internal.h"
#include "voc.h"
#include "libavutil/intreadwrite.h"
video->codec->height = 192;
/* 4:3 320x200 with 8 empty lines */
video->sample_aspect_ratio = (AVRational) { 5, 6 };
- av_set_pts_info(video, 64, 2, 25);
+ avpriv_set_pts_info(video, 64, 2, 25);
video->nb_frames = framecount;
video->duration = framecount;
video->start_time = 0;
*/
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#include "isom.h"
#include "libavutil/intreadwrite.h"
return AVERROR_INVALIDDATA;
}
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
st->start_time = 0;
/* position the stream at the start of data */
*/
#include "avformat.h"
+#include "internal.h"
#define CDG_PACKET_SIZE 24
#define CDG_COMMAND 0x09
vst->codec->codec_id = CODEC_ID_CDGRAPHICS;
/// 75 sectors/sec * 4 packets/sector = 300 packets/sec
- av_set_pts_info(vst, 32, 1, 300);
+ avpriv_set_pts_info(vst, 32, 1, 300);
ret = avio_size(s->pb);
if (ret > 0)
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
static int dfa_probe(AVProbeData *p)
{
av_log(s, AV_LOG_WARNING, "Zero FPS reported, defaulting to 10\n");
mspf = 100;
}
- av_set_pts_info(st, 24, mspf, 1000);
+ avpriv_set_pts_info(st, 24, mspf, 1000);
avio_skip(pb, 128 - 16); // padding
st->duration = frames;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
typedef struct CinFileHeader {
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 32, 1, 12);
+ avpriv_set_pts_info(st, 32, 1, 12);
cin->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_DSICINVIDEO;
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 32, 1, 22050);
+ avpriv_set_pts_info(st, 32, 1, 22050);
cin->audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_DSICINAUDIO;
*/
#include <time.h>
#include "avformat.h"
+#include "internal.h"
#include "libavcodec/dvdata.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mathematics.h"
c->ast[i] = avformat_new_stream(c->fctx, NULL);
if (!c->ast[i])
break;
- av_set_pts_info(c->ast[i], 64, 1, 30000);
+ avpriv_set_pts_info(c->ast[i], 64, 1, 30000);
c->ast[i]->codec->codec_type = AVMEDIA_TYPE_AUDIO;
c->ast[i]->codec->codec_id = CODEC_ID_PCM_S16LE;
if (c->sys) {
avctx = c->vst->codec;
- av_set_pts_info(c->vst, 64, c->sys->time_base.num,
+ avpriv_set_pts_info(c->vst, 64, c->sys->time_base.num,
c->sys->time_base.den);
avctx->time_base= c->sys->time_base;
if (!avctx->width){
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#define DXA_EXTRA_SIZE 9
st->codec->width = w;
st->codec->height = h;
av_reduce(&den, &num, den, num, (1UL<<31)-1);
- av_set_pts_info(st, 33, num, den);
+ avpriv_set_pts_info(st, 33, num, den);
/* flags & 0x80 means that image is interlaced,
* flags & 0x40 means that image has double height
* either way set true height
*/
#include "avformat.h"
+#include "internal.h"
typedef struct {
unsigned int channels;
st->codec->codec_id = CODEC_ID_ADPCM_EA_XAS;
st->codec->channels = cdata->channels;
st->codec->sample_rate = sample_rate;
- av_set_pts_info(st, 64, 1, sample_rate);
+ avpriv_set_pts_info(st, 64, 1, sample_rate);
cdata->audio_pts = 0;
return 0;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define SCHl_TAG MKTAG('S', 'C', 'H', 'l')
#define SEAD_TAG MKTAG('S', 'E', 'A', 'D') /* Sxxx header */
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 33, 1, ea->sample_rate);
+ avpriv_set_pts_info(st, 33, 1, ea->sample_rate);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = ea->audio_codec;
st->codec->codec_tag = 0; /* no tag */
#include "libavutil/intreadwrite.h"
#include "libavutil/intfloat_readwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "ffm.h"
#if CONFIG_AVSERVER
#include <unistd.h>
if (!st)
goto fail;
- av_set_pts_info(st, 64, 1, 1000000);
+ avpriv_set_pts_info(st, 64, 1, 1000000);
codec = st->codec;
/* generic info */
#include "libavutil/intreadwrite.h"
#include "libavutil/intfloat_readwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "ffm.h"
static void flush_packet(AVFormatContext *s)
/* list of streams */
for(i=0;i<s->nb_streams;i++) {
st = s->streams[i];
- av_set_pts_info(st, 64, 1, 1000000);
+ avpriv_set_pts_info(st, 64, 1, 1000000);
codec = st->codec;
/* generic info */
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define RAND_TAG MKBETAG('R','a','n','d')
st->codec->width = avio_rb16(pb);
st->codec->height = avio_rb16(pb);
film->leading = avio_rb16(pb);
- av_set_pts_info(st, 64, 1, avio_rb16(pb));
+ avpriv_set_pts_info(st, 64, 1, avio_rb16(pb));
avio_seek(pb, 0, SEEK_SET);
#include "libavcodec/flac.h"
#include "avformat.h"
+#include "internal.h"
#include "rawdec.h"
#include "oggdec.h"
#include "vorbiscomment.h"
/* set time base and duration */
if (si.samplerate > 0) {
- av_set_pts_info(st, 64, 1, si.samplerate);
+ avpriv_set_pts_info(st, 64, 1, si.samplerate);
if (si.samples > 0)
st->duration = si.samples;
}
#include "libavutil/intreadwrite.h"
#include "libavutil/audioconvert.h"
#include "avformat.h"
+#include "internal.h"
#define FLIC_FILE_MAGIC_1 0xAF11
#define FLIC_FILE_MAGIC_2 0xAF12
/* Since the header information is incorrect we have to figure out the
* framerate using block_align and the fact that the audio is 22050 Hz.
* We usually have two cases: 2205 -> 10 fps and 1470 -> 15 fps */
- av_set_pts_info(st, 64, ast->codec->block_align, FLIC_TFTD_SAMPLE_RATE);
- av_set_pts_info(ast, 64, 1, FLIC_TFTD_SAMPLE_RATE);
+ avpriv_set_pts_info(st, 64, ast->codec->block_align, FLIC_TFTD_SAMPLE_RATE);
+ avpriv_set_pts_info(ast, 64, 1, FLIC_TFTD_SAMPLE_RATE);
} else if (AV_RL16(&header[0x10]) == FLIC_CHUNK_MAGIC_1) {
- av_set_pts_info(st, 64, FLIC_MC_SPEED, 70);
+ avpriv_set_pts_info(st, 64, FLIC_MC_SPEED, 70);
/* rewind the stream since the first chunk is at offset 12 */
avio_seek(pb, 12, SEEK_SET);
memcpy(st->codec->extradata, header, 12);
} else if (magic_number == FLIC_FILE_MAGIC_1) {
- av_set_pts_info(st, 64, speed, 70);
+ avpriv_set_pts_info(st, 64, speed, 70);
} else if ((magic_number == FLIC_FILE_MAGIC_2) ||
(magic_number == FLIC_FILE_MAGIC_3)) {
- av_set_pts_info(st, 64, speed, 1000);
+ avpriv_set_pts_info(st, 64, speed, 1000);
} else {
av_log(s, AV_LOG_INFO, "Invalid or unsupported magic chunk in file\n");
return AVERROR_INVALIDDATA;
#include "libavcodec/bytestream.h"
#include "libavcodec/mpeg4audio.h"
#include "avformat.h"
+#include "internal.h"
#include "avio_internal.h"
#include "flv.h"
return NULL;
st->id = is_audio;
st->codec->codec_type = is_audio ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
- av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
+ avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
return st;
}
if(get_audio_flags(enc)<0)
return -1;
}
- av_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
+ avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
sc = av_mallocz(sizeof(FLVStreamContext));
if (!sc)
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "avformat.h"
+#include "internal.h"
#define GSM_BLOCK_SIZE 33
#define GSM_BLOCK_SAMPLES 160
st->codec->block_align = GSM_BLOCK_SIZE;
st->codec->bit_rate = GSM_BLOCK_SIZE * 8 * c->sample_rate / GSM_BLOCK_SAMPLES;
- av_set_pts_info(st, 64, GSM_BLOCK_SAMPLES, GSM_SAMPLE_RATE);
+ avpriv_set_pts_info(st, 64, GSM_BLOCK_SAMPLES, GSM_SAMPLE_RATE);
return 0;
}
main_timebase = (AVRational){1001, 60000};
for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
- av_set_pts_info(st, 32, main_timebase.num, main_timebase.den);
+ avpriv_set_pts_info(st, 32, main_timebase.num, main_timebase.den);
}
return 0;
}
#include "libavutil/intfloat_readwrite.h"
#include "libavutil/mathematics.h"
#include "avformat.h"
+#include "internal.h"
#include "gxf.h"
#include "riff.h"
#include "audiointerleave.h"
}
sc->track_type = 2;
sc->sample_rate = st->codec->sample_rate;
- av_set_pts_info(st, 64, 1, sc->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, sc->sample_rate);
sc->sample_size = 16;
sc->frame_rate_index = -2;
sc->lines_index = -2;
"gxf muxer only accepts PAL or NTSC resolutions currently\n");
return -1;
}
- av_set_pts_info(st, 64, gxf->time_base.num, gxf->time_base.den);
+ avpriv_set_pts_info(st, 64, gxf->time_base.num, gxf->time_base.den);
if (gxf_find_lines_index(st) < 0)
sc->lines_index = -1;
sc->sample_size = st->codec->bit_rate;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define HUFFMAN_TABLE_SIZE (64 * 1024)
#define IDCIN_FPS 14
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 33, 1, IDCIN_FPS);
+ avpriv_set_pts_info(st, 33, 1, IDCIN_FPS);
idcin->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_IDCIN;
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 33, 1, IDCIN_FPS);
+ avpriv_set_pts_info(st, 33, 1, IDCIN_FPS);
idcin->audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_tag = 1;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define RoQ_MAGIC_NUMBER 0x1084
#define RoQ_CHUNK_PREAMBLE_SIZE 8
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 63, 1, framerate);
+ avpriv_set_pts_info(st, 63, 1, framerate);
roq->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_ROQ;
AVStream *st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 32, 1, RoQ_AUDIO_SAMPLE_RATE);
+ avpriv_set_pts_info(st, 32, 1, RoQ_AUDIO_SAMPLE_RATE);
roq->audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_ROQ_DPCM;
#include "libavutil/intreadwrite.h"
#include "libavutil/dict.h"
#include "avformat.h"
+#include "internal.h"
#define ID_8SVX MKTAG('8','S','V','X')
#define ID_VHDR MKTAG('V','H','D','R')
switch(st->codec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
- av_set_pts_info(st, 32, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
switch(compression) {
case COMP_NONE:
st->need_parsing = AVSTREAM_PARSE_FULL;
}
- av_set_pts_info(st, 60, framerate.den, framerate.num);
+ avpriv_set_pts_info(st, 60, framerate.den, framerate.num);
if (width && height) {
st->codec->width = width;
int flags, int64_t *ts_ret,
int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
+/**
+ * Set the pts for a given stream. If the new values would be invalid
+ * (<= 0), it leaves the AVStream unchanged.
+ *
+ * @param s stream
+ * @param pts_wrap_bits number of bits effectively used by the pts
+ * (used for wrap control, 33 is the value for MPEG)
+ * @param pts_num numerator to convert to seconds (MPEG: 1)
+ * @param pts_den denominator to convert to seconds (MPEG: 90000)
+ */
+void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
+ unsigned int pts_num, unsigned int pts_den);
+
#endif /* AVFORMAT_INTERNAL_H */
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define CHUNK_PREAMBLE_SIZE 4
#define OPCODE_PREAMBLE_SIZE 4
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 63, 1, 1000000);
+ avpriv_set_pts_info(st, 63, 1, 1000000);
ipmovie->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_INTERPLAY_VIDEO;
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 32, 1, ipmovie->audio_sample_rate);
+ avpriv_set_pts_info(st, 32, 1, ipmovie->audio_sample_rate);
ipmovie->audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = ipmovie->audio_type;
*/
#include "avformat.h"
+#include "internal.h"
#include "libavutil/avstring.h"
#define ISS_SIG "IMA_ADPCM_Sound"
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate
* st->codec->bits_per_coded_sample;
st->codec->block_align = iss->packet_size;
- av_set_pts_info(st, 32, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
return 0;
}
*/
#include "avformat.h"
+#include "internal.h"
static int probe(AVProbeData *p)
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_MPEG4;
st->need_parsing = AVSTREAM_PARSE_FULL;
- av_set_pts_info(st, 64, 1, 90000);
+ avpriv_set_pts_info(st, 64, 1, 90000);
return 0;
*/
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#include "libavutil/intreadwrite.h"
return AVERROR_INVALIDDATA;
}
- av_set_pts_info(st, 64, time_base.num, time_base.den);
+ avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
return 0;
}
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define JV_PREAMBLE_SIZE 5
vst->codec->height = avio_rl16(pb);
vst->nb_frames =
ast->nb_index_entries = avio_rl16(pb);
- av_set_pts_info(vst, 64, avio_rl16(pb), 1000);
+ avpriv_set_pts_info(vst, 64, avio_rl16(pb), 1000);
avio_skip(pb, 4);
ast->codec->codec_tag = 0; /* no fourcc */
ast->codec->sample_rate = avio_rl16(pb);
ast->codec->channels = 1;
- av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
+ avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
avio_skip(pb, 10);
*/
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#include <libnut.h>
for (j = 0; j < s[i].fourcc_len; j++) s[i].fourcc[j] = (fourcc >> (j*8)) & 0xFF;
ff_parse_specific_params(codec, &num, &ssize, &denom);
- av_set_pts_info(avf->streams[i], 60, denom, num);
+ avpriv_set_pts_info(avf->streams[i], 60, denom, num);
s[i].time_base.num = denom;
s[i].time_base.den = num;
memcpy(st->codec->extradata, s[i].codec_specific, st->codec->extradata_size);
}
- av_set_pts_info(avf->streams[i], 60, s[i].time_base.num, s[i].time_base.den);
+ avpriv_set_pts_info(avf->streams[i], 60, s[i].time_base.num, s[i].time_base.den);
st->start_time = 0;
st->duration = s[i].max_pts;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define LMLM4_I_FRAME 0x00
#define LMLM4_P_FRAME 0x01
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_MPEG4;
st->need_parsing = AVSTREAM_PARSE_HEADERS;
- av_set_pts_info(st, 64, 1001, 30000);
+ avpriv_set_pts_info(st, 64, 1001, 30000);
if (!(st = avformat_new_stream(s, NULL)))
return AVERROR(ENOMEM);
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#define LXF_PACKET_HEADER_SIZE 60
//use audio packet size to determine video standard
//for NTSC we have one 8008-sample audio frame per five video frames
if (samples == LXF_SAMPLERATE * 5005 / 30000) {
- av_set_pts_info(s->streams[0], 64, 1001, 30000);
+ avpriv_set_pts_info(s->streams[0], 64, 1001, 30000);
} else {
//assume PAL, but warn if we don't have 1920 samples
if (samples != LXF_SAMPLERATE / 25)
av_log(s, AV_LOG_WARNING,
"video doesn't seem to be PAL or NTSC. guessing PAL\n");
- av_set_pts_info(s->streams[0], 64, 1, 25);
+ avpriv_set_pts_info(s->streams[0], 64, 1, 25);
}
//TODO: warning if track mask != (1 << channels) - 1?
st->codec->sample_rate = LXF_SAMPLERATE;
st->codec->channels = lxf->channels;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
}
if (format == 1) {
if (track->time_scale < 0.01)
track->time_scale = 1.0;
- av_set_pts_info(st, 64, matroska->time_scale*track->time_scale, 1000*1000*1000); /* 64 bit pts in ns */
+ avpriv_set_pts_info(st, 64, matroska->time_scale*track->time_scale, 1000*1000*1000); /* 64 bit pts in ns */
st->codec->codec_id = codec_id;
st->start_time = 0;
*/
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#include "isom.h"
#include "matroska.h"
end_ebml_master(pb, track);
// ms precision is the de-facto standard timescale for mkv files
- av_set_pts_info(st, 64, 1, 1000);
+ avpriv_set_pts_info(st, 64, 1, 1000);
}
end_ebml_master(pb, tracks);
return 0;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define MM_PREAMBLE_SIZE 6
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = width;
st->codec->height = height;
- av_set_pts_info(st, 64, 1, frame_rate);
+ avpriv_set_pts_info(st, 64, 1, frame_rate);
/* audio stream */
if (length == MM_HEADER_LEN_AV) {
st->codec->codec_id = CODEC_ID_PCM_U8;
st->codec->channels = 1;
st->codec->sample_rate = 8000;
- av_set_pts_info(st, 64, 1, 8000); /* 8000 hz */
+ avpriv_set_pts_info(st, 64, 1, 8000); /* 8000 hz */
}
mm->audio_pts = 0;
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avformat.h"
+#include "internal.h"
#include "avio_internal.h"
#include "pcm.h"
#include "riff.h"
mmf->awapos = ff_start_tag(pb, "Awa\x01");
- av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);
+ avpriv_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);
avio_flush(pb);
st->codec->bits_per_coded_sample = 4;
st->codec->bit_rate = st->codec->sample_rate * st->codec->bits_per_coded_sample;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
return 0;
}
#include "libavutil/avstring.h"
#include "libavutil/dict.h"
#include "avformat.h"
+#include "internal.h"
#include "avio_internal.h"
#include "riff.h"
#include "isom.h"
sc->time_scale = 1;
}
- av_set_pts_info(st, 64, 1, sc->time_scale);
+ avpriv_set_pts_info(st, 64, 1, sc->time_scale);
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
!st->codec->frame_size && sc->stts_count == 1) {
if (!track->height)
track->height = st->codec->height;
- av_set_pts_info(st, 64, 1, track->timescale);
+ avpriv_set_pts_info(st, 64, 1, track->timescale);
}
mov_write_mdat_tag(pb, mov);
#include "libavutil/dict.h"
#include "libavutil/mathematics.h"
#include "avformat.h"
+#include "internal.h"
#include "id3v2.h"
#include "id3v1.h"
#include "libavcodec/mpegaudiodecheader.h"
st->start_time = 0;
// lcm of all mp3 sample rates
- av_set_pts_info(st, 64, 1, 14112000);
+ avpriv_set_pts_info(st, 64, 1, 14112000);
off = avio_tell(s->pb);
#include "libavcodec/get_bits.h"
#include "avformat.h"
+#include "internal.h"
#include "apetag.h"
#include "id3v1.h"
#include "libavutil/dict.h"
st->codec->extradata = av_mallocz(st->codec->extradata_size+FF_INPUT_BUFFER_PADDING_SIZE);
avio_read(s->pb, st->codec->extradata, 16);
st->codec->sample_rate = mpc_rate[st->codec->extradata[2] & 3];
- av_set_pts_info(st, 32, MPC_FRAMESIZE, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 32, MPC_FRAMESIZE, st->codec->sample_rate);
/* scan for seekpoints */
st->start_time = 0;
st->duration = c->fcount;
#include "libavcodec/get_bits.h"
#include "libavcodec/unary.h"
#include "avformat.h"
+#include "internal.h"
#include "avio_internal.h"
/// Two-byte MPC tag
st->codec->channels = (st->codec->extradata[1] >> 4) + 1;
st->codec->sample_rate = mpc8_rate[st->codec->extradata[0] >> 5];
- av_set_pts_info(st, 32, 1152 << (st->codec->extradata[1]&3)*2, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 32, 1152 << (st->codec->extradata[1]&3)*2, st->codec->sample_rate);
st->duration = c->samples / (1152 << (st->codec->extradata[1]&3)*2);
size -= avio_tell(pb) - pos;
#include "libavutil/opt.h"
#include "libavcodec/put_bits.h"
#include "avformat.h"
+#include "internal.h"
#include "mpeg.h"
#define MAX_PAYLOAD_SIZE 4096
goto fail;
st->priv_data = stream;
- av_set_pts_info(st, 64, 1, 90000);
+ avpriv_set_pts_info(st, 64, 1, 90000);
switch(st->codec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
static int mpegts_set_stream_info(AVStream *st, PESContext *pes,
uint32_t stream_type, uint32_t prog_reg_desc)
{
- av_set_pts_info(st, 33, 1, 90000);
+ avpriv_set_pts_info(st, 33, 1, 90000);
st->priv_data = pes;
st->codec->codec_type = AVMEDIA_TYPE_DATA;
st->codec->codec_id = CODEC_ID_NONE;
}
sub_st->id = pes->pid;
- av_set_pts_info(sub_st, 33, 1, 90000);
+ avpriv_set_pts_info(sub_st, 33, 1, 90000);
sub_st->priv_data = sub_pes;
sub_st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
sub_st->codec->codec_id = CODEC_ID_AC3;
if (cts != AV_NOPTS_VALUE)
pes->pts = cts;
- av_set_pts_info(pes->st, sl->timestamp_len, 1, sl->timestamp_res);
+ avpriv_set_pts_info(pes->st, sl->timestamp_len, 1, sl->timestamp_res);
return (get_bits_count(&gb) + 7) >> 3;
}
st = avformat_new_stream(s, NULL);
if (!st)
goto fail;
- av_set_pts_info(st, 60, 1, 27000000);
+ avpriv_set_pts_info(st, 60, 1, 27000000);
st->codec->codec_type = AVMEDIA_TYPE_DATA;
st->codec->codec_id = CODEC_ID_MPEG2TS;
/* assign pids to each stream */
for(i = 0;i < s->nb_streams; i++) {
st = s->streams[i];
- av_set_pts_info(st, 33, 1, 90000);
+ avpriv_set_pts_info(st, 33, 1, 90000);
ts_st = av_mallocz(sizeof(MpegTSWriteStream));
if (!ts_st)
goto fail;
#include "libavcodec/bytestream.h"
#include "avformat.h"
+#include "internal.h"
#define HEADER_SIZE 24
codec->codec_id = CODEC_ID_MIMIC;
codec->codec_tag = MKTAG('M', 'L', '2', '0');
- av_set_pts_info(st, 32, 1, 1000);
+ avpriv_set_pts_info(st, 32, 1, 1000);
/* Some files start with "connected\r\n\r\n".
* So skip until we find the first byte of struct size */
#include "libavutil/bswap.h"
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define MTV_ASUBCHUNK_DATA_SIZE 500
#define MTV_HEADER_SIZE 512
if(!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 64, 1, mtv->video_fps);
+ avpriv_set_pts_info(st, 64, 1, mtv->video_fps);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_RAWVIDEO;
st->codec->pix_fmt = PIX_FMT_RGB565;
if(!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 64, 1, AUDIO_SAMPLING_RATE);
+ avpriv_set_pts_info(st, 64, 1, AUDIO_SAMPLING_RATE);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_MP3;
st->codec->bit_rate = mtv->audio_br;
*/
#include "avformat.h"
+#include "internal.h"
#define MVI_FRAC_BITS 10
return AVERROR_INVALIDDATA;
}
- av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
+ avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = CODEC_ID_PCM_U8;
ast->codec->channels = 1;
ast->codec->bits_per_coded_sample = 8;
ast->codec->bit_rate = ast->codec->sample_rate * 8;
- av_set_pts_info(vst, 64, msecs_per_frame, 1000000);
+ avpriv_set_pts_info(vst, 64, msecs_per_frame, 1000000);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_MOTIONPIXELS;
if (st->duration == -1)
st->duration = AV_NOPTS_VALUE;
st->start_time = component->start_position;
- av_set_pts_info(st, 64, material_track->edit_rate.num, material_track->edit_rate.den);
+ avpriv_set_pts_info(st, 64, material_track->edit_rate.num, material_track->edit_rate.den);
if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
av_log(s, AV_LOG_ERROR, "unsupported video frame rate\n");
return -1;
}
- av_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
+ avpriv_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
if (s->oformat == &ff_mxf_d10_muxer) {
if (st->codec->bit_rate == 50000000)
if (mxf->time_base.den == 25) sc->index = 3;
av_log(s, AV_LOG_ERROR, "only 48khz is implemented\n");
return -1;
}
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
if (s->oformat == &ff_mxf_d10_muxer) {
if (st->index != 1) {
av_log(s, AV_LOG_ERROR, "MXF D-10 only support one audio track\n");
#include "libavutil/intreadwrite.h"
#include "libavcodec/mjpeg.h"
#include "avformat.h"
+#include "internal.h"
#include "avio.h"
#define DEFAULT_PACKET_SIZE 1024
return AVERROR(ENOMEM);
video_st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
video_st->codec->codec_id = CODEC_ID_MXPEG;
- av_set_pts_info(video_st, 64, 1, 1000000);
+ avpriv_set_pts_info(video_st, 64, 1, 1000000);
audio_st = avformat_new_stream(s, NULL);
if (!audio_st)
audio_st->codec->sample_rate = 8000;
audio_st->codec->bits_per_coded_sample = 8;
audio_st->codec->block_align = 1;
- av_set_pts_info(audio_st, 64, 1, 1000000);
+ avpriv_set_pts_info(audio_st, 64, 1, 1000000);
mxg->soi_ptr = mxg->buffer_ptr = mxg->buffer = 0;
mxg->buffer_size = 0;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define NC_VIDEO_FLAG 0x1A5
st->codec->codec_id = CODEC_ID_MPEG4;
st->need_parsing = AVSTREAM_PARSE_FULL;
- av_set_pts_info(st, 64, 1, 100);
+ avpriv_set_pts_info(st, 64, 1, 100);
return 0;
}
#include "libavutil/mathematics.h"
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#include "libavutil/dict.h"
st->codec->height = vheight;
st->codec->bits_per_coded_sample = 24; /* depth XXX */
- av_set_pts_info(st, 64, framerate.den, framerate.num);
+ avpriv_set_pts_info(st, 64, framerate.den, framerate.num);
st->start_time = 0;
st->duration = av_rescale(nsv->duration, framerate.num, 1000*framerate.den);
st->need_parsing = AVSTREAM_PARSE_FULL; /* for PCM we will read a chunk later and put correct info */
/* set timebase to common denominator of ms and framerate */
- av_set_pts_info(st, 64, 1, framerate.num*1000);
+ avpriv_set_pts_info(st, 64, 1, framerate.num*1000);
st->start_time = 0;
st->duration = (int64_t)nsv->duration * framerate.num;
#endif
return -1;
}
stc->time_base= &nut->time_base[stc->time_base_id];
- av_set_pts_info(s->streams[stream_id], 63, stc->time_base->num, stc->time_base->den);
+ avpriv_set_pts_info(s->streams[stream_id], 63, stc->time_base->num, stc->time_base->den);
return 0;
}
AVRational time_base;
ff_parse_specific_params(st->codec, &time_base.den, &ssize, &time_base.num);
- av_set_pts_info(st, 64, time_base.num, time_base.den);
+ avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
for(j=0; j<nut->time_base_count; j++){
if(!memcmp(&time_base, &nut->time_base[j], sizeof(AVRational))){
#include "libavutil/intreadwrite.h"
#include "libavutil/intfloat_readwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
typedef struct {
vst->codec->bits_per_coded_sample = 10;
vst->sample_aspect_ratio = av_d2q(aspect * height / width, 10000);
vst->r_frame_rate = av_d2q(fps, 60000);
- av_set_pts_info(vst, 32, 1, 1000);
+ avpriv_set_pts_info(vst, 32, 1, 1000);
} else
ctx->v_id = -1;
ast->codec->bit_rate = 2 * 2 * 44100 * 8;
ast->codec->block_align = 2 * 2;
ast->codec->bits_per_coded_sample = 16;
- av_set_pts_info(ast, 32, 1, 1000);
+ avpriv_set_pts_info(ast, 32, 1, 1000);
} else
ctx->a_id = -1;
return AVERROR(ENOMEM);
st->id = idx;
- av_set_pts_info(st, 64, 1, 1000000);
+ avpriv_set_pts_info(st, 64, 1, 1000000);
}
return idx;
unsigned serial_num = i;
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
- av_set_pts_info(st, 64, st->codec->time_base.num, st->codec->time_base.den);
+ avpriv_set_pts_info(st, 64, st->codec->time_base.num, st->codec->time_base.den);
if (st->codec->codec_id != CODEC_ID_VORBIS &&
st->codec->codec_id != CODEC_ID_THEORA &&
st->codec->codec_id != CODEC_ID_SPEEX &&
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "oggdec.h"
struct oggcelt_private {
st->codec->extradata = extradata;
st->codec->extradata_size = 2 * sizeof(uint32_t);
if (sample_rate)
- av_set_pts_info(st, 64, 1, sample_rate);
+ avpriv_set_pts_info(st, 64, 1, sample_rate);
priv->extra_headers_left = 1 + extra_headers;
os->private = priv;
AV_WL32(extradata + 0, overlap);
#include "libavcodec/get_bits.h"
#include "libavcodec/dirac.h"
#include "avformat.h"
+#include "internal.h"
#include "oggdec.h"
static int dirac_header(AVFormatContext *s, int idx)
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_DIRAC;
// dirac in ogg always stores timestamps as though the video were interlaced
- av_set_pts_info(st, 64, st->codec->time_base.num, 2*st->codec->time_base.den);
+ avpriv_set_pts_info(st, 64, st->codec->time_base.num, 2*st->codec->time_base.den);
return 1;
}
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_DIRAC;
- av_set_pts_info(st, 64, AV_RB32(buf+12), AV_RB32(buf+8));
+ avpriv_set_pts_info(st, 64, AV_RB32(buf+12), AV_RB32(buf+8));
return 1;
}
#include "libavcodec/get_bits.h"
#include "libavcodec/flac.h"
#include "avformat.h"
+#include "internal.h"
#include "oggdec.h"
#define OGG_FLAC_METADATA_TYPE_STREAMINFO 0x7F
memcpy(st->codec->extradata, streaminfo_start, FLAC_STREAMINFO_SIZE);
st->codec->extradata_size = FLAC_STREAMINFO_SIZE;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
} else if (mdt == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
ff_vorbis_comment (s, &st->metadata, os->buf + os->pstart + 4, os->psize - 4);
}
#include "libavcodec/get_bits.h"
#include "libavcodec/bytestream.h"
#include "avformat.h"
+#include "internal.h"
#include "oggdec.h"
#include "riff.h"
st->codec->height = bytestream_get_le32(&p);
st->codec->time_base.den = spu * 10000000;
st->codec->time_base.num = time_unit;
- av_set_pts_info(st, 64, st->codec->time_base.num, st->codec->time_base.den);
+ avpriv_set_pts_info(st, 64, st->codec->time_base.num, st->codec->time_base.den);
} else {
st->codec->channels = bytestream_get_le16(&p);
p += 2; /* block_align */
st->codec->bit_rate = bytestream_get_le32(&p) * 8;
st->codec->sample_rate = spu * 10000000 / time_unit;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
}
} else if (*p == 3) {
if (os->psize > 8)
#include "libavcodec/bytestream.h"
#include "avformat.h"
+#include "internal.h"
#include "oggdec.h"
static int skeleton_header(AVFormatContext *s, int idx)
if (start_den) {
int base_den;
av_reduce(&start_time, &base_den, start_num, start_den, INT_MAX);
- av_set_pts_info(st, 64, 1, base_den);
+ avpriv_set_pts_info(st, 64, 1, base_den);
os->lastpts =
st->start_time = start_time;
}
#include "libavcodec/get_bits.h"
#include "libavcodec/bytestream.h"
#include "avformat.h"
+#include "internal.h"
#include "oggdec.h"
struct speex_params {
+ FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(st->codec->extradata, p, st->codec->extradata_size);
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
} else
ff_vorbis_comment(s, &st->metadata, p, os->psize);
#include "libavutil/bswap.h"
#include "libavcodec/get_bits.h"
#include "avformat.h"
+#include "internal.h"
#include "oggdec.h"
struct theora_params {
st->codec->time_base.num = 1;
st->codec->time_base.den = 25;
}
- av_set_pts_info(st, 64, st->codec->time_base.num, st->codec->time_base.den);
+ avpriv_set_pts_info(st, 64, st->codec->time_base.num, st->codec->time_base.den);
st->sample_aspect_ratio.num = get_bits_long(&gb, 24);
st->sample_aspect_ratio.den = get_bits_long(&gb, 24);
if (srate > 0) {
st->codec->sample_rate = srate;
- av_set_pts_info(st, 64, 1, srate);
+ avpriv_set_pts_info(st, 64, 1, srate);
}
} else if (os->buf[os->pstart] == 3) {
if (os->psize > 8 &&
*/
#include "avformat.h"
+#include "internal.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/des.h"
#include "pcm.h"
AV_WL16(&edata[10], 1); // always 1
// AV_WL16(&edata[12], 0); // always 0
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
break;
case OMA_CODECID_ATRAC3P:
st->codec->channels = (codec_params >> 10) & 7;
framesize = ((codec_params & 0x3FF) * 8) + 8;
st->codec->sample_rate = srate_tab[(codec_params >> 13) & 7]*100;
st->codec->bit_rate = st->codec->sample_rate * framesize * 8 / 1024;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
av_log(s, AV_LOG_ERROR, "Unsupported codec ATRAC3+!\n");
break;
case OMA_CODECID_MP3:
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define RIFF_TAG MKTAG('R', 'I', 'F', 'F')
#define CDXA_TAG MKTAG('C', 'D', 'X', 'A')
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 64, 1, 15);
+ avpriv_set_pts_info(st, 64, 1, 15);
str->channels[channel].video_stream_index = st->index;
// st->codec->bit_rate = 0; //FIXME;
st->codec->block_align = 128;
- av_set_pts_info(st, 64, 128, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 128, st->codec->sample_rate);
}
pkt = ret_pkt;
if (av_new_packet(pkt, 2304))
*/
#include "avformat.h"
+#include "internal.h"
#include "mpeg.h"
#define PVA_MAX_PAYLOAD_LENGTH 0x17f8
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
st->need_parsing = AVSTREAM_PARSE_FULL;
- av_set_pts_info(st, 32, 1, 90000);
+ avpriv_set_pts_info(st, 32, 1, 90000);
av_add_index_entry(st, 0, 0, 0, 0, AVINDEX_KEYFRAME);
if (!(st = avformat_new_stream(s, NULL)))
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_MP2;
st->need_parsing = AVSTREAM_PARSE_FULL;
- av_set_pts_info(st, 33, 1, 90000);
+ avpriv_set_pts_info(st, 33, 1, 90000);
av_add_index_entry(st, 0, 0, 0, 0, AVINDEX_KEYFRAME);
/* the parameters will be extracted from the compressed bitstream */
#include "libavutil/dict.h"
#include "libavutil/mathematics.h"
#include "avformat.h"
+#include "internal.h"
typedef struct {
unsigned video_offsets_count;
av_dlog(s, "unknown1 %d\n", tmp);
tmp = avio_rb32(s->pb);
- av_set_pts_info(st, 32, 1, tmp);
+ avpriv_set_pts_info(st, 32, 1, tmp);
tmp = avio_rb32(s->pb); // filenum
av_dlog(s, "filenum %d\n", tmp);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = CODEC_ID_PCM_S32BE;
ast->codec->channels = tmp;
- av_set_pts_info(ast, 32, 1, st->time_base.den);
+ avpriv_set_pts_info(ast, 32, 1, st->time_base.den);
}
avio_read(s->pb, filename, 257);
*/
#include "avformat.h"
+#include "internal.h"
#include "avio_internal.h"
#include "rawdec.h"
#include "libavutil/opt.h"
st->codec->bits_per_coded_sample = av_get_bits_per_sample(st->codec->codec_id);
assert(st->codec->bits_per_coded_sample > 0);
st->codec->block_align = st->codec->bits_per_coded_sample*st->codec->channels/8;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
break;
}
case AVMEDIA_TYPE_VIDEO: {
av_log(s, AV_LOG_ERROR, "Could not parse framerate: %s.\n", s1->framerate);
goto fail;
}
- av_set_pts_info(st, 64, framerate.den, framerate.num);
+ avpriv_set_pts_info(st, 64, framerate.den, framerate.num);
st->codec->width = width;
st->codec->height = height;
st->codec->pix_fmt = pix_fmt;
}
st->codec->time_base = (AVRational){framerate.den, framerate.num};
- av_set_pts_info(st, 64, 1, 1200000);
+ avpriv_set_pts_info(st, 64, 1, 1200000);
fail:
return ret;
#include "libavutil/intreadwrite.h"
#include "libavutil/mathematics.h"
#include "avformat.h"
+#include "internal.h"
#define EXTRADATA1_SIZE (6 + 256 * 3) ///< video base, clr, palette
st->codec->bits_per_coded_sample;
st->codec->block_align = st->codec->channels *
st->codec->bits_per_coded_sample / 8;
- av_set_pts_info(st,32,1,rate);
+ avpriv_set_pts_info(st,32,1,rate);
}
- av_set_pts_info(s->streams[0], 32, pts_num, pts_den);
+ avpriv_set_pts_info(s->streams[0], 32, pts_num, pts_den);
chunk_size = av_malloc(frame_count * sizeof(uint32_t));
audio_size = av_malloc(frame_count * sizeof(uint32_t));
#include "libavutil/intreadwrite.h"
#include "libavutil/dict.h"
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#include "rm.h"
int64_t codec_pos;
int ret;
- av_set_pts_info(st, 64, 1, 1000);
+ avpriv_set_pts_info(st, 64, 1, 1000);
codec_pos = avio_tell(pb);
v = avio_rb32(pb);
if (v == MKTAG(0xfd, 'a', 'r', '.')) {
#include "libavutil/avstring.h"
#include "libavutil/dict.h"
#include "avformat.h"
+#include "internal.h"
#include <stdlib.h>
#define RPL_SIGNATURE "ARMovie\x0A"
vst->codec->bits_per_coded_sample = read_line_and_int(pb, &error); // video bits per sample
error |= read_line(pb, line, sizeof(line)); // video frames per second
fps = read_fps(line, &error);
- av_set_pts_info(vst, 32, fps.den, fps.num);
+ avpriv_set_pts_info(vst, 32, fps.den, fps.num);
// Figure out the video codec
switch (vst->codec->codec_tag) {
"RPL audio format %i not supported yet!\n",
audio_format);
}
- av_set_pts_info(ast, 32, 1, ast->codec->bit_rate);
+ avpriv_set_pts_info(ast, 32, 1, ast->codec->bit_rate);
} else {
for (i = 0; i < 3; i++)
error |= read_line(pb, line, sizeof(line));
st->codec->channels = 1;
st->codec->sample_rate = rate;
- av_set_pts_info(st, 64, 1, rate);
+ avpriv_set_pts_info(st, 64, 1, rate);
return 0;
}
#include "rtsp.h"
#include "asf.h"
#include "avio_internal.h"
+#include "internal.h"
/**
* From MSDN 2.2.1.4, we learn that ASF data packets over RTP should not
*rt->asf_ctx->streams[i]->codec;
rt->asf_ctx->streams[i]->codec->extradata_size = 0;
rt->asf_ctx->streams[i]->codec->extradata = NULL;
- av_set_pts_info(s->streams[stream_index], 32, 1, 1000);
+ avpriv_set_pts_info(s->streams[stream_index], 32, 1, 1000);
}
}
}
*/
#include "avformat.h"
+#include "internal.h"
#include "avio_internal.h"
#include "rtp.h"
#include "rtpdec.h"
(st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
tag != MKTAG('s','o','u','n')))
return AVERROR_INVALIDDATA;
- av_set_pts_info(st, 32, 1, avio_rb32(&pb));
+ avpriv_set_pts_info(st, 32, 1, avio_rb32(&pb));
if (pos + data_len > len)
return AVERROR_INVALIDDATA;
}
}
- av_set_pts_info(st, 32, 1, 90000);
+ avpriv_set_pts_info(st, 32, 1, 90000);
switch(st->codec->codec_id) {
case CODEC_ID_MP2:
case CODEC_ID_MP3:
case CODEC_ID_ADPCM_G722:
/* Due to a historical error, the clock rate for G722 in RTP is
* 8000, even if the sample rate is 16000. See RFC 3551. */
- av_set_pts_info(st, 32, 1, 8000);
+ avpriv_set_pts_info(st, 32, 1, 8000);
break;
case CODEC_ID_AMR_NB:
case CODEC_ID_AMR_WB:
default:
defaultcase:
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
- av_set_pts_info(st, 32, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
}
s->buf_ptr = s->buf;
break;
codec->channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS;
if (i > 0) {
codec->sample_rate = i;
- av_set_pts_info(st, 32, 1, codec->sample_rate);
+ avpriv_set_pts_info(st, 32, 1, codec->sample_rate);
get_word_sep(buf, sizeof(buf), "/", &p);
i = atoi(buf);
if (i > 0)
case AVMEDIA_TYPE_VIDEO:
av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
if (i > 0)
- av_set_pts_info(st, 32, 1, i);
+ avpriv_set_pts_info(st, 32, 1, i);
break;
default:
break;
ff_rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
st->codec->sample_rate > 0)
- av_set_pts_info(st, 32, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
/* Even static payload types may need a custom depacketizer */
handler = ff_rtp_handler_find_by_id(
rtsp_st->sdp_payload_type, st->codec->codec_type);
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define FILM_TAG MKBETAG('F', 'I', 'L', 'M')
#define FDSC_TAG MKBETAG('F', 'D', 'S', 'C')
return AVERROR(ENOMEM);
for(i=0; i<s->nb_streams; i++)
- av_set_pts_info(s->streams[i], 33, 1, film->base_clock);
+ avpriv_set_pts_info(s->streams[i], 33, 1, film->base_clock);
audio_frame_counter = 0;
for (i = 0; i < film->sample_count; i++) {
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define VMD_HEADER_SIZE 0x0330
#define BYTES_PER_FRAME_RECORD 16
vst = avformat_new_stream(s, NULL);
if (!vst)
return AVERROR(ENOMEM);
- av_set_pts_info(vst, 33, 1, 10);
+ avpriv_set_pts_info(vst, 33, 1, 10);
vmd->video_stream_index = vst->index;
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = vmd->is_indeo3 ? CODEC_ID_INDEO3 : CODEC_ID_VMDVIDEO;
num = st->codec->block_align;
den = st->codec->sample_rate * st->codec->channels;
av_reduce(&den, &num, den, num, (1UL<<31)-1);
- av_set_pts_info(vst, 33, num, den);
- av_set_pts_info(st, 33, num, den);
+ avpriv_set_pts_info(vst, 33, num, den);
+ avpriv_set_pts_info(st, 33, num, den);
}
toc_offset = AV_RL32(&vmd->vmd_header[812]);
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
enum SIFFTags{
TAG_SIFF = MKTAG('S', 'I', 'F', 'F'),
ast->codec->bits_per_coded_sample = c->bits;
ast->codec->sample_rate = c->rate;
ast->codec->frame_size = c->block_align;
- av_set_pts_info(ast, 16, 1, c->rate);
+ avpriv_set_pts_info(ast, 16, 1, c->rate);
return 0;
}
st->codec->width = width;
st->codec->height = height;
st->codec->pix_fmt = PIX_FMT_PAL8;
- av_set_pts_info(st, 16, 1, 12);
+ avpriv_set_pts_info(st, 16, 1, 12);
c->cur_frame = 0;
c->has_video = 1;
#include "libavutil/bswap.h"
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define SMACKER_PAL 0x01
#define SMACKER_FLAG_RING_FRAME 0x01
smk->pts_inc *= 100;
tbase = 100000;
av_reduce(&tbase, &smk->pts_inc, tbase, smk->pts_inc, (1UL<<31)-1);
- av_set_pts_info(st, 33, smk->pts_inc, tbase);
+ avpriv_set_pts_info(st, 33, smk->pts_inc, tbase);
st->duration = smk->frames;
/* handle possible audio streams */
for(i = 0; i < 7; i++) {
ast[i]->codec->bits_per_coded_sample = (smk->aflags[i] & SMK_AUD_16BITS) ? 16 : 8;
if(ast[i]->codec->bits_per_coded_sample == 16 && ast[i]->codec->codec_id == CODEC_ID_PCM_U8)
ast[i]->codec->codec_id = CODEC_ID_PCM_S16LE;
- av_set_pts_info(ast[i], 64, 1, ast[i]->codec->sample_rate
+ avpriv_set_pts_info(ast[i], 64, 1, ast[i]->codec->sample_rate
* ast[i]->codec->channels * ast[i]->codec->bits_per_coded_sample / 8);
}
}
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "pcm.h"
/* if we don't know the size in advance */
st->codec->codec_id = codec;
st->codec->channels = channels;
st->codec->sample_rate = rate;
- av_set_pts_info(st, 64, 1, rate);
+ avpriv_set_pts_info(st, 64, 1, rate);
return 0;
}
#include "libavutil/intfloat_readwrite.h"
#include "libavutil/dict.h"
#include "avformat.h"
+#include "internal.h"
#include "pcm.h"
#include "sox.h"
st->codec->block_align = st->codec->bits_per_coded_sample *
st->codec->channels / 8;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
return 0;
}
AVStream *st = avformat_new_stream(s, NULL);
if (!st)
return -1;
- av_set_pts_info(st, 64, 1, 1000);
+ avpriv_set_pts_info(st, 64, 1, 1000);
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_id = CODEC_ID_SRT;
return 0;
vst->id = ch_id;
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, avio_r8(pb));
- av_set_pts_info(vst, 16, 256, swf->frame_rate);
+ avpriv_set_pts_info(vst, 16, 256, swf->frame_rate);
vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
len -= 8;
} else if (tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) {
ast->codec->sample_rate = 5512;
else
ast->codec->sample_rate = 11025 << (sample_rate_code-1);
- av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
+ avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
len -= 4;
} else if (tag == TAG_VIDEOFRAME) {
int ch_id = avio_rl16(pb);
vst->id = -2; /* -2 to avoid clash with video stream and audio stream */
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_MJPEG;
- av_set_pts_info(vst, 64, 256, swf->frame_rate);
+ avpriv_set_pts_info(vst, 64, 256, swf->frame_rate);
vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
st = vst;
}
#include "libavutil/intreadwrite.h"
#include "libavutil/intfloat_readwrite.h"
#include "avformat.h"
+#include "internal.h"
typedef struct ThpDemuxContext {
int version;
/* The denominator and numerator are switched because 1/fps
is required. */
- av_set_pts_info(st, 64, thp->fps.den, thp->fps.num);
+ avpriv_set_pts_info(st, 64, thp->fps.den, thp->fps.num);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_THP;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->channels = avio_rb32(pb); /* numChannels. */
st->codec->sample_rate = avio_rb32(pb); /* Frequency. */
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
thp->audio_stream_index = st->index;
thp->has_audio = 1;
*/
#include "avformat.h"
+#include "internal.h"
#define SEQ_FRAME_SIZE 6144
#define SEQ_FRAME_W 256
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 32, 1, SEQ_FRAME_RATE);
+ avpriv_set_pts_info(st, 32, 1, SEQ_FRAME_RATE);
seq->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_TIERTEXSEQVIDEO;
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 32, 1, SEQ_SAMPLE_RATE);
+ avpriv_set_pts_info(st, 32, 1, SEQ_SAMPLE_RATE);
seq->audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_PCM_S16BE;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
enum {
TMV_PADDING = 0x01,
ast->codec->bits_per_coded_sample = 8;
ast->codec->bit_rate = ast->codec->sample_rate *
ast->codec->bits_per_coded_sample;
- av_set_pts_info(ast, 32, 1, ast->codec->sample_rate);
+ avpriv_set_pts_info(ast, 32, 1, ast->codec->sample_rate);
fps.num = ast->codec->sample_rate * ast->codec->channels;
fps.den = tmv->audio_chunk_size;
vst->codec->pix_fmt = PIX_FMT_PAL8;
vst->codec->width = char_cols * 8;
vst->codec->height = char_rows * 8;
- av_set_pts_info(vst, 32, fps.den, fps.num);
+ avpriv_set_pts_info(vst, 32, fps.den, fps.num);
if (features & TMV_PADDING)
tmv->padding =
#include "libavcodec/get_bits.h"
#include "avformat.h"
+#include "internal.h"
#include "id3v1.h"
#include "libavutil/dict.h"
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 64, 1, samplerate);
+ avpriv_set_pts_info(st, 64, 1, samplerate);
st->start_time = 0;
st->duration = datalen;
#include "libavutil/opt.h"
#include "libavutil/parseutils.h"
#include "avformat.h"
+#include "internal.h"
#include "sauce.h"
typedef struct {
}
st->codec->width = width;
st->codec->height = height;
- av_set_pts_info(st, 60, framerate.den, framerate.num);
+ avpriv_set_pts_info(st, 60, framerate.den, framerate.num);
/* simulate tty display speed */
s->chars_per_frame = FFMAX(av_q2d(st->time_base)*s->chars_per_frame, 1);
st->probe_packets = MAX_PROBE_PACKETS;
/* default pts setting is MPEG-like */
- av_set_pts_info(st, 33, 1, 90000);
+ avpriv_set_pts_info(st, 33, 1, 90000);
st->last_IP_pts = AV_NOPTS_VALUE;
for(i=0; i<MAX_REORDER_DELAY+1; i++)
st->pts_buffer[i]= AV_NOPTS_VALUE;
return len;
}
+#if FF_API_SET_PTS_INFO
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
unsigned int pts_num, unsigned int pts_den)
+{
+ avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
+}
+#endif
+
+void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
+ unsigned int pts_num, unsigned int pts_den)
{
AVRational new_tb;
if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define VC1_EXTRADATA_SIZE 4
avio_skip(pb, 8);
fps = avio_rl32(pb);
if(fps == 0xFFFFFFFF)
- av_set_pts_info(st, 32, 1, 1000);
+ avpriv_set_pts_info(st, 32, 1, 1000);
else{
if (!fps) {
av_log(s, AV_LOG_ERROR, "Zero FPS specified, defaulting to 1 FPS\n");
fps = 1;
}
- av_set_pts_info(st, 24, 1, fps);
+ avpriv_set_pts_info(st, 24, 1, fps);
st->duration = frames;
}
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avformat.h"
+#include "internal.h"
typedef struct RCVContext {
int frames;
avio_wl32(pb, s->streams[0]->r_frame_rate.den);
else
avio_wl32(pb, 0xFFFFFFFF); //variable framerate
- av_set_pts_info(s->streams[0], 32, 1, 1000);
+ avpriv_set_pts_info(s->streams[0], 32, 1, 1000);
return 0;
}
#ifndef FF_API_OLD_INTERRUPT_CB
#define FF_API_OLD_INTERRUPT_CB (LIBAVFORMAT_VERSION_MAJOR < 54)
#endif
+#ifndef FF_API_SET_PTS_INFO
+#define FF_API_SET_PTS_INFO (LIBAVFORMAT_VERSION_MAJOR < 54)
+#endif
#endif /* AVFORMAT_VERSION_H */
*/
#include "avformat.h"
+#include "internal.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/dict.h"
#include "libavutil/mathematics.h"
return -1;
}
c->frame_bit_len = st->codec->bit_rate*size/st->codec->sample_rate;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
/* put first 12 bytes of COMM chunk in extradata */
if (!(st->codec->extradata = av_malloc(12 + FF_INPUT_BUFFER_PADDING_SIZE)))
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "avformat.h"
+#include "internal.h"
#include "avio_internal.h"
#include "pcm.h"
#include "riff.h"
if (wav->write_bext)
bwf_write_bext_chunk(s);
- av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);
+ avpriv_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);
wav->maxpts = wav->last_duration = 0;
wav->minpts = INT64_MAX;
return ret;
(*st)->need_parsing = AVSTREAM_PARSE_FULL;
- av_set_pts_info(*st, 64, 1, (*st)->codec->sample_rate);
+ avpriv_set_pts_info(*st, 64, 1, (*st)->codec->sample_rate);
return 0;
}
st->need_parsing = AVSTREAM_PARSE_FULL;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
size = find_guid(pb, guid_data);
if (size < 0) {
#include "libavutil/intreadwrite.h"
#include "libavutil/dict.h"
#include "avformat.h"
+#include "internal.h"
#define FORM_TAG MKTAG('F', 'O', 'R', 'M')
#define MOVE_TAG MKTAG('M', 'O', 'V', 'E')
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 33, 1, WC3_FRAME_FPS);
+ avpriv_set_pts_info(st, 33, 1, WC3_FRAME_FPS);
wc3->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_XAN_WC3;
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 33, 1, WC3_FRAME_FPS);
+ avpriv_set_pts_info(st, 33, 1, WC3_FRAME_FPS);
wc3->audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_PCM_S16LE;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define AUD_HEADER_SIZE 12
#define AUD_CHUNK_PREAMBLE_SIZE 8
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 33, 1, wsaud->audio_samplerate);
+ avpriv_set_pts_info(st, 33, 1, wsaud->audio_samplerate);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = wsaud->audio_type;
st->codec->codec_tag = 0; /* no tag */
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 33, 1, VQA_FRAMERATE);
+ avpriv_set_pts_info(st, 33, 1, VQA_FRAMERATE);
wsvqa->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_WS_VQA;
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
- av_set_pts_info(st, 33, 1, VQA_FRAMERATE);
+ avpriv_set_pts_info(st, 33, 1, VQA_FRAMERATE);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
if (AV_RL16(&header[0]) == 1)
st->codec->codec_id = CODEC_ID_WESTWOOD_SND1;
}
st->codec->codec_type = codec_type;
st->need_parsing = AVSTREAM_PARSE_FULL;
- av_set_pts_info(st, 64, 1, 10000000);
+ avpriv_set_pts_info(st, 64, 1, 10000000);
return st;
}
#include "libavutil/intreadwrite.h"
#include "libavutil/dict.h"
#include "avformat.h"
+#include "internal.h"
#include "apetag.h"
#include "id3v1.h"
st->codec->channel_layout = wc->chmask;
st->codec->sample_rate = wc->rate;
st->codec->bits_per_coded_sample = wc->bpp;
- av_set_pts_info(st, 64, 1, wc->rate);
+ avpriv_set_pts_info(st, 64, 1, wc->rate);
st->start_time = 0;
st->duration = wc->samples;
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#define XA00_TAG MKTAG('X', 'A', 0, 0)
#define XAI0_TAG MKTAG('X', 'A', 'I', 0)
st->codec->block_align = avio_rl16(pb);
st->codec->bits_per_coded_sample = avio_rl16(pb);
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
return 0;
}
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
#define XMV_MIN_HEADER_SIZE 36
if (!vst)
return AVERROR(ENOMEM);
- av_set_pts_info(vst, 32, 1, 1000);
+ avpriv_set_pts_info(vst, 32, 1, 1000);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_WMV2;
ast->codec->bit_rate = track->bit_rate;
ast->codec->block_align = 36 * track->channels;
- av_set_pts_info(ast, 32, track->block_samples, track->sample_rate);
+ avpriv_set_pts_info(ast, 32, track->block_samples, track->sample_rate);
packet->stream_index = ast->index;
#include <inttypes.h>
#include "avformat.h"
+#include "internal.h"
#include "riff.h"
/*
}
/* set the sample rate */
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
+ avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
/* parse the remaining RIFF chunks */
for (;;) {
#include "libavutil/intreadwrite.h"
#include "avformat.h"
+#include "internal.h"
typedef struct yop_dec_context {
AVPacket video_packet;
avio_seek(pb, 2048, SEEK_SET);
- av_set_pts_info(video_stream, 32, 1, frame_rate);
+ avpriv_set_pts_info(video_stream, 32, 1, frame_rate);
return 0;
}
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avformat.h"
+#include "internal.h"
#define Y4M_MAGIC "YUV4MPEG2"
#define Y4M_FRAME_MAGIC "FRAME"
st->codec->width = width;
st->codec->height = height;
av_reduce(&raten, &rated, raten, rated, (1UL<<31)-1);
- av_set_pts_info(st, 64, rated, raten);
+ avpriv_set_pts_info(st, 64, rated, raten);
st->codec->pix_fmt = pix_fmt;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_RAWVIDEO;