#include "audiointerleave.h"
#include "avformat.h"
-#include "avio_internal.h"
#include "id3v2.h"
#include "internal.h"
#include "metadata.h"
pkt->pos = orig_pos;
if (!pkt->size)
- av_free_packet(pkt);
+ av_packet_unref(pkt);
return pkt->size > orig_size ? pkt->size - orig_size : ret;
}
(av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
}
-AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened,
- int *score_max)
-{
- AVProbeData lpd = *pd;
- AVInputFormat *fmt1 = NULL, *fmt;
- int score, id3 = 0;
-
- if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
- int id3len = ff_id3v2_tag_len(lpd.buf);
- if (lpd.buf_size > id3len + 16) {
- lpd.buf += id3len;
- lpd.buf_size -= id3len;
- }
- id3 = 1;
- }
-
- fmt = NULL;
- while ((fmt1 = av_iformat_next(fmt1))) {
- if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
- continue;
- score = 0;
- if (fmt1->read_probe) {
- score = fmt1->read_probe(&lpd);
- } else if (fmt1->extensions) {
- if (av_match_ext(lpd.filename, fmt1->extensions))
- score = AVPROBE_SCORE_EXTENSION;
- }
- if (score > *score_max) {
- *score_max = score;
- fmt = fmt1;
- } else if (score == *score_max)
- fmt = NULL;
- }
-
- // A hack for files with huge id3v2 tags -- try to guess by file extension.
- if (!fmt && is_opened && *score_max < AVPROBE_SCORE_EXTENSION / 2) {
- while ((fmt = av_iformat_next(fmt)))
- if (fmt->extensions &&
- av_match_ext(lpd.filename, fmt->extensions)) {
- *score_max = AVPROBE_SCORE_EXTENSION / 2;
- break;
- }
- }
-
- if (!fmt && id3 && *score_max < AVPROBE_SCORE_EXTENSION / 2 - 1) {
- while ((fmt = av_iformat_next(fmt)))
- if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
- *score_max = AVPROBE_SCORE_EXTENSION / 2 - 1;
- break;
- }
- }
-
- return fmt;
-}
-
-AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
-{
- int score = 0;
- return av_probe_input_format2(pd, is_opened, &score);
-}
-
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
AVProbeData *pd, int score)
{
{ "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
{ "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
{ "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
+ { "latm", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
{ "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
{ "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
{ "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
fmt->name, score);
for (i = 0; fmt_id_type[i].name; i++) {
if (!strcmp(fmt->name, fmt_id_type[i].name)) {
- st->codec->codec_id = fmt_id_type[i].id;
- st->codec->codec_type = fmt_id_type[i].type;
+ st->codecpar->codec_id = fmt_id_type[i].id;
+ st->codecpar->codec_type = fmt_id_type[i].type;
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
+ st->codec->codec_type = st->codecpar->codec_type;
+ st->codec->codec_id = st->codecpar->codec_id;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
break;
}
}
/************************************************************/
/* input media file */
-/** size of probe buffer, for guessing file type from file contents */
-#define PROBE_BUF_MIN 2048
-#define PROBE_BUF_MAX (1 << 20)
-
-int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
- const char *filename, void *logctx,
- unsigned int offset, unsigned int max_probe_size)
-{
- AVProbeData pd = { filename ? filename : "" };
- uint8_t *buf = NULL;
- int ret = 0, probe_size;
-
- if (!max_probe_size)
- max_probe_size = PROBE_BUF_MAX;
- else if (max_probe_size > PROBE_BUF_MAX)
- max_probe_size = PROBE_BUF_MAX;
- else if (max_probe_size < PROBE_BUF_MIN)
- return AVERROR(EINVAL);
-
- if (offset >= max_probe_size)
- return AVERROR(EINVAL);
- avio_skip(pb, offset);
- max_probe_size -= offset;
-
- for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
- probe_size = FFMIN(probe_size << 1,
- FFMAX(max_probe_size, probe_size + 1))) {
- int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX / 4 : 0;
-
- /* Read probe data. */
- if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
- return ret;
- if ((ret = avio_read(pb, buf + pd.buf_size,
- probe_size - pd.buf_size)) < 0) {
- /* Fail if error was not end of file, otherwise, lower score. */
- if (ret != AVERROR_EOF) {
- av_free(buf);
- return ret;
- }
- score = 0;
- ret = 0; /* error was end of file, nothing read */
- }
- pd.buf_size += ret;
- pd.buf = buf;
-
- memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
-
- /* Guess file format. */
- *fmt = av_probe_input_format2(&pd, 1, &score);
- if (*fmt) {
- /* This can only be true in the last iteration. */
- if (score <= AVPROBE_SCORE_MAX / 4) {
- av_log(logctx, AV_LOG_WARNING,
- "Format detected only with low score of %d, "
- "misdetection possible!\n", score);
- } else
- av_log(logctx, AV_LOG_DEBUG,
- "Probed with size=%d and score=%d\n", probe_size, score);
- }
- }
-
- if (!*fmt) {
- av_free(buf);
- return AVERROR_INVALIDDATA;
- }
-
- /* Rewind. Reuse probe buffer to avoid seeking. */
- if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
- av_free(buf);
-
- return ret;
-}
-
/* Open input file and probe the format if necessary. */
static int init_input(AVFormatContext *s, const char *filename,
AVDictionary **options)
(!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
return 0;
- if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
- &s->interrupt_callback, options)) < 0)
+ ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ, options);
+ if (ret < 0)
return ret;
if (s->iformat)
return 0;
s, 0, s->probesize);
}
-static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
- AVPacketList **plast_pktl)
+static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
+ AVPacketList **plast_pktl, int ref)
{
AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
+ int ret;
+
if (!pktl)
- return NULL;
+ return AVERROR(ENOMEM);
+
+ if (ref) {
+ if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
+ av_free(pktl);
+ return ret;
+ }
+ } else {
+ pktl->pkt = *pkt;
+ }
if (*packet_buffer)
(*plast_pktl)->next = pktl;
/* Add the packet in the buffered packet list. */
*plast_pktl = pktl;
- pktl->pkt = *pkt;
- return &pktl->pkt;
+ return 0;
}
static int queue_attached_pictures(AVFormatContext *s)
{
- int i;
+ int i, ret;
for (i = 0; i < s->nb_streams; i++)
if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
s->streams[i]->discard < AVDISCARD_ALL) {
- AVPacket copy = s->streams[i]->attached_pic;
- copy.buf = av_buffer_ref(copy.buf);
- if (!copy.buf)
- return AVERROR(ENOMEM);
- add_to_pktbuf(&s->raw_packet_buffer, ©,
- &s->raw_packet_buffer_end);
+ ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
+ &s->streams[i]->attached_pic,
+ &s->internal->raw_packet_buffer_end, 1);
+ if (ret < 0)
+ return ret;
}
return 0;
}
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
+static int update_stream_avctx(AVFormatContext *s)
+{
+ int i, ret;
+ for (i = 0; i < s->nb_streams; i++) {
+ AVStream *st = s->streams[i];
+
+ if (!st->internal->need_codec_update)
+ continue;
+
+ ret = avcodec_parameters_to_context(st->codec, st->codecpar);
+ if (ret < 0)
+ return ret;
+
+ st->internal->need_codec_update = 0;
+ }
+ return 0;
+}
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
int avformat_open_input(AVFormatContext **ps, const char *filename,
AVInputFormat *fmt, AVDictionary **options)
{
AVFormatContext *s = *ps;
- int ret = 0;
+ int i, ret = 0;
AVDictionary *tmp = NULL;
ID3v2ExtraMeta *id3v2_extra_meta = NULL;
if ((ret = queue_attached_pictures(s)) < 0)
goto fail;
- if (s->pb && !s->data_offset)
- s->data_offset = avio_tell(s->pb);
+ if (s->pb && !s->internal->data_offset)
+ s->internal->data_offset = avio_tell(s->pb);
- s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
+ s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
+
+#if FF_API_LAVF_AVCTX
+ update_stream_avctx(s);
+#endif
+
+ for (i = 0; i < s->nb_streams; i++)
+ s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
if (options) {
av_dict_free(options);
static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
{
- if (st->codec->codec_id == AV_CODEC_ID_PROBE) {
+ if (st->codecpar->codec_id == AV_CODEC_ID_PROBE) {
AVProbeData *pd = &st->probe_data;
av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
--st->probe_packets;
av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
set_codec_from_probe_data(s, st, pd, st->probe_packets > 0
? AVPROBE_SCORE_MAX / 4 : 0);
- if (st->codec->codec_id != AV_CODEC_ID_PROBE) {
+ if (st->codecpar->codec_id != AV_CODEC_ID_PROBE) {
pd->buf_size = 0;
av_freep(&pd->buf);
av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
AVStream *st;
for (;;) {
- AVPacketList *pktl = s->raw_packet_buffer;
+ AVPacketList *pktl = s->internal->raw_packet_buffer;
if (pktl) {
*pkt = pktl->pkt;
st = s->streams[pkt->stream_index];
- if (st->codec->codec_id != AV_CODEC_ID_PROBE ||
+ if (st->codecpar->codec_id != AV_CODEC_ID_PROBE ||
!st->probe_packets ||
- s->raw_packet_buffer_remaining_size < pkt->size) {
+ s->internal->raw_packet_buffer_remaining_size < pkt->size) {
AVProbeData *pd;
if (st->probe_packets)
if ((err = probe_codec(s, st, NULL)) < 0)
pd = &st->probe_data;
av_freep(&pd->buf);
pd->buf_size = 0;
- s->raw_packet_buffer = pktl->next;
- s->raw_packet_buffer_remaining_size += pkt->size;
+ s->internal->raw_packet_buffer = pktl->next;
+ s->internal->raw_packet_buffer_remaining_size += pkt->size;
av_free(pktl);
return 0;
}
continue;
}
+ if (!pkt->buf) {
+ AVPacket tmp = { 0 };
+ ret = av_packet_ref(&tmp, pkt);
+ if (ret < 0)
+ return ret;
+ *pkt = tmp;
+ }
+
if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
(pkt->flags & AV_PKT_FLAG_CORRUPT)) {
av_log(s, AV_LOG_WARNING,
"Dropped corrupted packet (stream = %d)\n",
pkt->stream_index);
- av_free_packet(pkt);
+ av_packet_unref(pkt);
continue;
}
st = s->streams[pkt->stream_index];
- switch (st->codec->codec_type) {
+ switch (st->codecpar->codec_type) {
case AVMEDIA_TYPE_VIDEO:
if (s->video_codec_id)
- st->codec->codec_id = s->video_codec_id;
+ st->codecpar->codec_id = s->video_codec_id;
break;
case AVMEDIA_TYPE_AUDIO:
if (s->audio_codec_id)
- st->codec->codec_id = s->audio_codec_id;
+ st->codecpar->codec_id = s->audio_codec_id;
break;
case AVMEDIA_TYPE_SUBTITLE:
if (s->subtitle_codec_id)
- st->codec->codec_id = s->subtitle_codec_id;
+ st->codecpar->codec_id = s->subtitle_codec_id;
break;
}
- if (!pktl && (st->codec->codec_id != AV_CODEC_ID_PROBE ||
+ if (!pktl && (st->codecpar->codec_id != AV_CODEC_ID_PROBE ||
!st->probe_packets))
return ret;
- add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
- s->raw_packet_buffer_remaining_size -= pkt->size;
+ err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
+ &s->internal->raw_packet_buffer_end, 0);
+ if (err)
+ return err;
+ s->internal->raw_packet_buffer_remaining_size -= pkt->size;
if ((err = probe_codec(s, st, pkt)) < 0)
return err;
/**********************************************************/
-/**
- * Get the number of samples of an audio frame. Return -1 on error.
- */
-int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
-{
- int frame_size;
-
- /* give frame_size priority if demuxing */
- if (!mux && enc->frame_size > 1)
- return enc->frame_size;
-
- if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
- return frame_size;
-
- /* Fall back on using frame_size if muxing. */
- if (enc->frame_size > 1)
- return enc->frame_size;
-
- return -1;
-}
-
/**
* Return the frame duration in seconds. Return 0 if not available.
*/
-void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
+void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
AVCodecParserContext *pc, AVPacket *pkt)
{
+ AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
+ (AVRational){ 0, 1 };
int frame_size;
*pnum = 0;
*pden = 0;
- switch (st->codec->codec_type) {
+ switch (st->codecpar->codec_type) {
case AVMEDIA_TYPE_VIDEO:
if (st->avg_frame_rate.num) {
*pnum = st->avg_frame_rate.den;
} else if (st->time_base.num * 1000LL > st->time_base.den) {
*pnum = st->time_base.num;
*pden = st->time_base.den;
- } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
- *pnum = st->codec->time_base.num;
- *pden = st->codec->time_base.den;
+ } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
+ *pnum = codec_framerate.den;
+ *pden = codec_framerate.num;
if (pc && pc->repeat_pict) {
if (*pnum > INT_MAX / (1 + pc->repeat_pict))
*pden /= 1 + pc->repeat_pict;
/* If this codec can be interlaced or progressive then we need
* a parser to compute duration of a packet. Thus if we have
* no parser in such case leave duration undefined. */
- if (st->codec->ticks_per_frame > 1 && !pc)
+ if (st->internal->avctx->ticks_per_frame > 1 && !pc)
*pnum = *pden = 0;
}
break;
case AVMEDIA_TYPE_AUDIO:
- frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
- if (frame_size <= 0 || st->codec->sample_rate <= 0)
+ frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
+ if (frame_size <= 0 || st->codecpar->sample_rate <= 0)
break;
*pnum = frame_size;
- *pden = st->codec->sample_rate;
+ *pden = st->codecpar->sample_rate;
break;
default:
break;
int64_t dts, int64_t pts)
{
AVStream *st = s->streams[stream_index];
- AVPacketList *pktl = s->packet_buffer;
+ AVPacketList *pktl = s->internal->packet_buffer;
if (st->first_dts != AV_NOPTS_VALUE ||
dts == AV_NOPTS_VALUE ||
static void update_initial_durations(AVFormatContext *s, AVStream *st,
int stream_index, int duration)
{
- AVPacketList *pktl = s->packet_buffer;
+ AVPacketList *pktl = s->internal->packet_buffer;
int64_t cur_dts = 0;
if (st->first_dts != AV_NOPTS_VALUE) {
cur_dts -= duration;
}
}
- pktl = s->packet_buffer;
+ pktl = s->internal->packet_buffer;
st->first_dts = cur_dts;
} else if (st->cur_dts)
return;
pktl->pkt.dts == AV_NOPTS_VALUE &&
!pktl->pkt.duration) {
pktl->pkt.dts = cur_dts;
- if (!st->codec->has_b_frames)
+ if (!st->internal->avctx->has_b_frames)
pktl->pkt.pts = cur_dts;
cur_dts += duration;
- if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
+ if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
pktl->pkt.duration = duration;
} else
break;
pkt->dts = AV_NOPTS_VALUE;
/* do we have a video B-frame ? */
- delay = st->codec->has_b_frames;
+ delay = st->internal->avctx->has_b_frames;
presentation_delayed = 0;
/* XXX: need has_b_frame, but cannot get it if the codec is
if (delay == 1 && pkt->dts == pkt->pts &&
pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
- pkt->dts = pkt->pts = AV_NOPTS_VALUE;
+ pkt->dts = AV_NOPTS_VALUE;
}
- if (pkt->duration == 0 && st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
- ff_compute_frame_duration(&num, &den, st, pc, pkt);
+ if (pkt->duration == 0 && st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
+ ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
if (den && num) {
pkt->duration = av_rescale_rnd(1, num * (int64_t) st->time_base.den,
den * (int64_t) st->time_base.num,
AV_ROUND_DOWN);
- if (pkt->duration != 0 && s->packet_buffer)
+ if (pkt->duration != 0 && s->internal->packet_buffer)
update_initial_durations(s, st, pkt->stream_index,
pkt->duration);
}
pkt->pts > pkt->dts)
presentation_delayed = 1;
- av_dlog(NULL,
+ av_log(NULL, AV_LOG_TRACE,
"IN delayed:%d pts:%"PRId64", dts:%"PRId64" "
"cur_dts:%"PRId64" st:%d pc:%p\n",
presentation_delayed, pkt->pts, pkt->dts, st->cur_dts,
/* Interpolate PTS and DTS if they are not present. We skip H.264
* currently because delay and has_b_frames are not reliably set. */
if ((delay == 0 || (delay == 1 && pc)) &&
- st->codec->codec_id != AV_CODEC_ID_H264) {
+ st->codecpar->codec_id != AV_CODEC_ID_H264) {
if (presentation_delayed) {
/* DTS = decompression timestamp */
/* PTS = presentation timestamp */
} else if (pkt->pts != AV_NOPTS_VALUE ||
pkt->dts != AV_NOPTS_VALUE ||
pkt->duration ||
- st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
+ st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
int duration = pkt->duration;
- if (!duration && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
- ff_compute_frame_duration(&num, &den, st, pc, pkt);
+ if (!duration && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
+ ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
if (den && num) {
duration = av_rescale_rnd(1,
num * (int64_t) st->time_base.den,
den * (int64_t) st->time_base.num,
AV_ROUND_DOWN);
- if (duration != 0 && s->packet_buffer)
+ if (duration != 0 && s->internal->packet_buffer)
update_initial_durations(s, st, pkt->stream_index,
duration);
}
if (pkt->dts == AV_NOPTS_VALUE)
pkt->dts = st->pts_buffer[0];
// We skipped it above so we try here.
- if (st->codec->codec_id == AV_CODEC_ID_H264)
+ if (st->codecpar->codec_id == AV_CODEC_ID_H264)
// This should happen on the first packet
update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
if (pkt->dts > st->cur_dts)
st->cur_dts = pkt->dts;
}
- av_dlog(NULL,
+ av_log(NULL, AV_LOG_TRACE,
"OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n",
presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
/* update flags */
- if (is_intra_only(st->codec->codec_id))
+ if (is_intra_only(st->codecpar->codec_id))
pkt->flags |= AV_PKT_FLAG_KEY;
+#if FF_API_CONVERGENCE_DURATION
+FF_DISABLE_DEPRECATION_WARNINGS
if (pc)
pkt->convergence_duration = pc->convergence_duration;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
}
static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
while (*pkt_buf) {
AVPacketList *pktl = *pkt_buf;
*pkt_buf = pktl->next;
- av_free_packet(&pktl->pkt);
+ av_packet_unref(&pktl->pkt);
av_freep(&pktl);
}
*pkt_buf_end = NULL;
int len;
av_init_packet(&out_pkt);
- len = av_parser_parse2(st->parser, st->codec,
+ len = av_parser_parse2(st->parser, st->internal->avctx,
&out_pkt.data, &out_pkt.size, data, size,
pkt->pts, pkt->dts, pkt->pos);
/* set the duration */
out_pkt.duration = 0;
- if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
- if (st->codec->sample_rate > 0) {
+ if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
+ if (st->internal->avctx->sample_rate > 0) {
out_pkt.duration =
av_rescale_q_rnd(st->parser->duration,
- (AVRational) { 1, st->codec->sample_rate },
+ (AVRational) { 1, st->internal->avctx->sample_rate },
st->time_base,
AV_ROUND_DOWN);
}
- } else if (st->codec->time_base.num != 0 &&
- st->codec->time_base.den != 0) {
- out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
- st->codec->time_base,
- st->time_base,
- AV_ROUND_DOWN);
}
out_pkt.stream_index = st->index;
0, 0, AVINDEX_KEYFRAME);
}
- if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
- out_pkt.buf = pkt->buf;
- pkt->buf = NULL;
-#if FF_API_DESTRUCT_PACKET
-FF_DISABLE_DEPRECATION_WARNINGS
- out_pkt.destruct = pkt->destruct;
- pkt->destruct = NULL;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
- }
- if ((ret = av_dup_packet(&out_pkt)) < 0)
- goto fail;
-
- if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
- av_free_packet(&out_pkt);
- ret = AVERROR(ENOMEM);
+ if ((ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
+ &s->internal->parse_queue_end,
+ 1))) {
+ av_packet_unref(&out_pkt);
goto fail;
}
}
}
fail:
- av_free_packet(pkt);
+ av_packet_unref(pkt);
return ret;
}
static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
{
int ret = 0, i, got_packet = 0;
+ AVDictionary *metadata = NULL;
av_init_packet(pkt);
- while (!got_packet && !s->parse_queue) {
+ while (!got_packet && !s->internal->parse_queue) {
AVStream *st;
AVPacket cur_pkt;
if (s->debug & FF_FDEBUG_TS)
av_log(s, AV_LOG_DEBUG,
"ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", "
- "size=%d, duration=%d, flags=%d\n",
+ "size=%d, duration=%"PRId64", flags=%d\n",
cur_pkt.stream_index, cur_pkt.pts, cur_pkt.dts,
cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
- st->parser = av_parser_init(st->codec->codec_id);
+ st->parser = av_parser_init(st->codecpar->codec_id);
if (!st->parser)
/* no parser available: just output the raw packets */
st->need_parsing = AVSTREAM_PARSE_NONE;
return ret;
} else {
/* free packet */
- av_free_packet(&cur_pkt);
+ av_packet_unref(&cur_pkt);
}
}
- if (!got_packet && s->parse_queue)
- ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
+ if (!got_packet && s->internal->parse_queue)
+ ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
+
+ av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
+ if (metadata) {
+ s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
+ av_dict_copy(&s->metadata, metadata, 0);
+ av_dict_free(&metadata);
+ av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
+ }
+
+#if FF_API_LAVF_AVCTX
+ update_stream_avctx(s);
+#endif
if (s->debug & FF_FDEBUG_TS)
av_log(s, AV_LOG_DEBUG,
"read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", "
- "size=%d, duration=%d, flags=%d\n",
+ "size=%d, duration=%"PRId64", flags=%d\n",
pkt->stream_index, pkt->pts, pkt->dts,
pkt->size, pkt->duration, pkt->flags);
int eof = 0;
if (!genpts)
- return s->packet_buffer
- ? read_from_packet_buffer(&s->packet_buffer,
- &s->packet_buffer_end, pkt)
+ return s->internal->packet_buffer
+ ? read_from_packet_buffer(&s->internal->packet_buffer,
+ &s->internal->packet_buffer_end, pkt)
: read_frame_internal(s, pkt);
for (;;) {
int ret;
- AVPacketList *pktl = s->packet_buffer;
+ AVPacketList *pktl = s->internal->packet_buffer;
if (pktl) {
AVPacket *next_pkt = &pktl->pkt;
}
pktl = pktl->next;
}
- pktl = s->packet_buffer;
+ pktl = s->internal->packet_buffer;
}
/* read packet from packet buffer, if there is data */
if (!(next_pkt->pts == AV_NOPTS_VALUE &&
next_pkt->dts != AV_NOPTS_VALUE && !eof))
- return read_from_packet_buffer(&s->packet_buffer,
- &s->packet_buffer_end, pkt);
+ return read_from_packet_buffer(&s->internal->packet_buffer,
+ &s->internal->packet_buffer_end, pkt);
}
ret = read_frame_internal(s, pkt);
return ret;
}
- if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
- &s->packet_buffer_end)) < 0)
- return AVERROR(ENOMEM);
+ ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
+ &s->internal->packet_buffer_end, 1);
+ if (ret < 0)
+ return ret;
}
}
/* XXX: suppress the packet queue */
static void flush_packet_queue(AVFormatContext *s)
{
- free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
- free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
- free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
+ free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
+ free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
+ free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
- s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
+ s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
}
/*******************************************************/
return -1;
for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
- if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
+ if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
!(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
return i;
}
if (first_audio_index < 0 &&
- st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
+ st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
first_audio_index = i;
}
return first_audio_index >= 0 ? first_audio_index : 0;
if (stream_index < 0)
return -1;
- av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
+ av_log(s, AV_LOG_TRACE, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
ts_max =
ts_min = AV_NOPTS_VALUE;
if (e->timestamp <= target_ts || e->pos == e->min_distance) {
pos_min = e->pos;
ts_min = e->timestamp;
- av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
+ av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
pos_min, ts_min);
} else {
assert(index == 0);
pos_max = e->pos;
ts_max = e->timestamp;
pos_limit = pos_max - e->min_distance;
- av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
+ av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
" dts_max=%"PRId64"\n", pos_max, pos_limit, ts_max);
}
}
int64_t start_pos, filesize;
int no_change;
- av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
+ av_log(s, AV_LOG_TRACE, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
if (ts_min == AV_NOPTS_VALUE) {
- pos_min = s->data_offset;
+ pos_min = s->internal->data_offset;
ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
if (ts_min == AV_NOPTS_VALUE)
return -1;
no_change = 0;
while (pos_min < pos_limit) {
- av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64
+ av_log(s, AV_LOG_TRACE, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64
" dts_max=%"PRId64"\n", pos_min, pos_max, ts_min, ts_max);
assert(pos_limit <= pos_max);
no_change++;
else
no_change = 0;
- av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64
+ av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64
" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
pos_limit, start_pos, no_change);
ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
pos_min++;
ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
- av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
+ av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
pos, ts_min, target_ts, ts_max);
*ts_ret = ts;
return pos;
{
int64_t pos_min, pos_max;
- pos_min = s->data_offset;
+ pos_min = s->internal->data_offset;
pos_max = avio_size(s->pb) - 1;
if (pos < pos_min)
return ret;
ff_update_cur_dts(s, st, ie->timestamp);
} else {
- if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
+ if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
return ret;
}
for (;;) {
} while (read_status == AVERROR(EAGAIN));
if (read_status < 0)
break;
- av_free_packet(&pkt);
+ av_packet_unref(&pkt);
if (stream_index == pkt.stream_index)
if ((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
break;
int bit_rate = 0;
for (i = 0; i < ic->nb_streams; i++) {
st = ic->streams[i];
- if (st->codec->bit_rate > 0) {
- if (INT_MAX - st->codec->bit_rate < bit_rate) {
+ if (st->codecpar->bit_rate > 0) {
+ if (INT_MAX - st->codecpar->bit_rate < bit_rate) {
bit_rate = 0;
break;
}
- bit_rate += st->codec->bit_rate;
+ bit_rate += st->codecpar->bit_rate;
}
}
ic->bit_rate = bit_rate;
for (i = 0; i < ic->nb_streams; i++) {
st = ic->streams[i];
if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
- av_log(st->codec, AV_LOG_WARNING,
+ av_log(ic, AV_LOG_WARNING,
"start time is not set in estimate_timings_from_pts\n");
if (st->parser) {
st->duration = duration;
}
}
- av_free_packet(pkt);
+ av_packet_unref(pkt);
}
} while (end_time == AV_NOPTS_VALUE &&
filesize > (DURATION_MAX_READ_SIZE << retry) &&
if ((!strcmp(ic->iformat->name, "mpeg") ||
!strcmp(ic->iformat->name, "mpegts")) &&
- file_size && ic->pb->seekable) {
+ file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
/* get accurate estimate from the PTSes */
estimate_timings_from_pts(ic, old_offset);
} else if (has_duration(ic)) {
AVStream av_unused *st;
for (i = 0; i < ic->nb_streams; i++) {
st = ic->streams[i];
- av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
+ av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
(double) st->start_time / AV_TIME_BASE,
(double) st->duration / AV_TIME_BASE);
}
- av_dlog(ic,
+ av_log(ic, AV_LOG_TRACE,
"stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
(double) ic->start_time / AV_TIME_BASE,
(double) ic->duration / AV_TIME_BASE,
static int has_codec_parameters(AVStream *st)
{
- AVCodecContext *avctx = st->codec;
+ AVCodecContext *avctx = st->internal->avctx;
int val;
switch (avctx->codec_type) {
static int has_decode_delay_been_guessed(AVStream *st)
{
- return st->codec->codec_id != AV_CODEC_ID_H264 ||
+ return st->internal->avctx->codec_id != AV_CODEC_ID_H264 ||
st->info->nb_decoded_frames >= 6;
}
/* returns 1 or 0 if or if not decoded data was returned, or a negative error */
-static int try_decode_frame(AVStream *st, AVPacket *avpkt,
+static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
AVDictionary **options)
{
+ AVCodecContext *avctx = st->internal->avctx;
const AVCodec *codec;
int got_picture = 1, ret = 0;
AVFrame *frame = av_frame_alloc();
if (!frame)
return AVERROR(ENOMEM);
- if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
+ if (!avcodec_is_open(avctx) && !st->info->found_decoder) {
AVDictionary *thread_opt = NULL;
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
codec = st->codec->codec ? st->codec->codec
- : avcodec_find_decoder(st->codec->codec_id);
+ : avcodec_find_decoder(st->codecpar->codec_id);
+FF_ENABLE_DEPRECATION_WARNINGS
+#else
+ codec = avcodec_find_decoder(st->codecpar->codec_id);
+#endif
if (!codec) {
st->info->found_decoder = -1;
/* Force thread count to 1 since the H.264 decoder will not extract
* SPS and PPS to extradata during multi-threaded decoding. */
av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
- ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
+ ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
if (!options)
av_dict_free(&thread_opt);
if (ret < 0) {
ret >= 0 &&
(!has_codec_parameters(st) || !has_decode_delay_been_guessed(st) ||
(!st->codec_info_nb_frames &&
- st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
+ (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
got_picture = 0;
- switch (st->codec->codec_type) {
- case AVMEDIA_TYPE_VIDEO:
- ret = avcodec_decode_video2(st->codec, frame,
- &got_picture, &pkt);
- break;
- case AVMEDIA_TYPE_AUDIO:
- ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
- break;
- default:
- break;
+ if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
+ avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
+ ret = avcodec_send_packet(avctx, &pkt);
+ if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
+ break;
+ if (ret >= 0)
+ pkt.size = 0;
+ ret = avcodec_receive_frame(avctx, frame);
+ if (ret >= 0)
+ got_picture = 1;
+ if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+ ret = 0;
}
if (ret >= 0) {
if (got_picture)
st->info->nb_decoded_frames++;
- pkt.data += ret;
- pkt.size -= ret;
ret = got_picture;
}
}
return ((const int[]) { 24, 30, 60, 12, 15 })[i - 60 * 12] * 1000 * 12;
}
-/* Is the time base unreliable?
- * This is a heuristic to balance between quick acceptance of the values in
- * the headers vs. some extra checks.
- * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
- * MPEG-2 commonly misuses field repeat flags to store different framerates.
- * And there are "variable" fps files this needs to detect as well. */
-static int tb_unreliable(AVCodecContext *c)
-{
- if (c->time_base.den >= 101L * c->time_base.num ||
- c->time_base.den < 5L * c->time_base.num ||
- // c->codec_tag == AV_RL32("DIVX") ||
- // c->codec_tag == AV_RL32("XVID") ||
- c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
- c->codec_id == AV_CODEC_ID_H264)
- return 1;
+static int extract_extradata_init(AVStream *st)
+{
+ AVStreamInternal *i = st->internal;
+ const AVBitStreamFilter *f;
+ int ret;
+
+ f = av_bsf_get_by_name("extract_extradata");
+ if (!f)
+ goto finish;
+
+ /* check that the codec id is supported */
+ if (f->codec_ids) {
+ const enum AVCodecID *ids;
+ for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
+ if (*ids == st->codecpar->codec_id)
+ break;
+ if (*ids == AV_CODEC_ID_NONE)
+ goto finish;
+ }
+
+ i->extract_extradata.pkt = av_packet_alloc();
+ if (!i->extract_extradata.pkt)
+ return AVERROR(ENOMEM);
+
+ ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
+ if (ret < 0)
+ goto fail;
+
+ ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
+ st->codecpar);
+ if (ret < 0)
+ goto fail;
+
+ i->extract_extradata.bsf->time_base_in = st->time_base;
+
+ /* if init fails here, we assume extracting extradata is just not
+ * supported for this codec, so we return success */
+ ret = av_bsf_init(i->extract_extradata.bsf);
+ if (ret < 0) {
+ av_bsf_free(&i->extract_extradata.bsf);
+ ret = 0;
+ }
+
+finish:
+ i->extract_extradata.inited = 1;
+
+ return 0;
+fail:
+ av_bsf_free(&i->extract_extradata.bsf);
+ av_packet_free(&i->extract_extradata.pkt);
+ return ret;
+}
+
+static int extract_extradata(AVStream *st, AVPacket *pkt)
+{
+ AVStreamInternal *i = st->internal;
+ AVPacket *pkt_ref;
+ int ret;
+
+ if (!i->extract_extradata.inited) {
+ ret = extract_extradata_init(st);
+ if (ret < 0)
+ return ret;
+ }
+
+ if (i->extract_extradata.inited && !i->extract_extradata.bsf)
+ return 0;
+
+ pkt_ref = i->extract_extradata.pkt;
+ ret = av_packet_ref(pkt_ref, pkt);
+ if (ret < 0)
+ return ret;
+
+ ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
+ if (ret < 0) {
+ av_packet_unref(pkt_ref);
+ return ret;
+ }
+
+ while (ret >= 0 && !i->avctx->extradata) {
+ int extradata_size;
+ uint8_t *extradata;
+
+ ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
+ if (ret < 0) {
+ if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
+ return ret;
+ continue;
+ }
+
+ extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
+ &extradata_size);
+
+ if (extradata) {
+ i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+ if (!i->avctx->extradata) {
+ av_packet_unref(pkt_ref);
+ return AVERROR(ENOMEM);
+ }
+ memcpy(i->avctx->extradata, extradata, extradata_size);
+ i->avctx->extradata_size = extradata_size;
+ }
+ av_packet_unref(pkt_ref);
+ }
+
return 0;
}
{
int i, count, ret, read_size, j;
AVStream *st;
+ AVCodecContext *avctx;
AVPacket pkt1, *pkt;
int64_t old_offset = avio_tell(ic->pb);
// new streams might appear, no options for those
const AVCodec *codec;
AVDictionary *thread_opt = NULL;
st = ic->streams[i];
+ avctx = st->internal->avctx;
// only for the split stuff
if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
- st->parser = av_parser_init(st->codec->codec_id);
+ st->parser = av_parser_init(st->codecpar->codec_id);
if (st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser)
st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
}
+
+ /* check if the caller has overridden the codec id */
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
+ if (st->codec->codec_id != st->internal->orig_codec_id) {
+ st->codecpar->codec_id = st->codec->codec_id;
+ st->codecpar->codec_type = st->codec->codec_type;
+ st->internal->orig_codec_id = st->codec->codec_id;
+ }
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+ if (st->codecpar->codec_id != st->internal->orig_codec_id)
+ st->internal->orig_codec_id = st->codecpar->codec_id;
+
+ ret = avcodec_parameters_to_context(avctx, st->codecpar);
+ if (ret < 0)
+ goto find_stream_info_err;
+ if (st->codecpar->codec_id != AV_CODEC_ID_PROBE &&
+ st->codecpar->codec_id != AV_CODEC_ID_NONE)
+ st->internal->avctx_inited = 1;
+
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
codec = st->codec->codec ? st->codec->codec
- : avcodec_find_decoder(st->codec->codec_id);
+ : avcodec_find_decoder(st->codecpar->codec_id);
+FF_ENABLE_DEPRECATION_WARNINGS
+#else
+ codec = avcodec_find_decoder(st->codecpar->codec_id);
+#endif
/* Force thread count to 1 since the H.264 decoder will not extract
* SPS and PPS to extradata during multi-threaded decoding. */
av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
/* Ensure that subtitle_header is properly set. */
- if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
- && codec && !st->codec->codec)
- avcodec_open2(st->codec, codec,
+ if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
+ && codec && !avctx->codec)
+ avcodec_open2(avctx, codec,
options ? &options[i] : &thread_opt);
// Try to just open decoders, in case this is enough to get parameters.
if (!has_codec_parameters(st)) {
- if (codec && !st->codec->codec)
- avcodec_open2(st->codec, codec,
+ if (codec && !avctx->codec)
+ avcodec_open2(avctx, codec,
options ? &options[i] : &thread_opt);
}
if (!options)
if (ic->fps_probe_size >= 0)
fps_analyze_framecount = ic->fps_probe_size;
/* variable fps and no guess at the real fps */
- if (tb_unreliable(st->codec) && !st->avg_frame_rate.num &&
+ if (!st->avg_frame_rate.num &&
st->codec_info_nb_frames < fps_analyze_framecount &&
- st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
+ st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
break;
- if (st->parser && st->parser->parser->split &&
- !st->codec->extradata)
+ if (!st->codecpar->extradata &&
+ !st->internal->avctx->extradata &&
+ (!st->internal->extract_extradata.inited ||
+ st->internal->extract_extradata.bsf))
break;
if (st->first_dts == AV_NOPTS_VALUE &&
- (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
- st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
+ st->codec_info_nb_frames < ic->max_ts_probe &&
+ (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
+ st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
break;
}
if (i == ic->nb_streams) {
/* flush the decoders */
if (st->info->found_decoder == 1) {
do {
- err = try_decode_frame(st, &empty_pkt,
+ err = try_decode_frame(ic, st, &empty_pkt,
(options && i < orig_nb_streams)
? &options[i] : NULL);
} while (err > 0 && !has_codec_parameters(st));
"decoding for stream %d failed\n", st->index);
} else if (!has_codec_parameters(st)) {
char buf[256];
- avcodec_string(buf, sizeof(buf), st->codec, 0);
+ avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
av_log(ic, AV_LOG_WARNING,
"Could not find codec parameters (%s)\n", buf);
} else {
break;
}
- if (ic->flags & AVFMT_FLAG_NOBUFFER) {
- pkt = &pkt1;
- } else {
- pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
- &ic->packet_buffer_end);
- if ((ret = av_dup_packet(pkt)) < 0)
+ pkt = &pkt1;
+
+ if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
+ ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
+ &ic->internal->packet_buffer_end, 0);
+ if (ret < 0)
goto find_stream_info_err;
}
read_size += pkt->size;
st = ic->streams[pkt->stream_index];
+ avctx = st->internal->avctx;
+ if (!st->internal->avctx_inited) {
+ ret = avcodec_parameters_to_context(avctx, st->codecpar);
+ if (ret < 0)
+ goto find_stream_info_err;
+ st->internal->avctx_inited = 1;
+ }
+
if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
/* check for non-increasing dts */
if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
/* check max_analyze_duration */
if (av_rescale_q(pkt->dts - st->info->fps_first_dts, st->time_base,
AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
- av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
+ av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached\n",
+ ic->max_analyze_duration);
+ if (ic->flags & AVFMT_FLAG_NOBUFFER)
+ av_packet_unref(pkt);
break;
}
}
- if (st->parser && st->parser->parser->split && !st->codec->extradata) {
- int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
- if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
- st->codec->extradata_size = i;
- st->codec->extradata = av_malloc(st->codec->extradata_size +
- FF_INPUT_BUFFER_PADDING_SIZE);
- if (!st->codec->extradata)
- return AVERROR(ENOMEM);
- memcpy(st->codec->extradata, pkt->data,
- st->codec->extradata_size);
- memset(st->codec->extradata + i, 0,
- FF_INPUT_BUFFER_PADDING_SIZE);
- }
+ if (!st->internal->avctx->extradata) {
+ ret = extract_extradata(st, pkt);
+ if (ret < 0)
+ goto find_stream_info_err;
}
/* If still no information, we try to open the codec and to
* it takes longer and uses more memory. For MPEG-4, we need to
* decompress for QuickTime.
*
- * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
+ * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
* least one frame of codec data, this makes sure the codec initializes
* the channel configuration and does not only trust the values from
* the container. */
- try_decode_frame(st, pkt,
+ try_decode_frame(ic, st, pkt,
(options && i < orig_nb_streams) ? &options[i] : NULL);
+ if (ic->flags & AVFMT_FLAG_NOBUFFER)
+ av_packet_unref(pkt);
+
st->codec_info_nb_frames++;
count++;
}
- // close codecs which were opened in try_decode_frame()
- for (i = 0; i < ic->nb_streams; i++) {
- st = ic->streams[i];
- avcodec_close(st->codec);
- }
for (i = 0; i < ic->nb_streams; i++) {
st = ic->streams[i];
- if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+ avctx = st->internal->avctx;
+ if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
/* estimate average framerate if not set by demuxer */
if (!st->avg_frame_rate.num &&
st->info->fps_last_dts != st->info->fps_first_dts) {
av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
best_fps, 12 * 1001, INT_MAX);
}
- } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
- if (!st->codec->bits_per_coded_sample)
- st->codec->bits_per_coded_sample =
- av_get_bits_per_sample(st->codec->codec_id);
+ } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
+ if (!avctx->bits_per_coded_sample)
+ avctx->bits_per_coded_sample =
+ av_get_bits_per_sample(avctx->codec_id);
// set stream disposition based on audio service type
- switch (st->codec->audio_service_type) {
+ switch (avctx->audio_service_type) {
case AV_AUDIO_SERVICE_TYPE_EFFECTS:
st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
break;
}
}
- estimate_timings(ic, old_offset);
-
compute_chapters_end(ic);
+ /* update the stream parameters from the internal codec contexts */
+ for (i = 0; i < ic->nb_streams; i++) {
+ st = ic->streams[i];
+ if (!st->internal->avctx_inited)
+ continue;
+
+ ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
+ if (ret < 0)
+ goto find_stream_info_err;
+
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
+ ret = avcodec_parameters_to_context(st->codec, st->codecpar);
+ if (ret < 0)
+ goto find_stream_info_err;
+
+ if (st->internal->avctx->subtitle_header) {
+ st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
+ if (!st->codec->subtitle_header)
+ goto find_stream_info_err;
+ st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
+ memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
+ st->codec->subtitle_header_size);
+ }
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
+ st->internal->avctx_inited = 0;
+ }
+
+ estimate_timings(ic, old_offset);
+
find_stream_info_err:
for (i = 0; i < ic->nb_streams; i++) {
- ic->streams[i]->codec->thread_count = 0;
+ avcodec_close(ic->streams[i]->internal->avctx);
av_freep(&ic->streams[i]->info);
+ av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
+ av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
}
return ret;
}
for (i = 0; i < nb_streams; i++) {
int real_stream_index = program ? program[i] : i;
AVStream *st = ic->streams[real_stream_index];
- AVCodecContext *avctx = st->codec;
- if (avctx->codec_type != type)
+ AVCodecParameters *par = st->codecpar;
+ if (par->codec_type != type)
continue;
if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
continue;
AV_DISPOSITION_VISUAL_IMPAIRED))
continue;
if (decoder_ret) {
- decoder = avcodec_find_decoder(st->codec->codec_id);
+ decoder = avcodec_find_decoder(par->codec_id);
if (!decoder) {
if (ret < 0)
ret = AVERROR_DECODER_NOT_FOUND;
return AVERROR(ENOSYS);
}
+static void free_stream(AVStream **pst)
+{
+ AVStream *st = *pst;
+ int i;
+
+ if (!st)
+ return;
+
+ for (i = 0; i < st->nb_side_data; i++)
+ av_freep(&st->side_data[i].data);
+ av_freep(&st->side_data);
+
+ if (st->parser)
+ av_parser_close(st->parser);
+
+ if (st->attached_pic.data)
+ av_packet_unref(&st->attached_pic);
+
+ if (st->internal) {
+ avcodec_free_context(&st->internal->avctx);
+ av_bsf_free(&st->internal->extract_extradata.bsf);
+ av_packet_free(&st->internal->extract_extradata.pkt);
+ }
+ av_freep(&st->internal);
+
+ av_dict_free(&st->metadata);
+ avcodec_parameters_free(&st->codecpar);
+ av_freep(&st->probe_data.buf);
+ av_free(st->index_entries);
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
+ av_free(st->codec->extradata);
+ av_free(st->codec->subtitle_header);
+ av_free(st->codec);
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+ av_free(st->priv_data);
+ av_free(st->info);
+
+ av_freep(pst);
+}
+
void avformat_free_context(AVFormatContext *s)
{
int i;
- AVStream *st;
+
+ if (!s)
+ return;
av_opt_free(s);
if (s->iformat && s->iformat->priv_class && s->priv_data)
av_opt_free(s->priv_data);
- for (i = 0; i < s->nb_streams; i++) {
- /* free all data in a stream component */
- st = s->streams[i];
- if (st->parser) {
- av_parser_close(st->parser);
- }
- if (st->attached_pic.data)
- av_free_packet(&st->attached_pic);
- av_dict_free(&st->metadata);
- av_freep(&st->probe_data.buf);
- av_free(st->index_entries);
- av_free(st->codec->extradata);
- av_free(st->codec->subtitle_header);
- av_free(st->codec);
- av_free(st->priv_data);
- av_free(st->info);
- av_free(st);
- }
+ for (i = 0; i < s->nb_streams; i++)
+ free_stream(&s->streams[i]);
+
for (i = s->nb_programs - 1; i >= 0; i--) {
av_dict_free(&s->programs[i]->metadata);
av_freep(&s->programs[i]->stream_index);
void avformat_close_input(AVFormatContext **ps)
{
AVFormatContext *s = *ps;
- AVIOContext *pb = s->pb;
+ AVIOContext *pb;
+
+ if (!*ps)
+ return;
+
+ pb = s->pb;
if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
(s->flags & AVFMT_FLAG_CUSTOM_IO))
avio_close(pb);
}
-AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
+AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
{
AVStream *st;
int i;
return NULL;
}
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
st->codec = avcodec_alloc_context3(c);
- if (s->iformat)
+ if (!st->codec) {
+ av_free(st->info);
+ av_free(st);
+ return NULL;
+ }
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
+ st->internal = av_mallocz(sizeof(*st->internal));
+ if (!st->internal)
+ goto fail;
+
+ if (s->iformat) {
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
/* no default bitrate if decoding */
st->codec->bit_rate = 0;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
+ /* default pts setting is MPEG-like */
+ avpriv_set_pts_info(st, 33, 1, 90000);
+ /* we set the current DTS to 0 so that formats without any timestamps
+ * but durations get some timestamps, formats with some unknown
+ * timestamps have their first few packets buffered and the
+ * timestamps corrected before they are returned to the user */
+ st->cur_dts = 0;
+ } else {
+ st->cur_dts = AV_NOPTS_VALUE;
+ }
+
+ st->codecpar = avcodec_parameters_alloc();
+ if (!st->codecpar)
+ goto fail;
+
+ st->internal->avctx = avcodec_alloc_context3(NULL);
+ if (!st->internal->avctx)
+ goto fail;
+
st->index = s->nb_streams;
st->start_time = AV_NOPTS_VALUE;
st->duration = AV_NOPTS_VALUE;
- /* we set the current DTS to 0 so that formats without any timestamps
- * but durations get some timestamps, formats with some unknown
- * timestamps have their first few packets buffered and the
- * timestamps corrected before they are returned to the user */
- st->cur_dts = 0;
st->first_dts = AV_NOPTS_VALUE;
st->probe_packets = MAX_PROBE_PACKETS;
- /* default pts setting is MPEG-like */
- 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;
st->info->fps_first_dts = AV_NOPTS_VALUE;
st->info->fps_last_dts = AV_NOPTS_VALUE;
+#if FF_API_LAVF_AVCTX
+ st->internal->need_codec_update = 1;
+#endif
+
s->streams[s->nb_streams++] = st;
return st;
+fail:
+ free_stream(&st);
+ return NULL;
}
AVProgram *av_new_program(AVFormatContext *ac, int id)
AVProgram *program = NULL;
int i;
- av_dlog(ac, "new_program: id=0x%04x\n", id);
+ av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
for (i = 0; i < ac->nb_programs; i++)
if (ac->programs[i]->id == id)
}
}
-static void print_fps(double d, const char *postfix)
-{
- uint64_t v = lrintf(d * 100);
- if (v % 100)
- av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
- else if (v % (100 * 1000))
- av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
- else
- av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d / 1000, postfix);
-}
-
-static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
-{
- if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
- AVDictionaryEntry *tag = NULL;
-
- av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
- while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
- if (strcmp("language", tag->key))
- av_log(ctx, AV_LOG_INFO,
- "%s %-16s: %s\n", indent, tag->key, tag->value);
- }
-}
-
-/* "user interface" functions */
-static void dump_stream_format(AVFormatContext *ic, int i,
- int index, int is_output)
-{
- char buf[256];
- int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
- AVStream *st = ic->streams[i];
- int g = av_gcd(st->time_base.num, st->time_base.den);
- AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
- avcodec_string(buf, sizeof(buf), st->codec, is_output);
- av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
- /* the pid is an important information, so we display it */
- /* XXX: add a generic system */
- if (flags & AVFMT_SHOW_IDS)
- av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
- if (lang)
- av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
- av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
- st->time_base.num / g, st->time_base.den / g);
- av_log(NULL, AV_LOG_INFO, ": %s", buf);
- if (st->sample_aspect_ratio.num && // default
- av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
- AVRational display_aspect_ratio;
- av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
- st->codec->width * st->sample_aspect_ratio.num,
- st->codec->height * st->sample_aspect_ratio.den,
- 1024 * 1024);
- av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
- st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
- display_aspect_ratio.num, display_aspect_ratio.den);
- }
- if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
- if (st->avg_frame_rate.den && st->avg_frame_rate.num)
- print_fps(av_q2d(st->avg_frame_rate), "fps");
- if (st->time_base.den && st->time_base.num)
- print_fps(1 / av_q2d(st->time_base), "tbn");
- if (st->codec->time_base.den && st->codec->time_base.num)
- print_fps(1 / av_q2d(st->codec->time_base), "tbc");
- }
- if (st->disposition & AV_DISPOSITION_DEFAULT)
- av_log(NULL, AV_LOG_INFO, " (default)");
- if (st->disposition & AV_DISPOSITION_DUB)
- av_log(NULL, AV_LOG_INFO, " (dub)");
- if (st->disposition & AV_DISPOSITION_ORIGINAL)
- av_log(NULL, AV_LOG_INFO, " (original)");
- if (st->disposition & AV_DISPOSITION_COMMENT)
- av_log(NULL, AV_LOG_INFO, " (comment)");
- if (st->disposition & AV_DISPOSITION_LYRICS)
- av_log(NULL, AV_LOG_INFO, " (lyrics)");
- if (st->disposition & AV_DISPOSITION_KARAOKE)
- av_log(NULL, AV_LOG_INFO, " (karaoke)");
- if (st->disposition & AV_DISPOSITION_FORCED)
- av_log(NULL, AV_LOG_INFO, " (forced)");
- if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
- av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
- if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
- av_log(NULL, AV_LOG_INFO, " (visual impaired)");
- if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
- av_log(NULL, AV_LOG_INFO, " (clean effects)");
- av_log(NULL, AV_LOG_INFO, "\n");
- dump_metadata(NULL, st->metadata, " ");
-}
-
-void av_dump_format(AVFormatContext *ic, int index,
- const char *url, int is_output)
-{
- int i;
- uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
- if (ic->nb_streams && !printed)
- return;
-
- av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
- is_output ? "Output" : "Input",
- index,
- is_output ? ic->oformat->name : ic->iformat->name,
- is_output ? "to" : "from", url);
- dump_metadata(NULL, ic->metadata, " ");
- if (!is_output) {
- av_log(NULL, AV_LOG_INFO, " Duration: ");
- if (ic->duration != AV_NOPTS_VALUE) {
- int hours, mins, secs, us;
- secs = ic->duration / AV_TIME_BASE;
- us = ic->duration % AV_TIME_BASE;
- mins = secs / 60;
- secs %= 60;
- hours = mins / 60;
- mins %= 60;
- av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
- (100 * us) / AV_TIME_BASE);
- } else {
- av_log(NULL, AV_LOG_INFO, "N/A");
- }
- if (ic->start_time != AV_NOPTS_VALUE) {
- int secs, us;
- av_log(NULL, AV_LOG_INFO, ", start: ");
- secs = ic->start_time / AV_TIME_BASE;
- us = abs(ic->start_time % AV_TIME_BASE);
- av_log(NULL, AV_LOG_INFO, "%d.%06d",
- secs, (int) av_rescale(us, 1000000, AV_TIME_BASE));
- }
- av_log(NULL, AV_LOG_INFO, ", bitrate: ");
- if (ic->bit_rate)
- av_log(NULL, AV_LOG_INFO, "%d kb/s", ic->bit_rate / 1000);
- else
- av_log(NULL, AV_LOG_INFO, "N/A");
- av_log(NULL, AV_LOG_INFO, "\n");
- }
- for (i = 0; i < ic->nb_chapters; i++) {
- AVChapter *ch = ic->chapters[i];
- av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
- av_log(NULL, AV_LOG_INFO,
- "start %f, ", ch->start * av_q2d(ch->time_base));
- av_log(NULL, AV_LOG_INFO,
- "end %f\n", ch->end * av_q2d(ch->time_base));
-
- dump_metadata(NULL, ch->metadata, " ");
- }
- if (ic->nb_programs) {
- int j, k, total = 0;
- for (j = 0; j < ic->nb_programs; j++) {
- AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
- "name", NULL, 0);
- av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
- name ? name->value : "");
- dump_metadata(NULL, ic->programs[j]->metadata, " ");
- for (k = 0; k < ic->programs[j]->nb_stream_indexes; k++) {
- dump_stream_format(ic, ic->programs[j]->stream_index[k],
- index, is_output);
- printed[ic->programs[j]->stream_index[k]] = 1;
- }
- total += ic->programs[j]->nb_stream_indexes;
- }
- if (total < ic->nb_streams)
- av_log(NULL, AV_LOG_INFO, " No Program\n");
- }
- for (i = 0; i < ic->nb_streams; i++)
- if (!printed[i])
- dump_stream_format(ic, i, index, is_output);
-
- av_free(printed);
-}
-
uint64_t ff_ntp_time(void)
{
return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
return -1;
}
-#define HEXDUMP_PRINT(...) \
- do { \
- if (!f) \
- av_log(avcl, level, __VA_ARGS__); \
- else \
- fprintf(f, __VA_ARGS__); \
- } while (0)
-
-static void hex_dump_internal(void *avcl, FILE *f, int level,
- const uint8_t *buf, int size)
-{
- int len, i, j, c;
-
- for (i = 0; i < size; i += 16) {
- len = size - i;
- if (len > 16)
- len = 16;
- HEXDUMP_PRINT("%08x ", i);
- for (j = 0; j < 16; j++) {
- if (j < len)
- HEXDUMP_PRINT(" %02x", buf[i + j]);
- else
- HEXDUMP_PRINT(" ");
- }
- HEXDUMP_PRINT(" ");
- for (j = 0; j < len; j++) {
- c = buf[i + j];
- if (c < ' ' || c > '~')
- c = '.';
- HEXDUMP_PRINT("%c", c);
- }
- HEXDUMP_PRINT("\n");
- }
-}
-
-void av_hex_dump(FILE *f, const uint8_t *buf, int size)
-{
- hex_dump_internal(NULL, f, 0, buf, size);
-}
-
-void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
-{
- hex_dump_internal(avcl, NULL, level, buf, size);
-}
-
-static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt,
- int dump_payload, AVRational time_base)
-{
- HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
- HEXDUMP_PRINT(" keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
- HEXDUMP_PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
- /* DTS is _always_ valid after av_read_frame() */
- HEXDUMP_PRINT(" dts=");
- if (pkt->dts == AV_NOPTS_VALUE)
- HEXDUMP_PRINT("N/A");
- else
- HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
- /* PTS may not be known if B-frames are present. */
- HEXDUMP_PRINT(" pts=");
- if (pkt->pts == AV_NOPTS_VALUE)
- HEXDUMP_PRINT("N/A");
- else
- HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
- HEXDUMP_PRINT("\n");
- HEXDUMP_PRINT(" size=%d\n", pkt->size);
- if (dump_payload)
- av_hex_dump(f, pkt->data, pkt->size);
-}
-
-void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
-{
- pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
-}
-
-void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
- AVStream *st)
-{
- pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
-}
-
void av_url_split(char *proto, int proto_size,
char *authorization, int authorization_size,
char *hostname, int hostname_size,
int64_t ff_iso8601_to_unix_time(const char *datestr)
{
-#if HAVE_STRPTIME
struct tm time1 = { 0 }, time2 = { 0 };
- char *ret1, *ret2;
- ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
- ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
+ const char *ret1, *ret2;
+ ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
+ ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
if (ret2 && !ret1)
return av_timegm(&time2);
else
return av_timegm(&time1);
-#else
- av_log(NULL, AV_LOG_WARNING,
- "strptime() unavailable on this system, cannot convert "
- "the date string.\n");
- return 0;
-#endif
}
-int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id,
+int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
int std_compliance)
{
if (ofmt) {
const uint8_t *data = NULL;
int size = 0;
- if (st->codec->width == 1920) {
- if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
+ if (st->codecpar->width == 1920) {
+ if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
data = avci100_1080p_extradata;
size = sizeof(avci100_1080p_extradata);
} else {
data = avci100_1080i_extradata;
size = sizeof(avci100_1080i_extradata);
}
- } else if (st->codec->width == 1440) {
+ } else if (st->codecpar->width == 1440) {
data = avci50_1080i_extradata;
size = sizeof(avci50_1080i_extradata);
- } else if (st->codec->width == 1280) {
+ } else if (st->codecpar->width == 1280) {
data = avci100_720p_extradata;
size = sizeof(avci100_720p_extradata);
}
if (!size)
return 0;
- av_freep(&st->codec->extradata);
- st->codec->extradata_size = 0;
- st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
- if (!st->codec->extradata)
+ av_freep(&st->codecpar->extradata);
+ st->codecpar->extradata_size = 0;
+ st->codecpar->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
+ if (!st->codecpar->extradata)
+ return AVERROR(ENOMEM);
+
+ memcpy(st->codecpar->extradata, data, size);
+ st->codecpar->extradata_size = size;
+
+ return 0;
+}
+
+uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
+ int *size)
+{
+ int i;
+
+ for (i = 0; i < st->nb_side_data; i++) {
+ if (st->side_data[i].type == type) {
+ if (size)
+ *size = st->side_data[i].size;
+ return st->side_data[i].data;
+ }
+ }
+ return NULL;
+}
+
+int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
+ uint8_t *data, size_t size)
+{
+ AVPacketSideData *sd, *tmp;
+ int i;
+
+ for (i = 0; i < st->nb_side_data; i++) {
+ sd = &st->side_data[i];
+
+ if (sd->type == type) {
+ av_freep(&sd->data);
+ sd->data = data;
+ sd->size = size;
+ return 0;
+ }
+ }
+
+ if ((unsigned) st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
+ return AVERROR(ERANGE);
+
+ tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
+ if (!tmp) {
return AVERROR(ENOMEM);
+ }
+
+ st->side_data = tmp;
+ st->nb_side_data++;
- memcpy(st->codec->extradata, data, size);
- st->codec->extradata_size = size;
+ sd = &st->side_data[st->nb_side_data - 1];
+ sd->type = type;
+ sd->data = data;
+ sd->size = size;
return 0;
}
+
+uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
+ int size)
+{
+ int ret;
+ uint8_t *data = av_malloc(size);
+
+ if (!data)
+ return NULL;
+
+ ret = av_stream_add_side_data(st, type, data, size);
+ if (ret < 0) {
+ av_freep(&data);
+ return NULL;
+ }
+
+ return data;
+}
+
+void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
+{
+ if (*pb)
+ s->io_close(s, *pb);
+ *pb = NULL;
+}