*/
#include "avformat.h"
#include "internal.h"
+#include "libavcodec/internal.h"
#include "libavcodec/opt.h"
#include "metadata.h"
#include "libavutil/avstring.h"
#include <assert.h>
/**
- * @file libavformat/utils.c
+ * @file
* various utility functions for use within FFmpeg
*/
return NULL;
}
-/* memory handling */
+#if LIBAVFORMAT_VERSION_MAJOR < 53 && CONFIG_SHARED && HAVE_SYMVER
+FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
+{
+ av_destruct_packet_nofree(pkt);
+}
+
+FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
+{
+ av_destruct_packet(pkt);
+}
+
+FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
+{
+ return av_new_packet(pkt, size);
+}
+FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
+{
+ return av_dup_packet(pkt);
+}
+
+FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
+{
+ av_free_packet(pkt);
+}
+
+FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
+{
+ av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
+ av_init_packet(pkt);
+}
+#endif
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
{
return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
}
-static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
+AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
{
AVInputFormat *fmt1, *fmt;
int score;
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
{
- AVInputFormat *fmt;
- fmt = av_probe_input_format2(pd, 1, &score);
+ static const struct {
+ const char *name; enum CodecID id; enum AVMediaType type;
+ } fmt_id_type[] = {
+ { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
+ { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
+ { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
+ { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
+ { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
+ { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
+ { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
+ { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
+ { 0 }
+ };
+ AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
if (fmt) {
+ int i;
av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
- if (!strcmp(fmt->name, "mp3")) {
- st->codec->codec_id = CODEC_ID_MP3;
- st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
- } else if (!strcmp(fmt->name, "ac3")) {
- st->codec->codec_id = CODEC_ID_AC3;
- st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
- } else if (!strcmp(fmt->name, "eac3")) {
- st->codec->codec_id = CODEC_ID_EAC3;
- st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
- } else if (!strcmp(fmt->name, "mpegvideo")) {
- st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
- st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
- } else if (!strcmp(fmt->name, "m4v")) {
- st->codec->codec_id = CODEC_ID_MPEG4;
- st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
- } else if (!strcmp(fmt->name, "h264")) {
- st->codec->codec_id = CODEC_ID_H264;
- st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
- } else if (!strcmp(fmt->name, "dts")) {
- st->codec->codec_id = CODEC_ID_DTS;
- st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
+ 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;
+ break;
+ }
}
}
return !!fmt;
}
}
- av_free(buf);
-
if (!*fmt) {
+ av_free(buf);
return AVERROR_INVALIDDATA;
}
- if (url_fseek(*pb, 0, SEEK_SET) < 0) {
- url_fclose(*pb);
- if (url_fopen(pb, filename, URL_RDONLY) < 0)
- return AVERROR(EIO);
- }
+ /* rewind. reuse probe buffer to avoid seeking */
+ if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
+ av_free(buf);
- return 0;
+ return ret;
}
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
if (buf_size > 0) {
url_setbufsize(pb, buf_size);
}
- if ((err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, 0)) < 0) {
+ if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
goto fail;
}
}
memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
- set_codec_from_probe_data(s, st, pd, 1);
+ //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
+ set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
if(st->codec->codec_id != CODEC_ID_PROBE){
pd->buf_size=0;
av_freep(&pd->buf);
if (pc && pc->repeat_pict) {
*pnum = (*pnum) * (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){
+ *pnum = *pden = 0;
+ }
}
break;
case AVMEDIA_TYPE_AUDIO:
int num, den, presentation_delayed, delay, i;
int64_t offset;
+ if (s->flags & AVFMT_FLAG_NOFILLIN)
+ return;
+
if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
pkt->dts= AV_NOPTS_VALUE;
if (pkt->duration == 0) {
compute_frame_duration(&num, &den, st, pc, pkt);
if (den && num) {
- pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
+ pkt->duration = av_rescale_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)
update_initial_durations(s, st, pkt);
/* update flags */
if(is_intra_only(st->codec))
- pkt->flags |= PKT_FLAG_KEY;
+ pkt->flags |= AV_PKT_FLAG_KEY;
else if (pc) {
pkt->flags = 0;
/* keyframe computation */
if (pc->key_frame == 1)
- pkt->flags |= PKT_FLAG_KEY;
+ pkt->flags |= AV_PKT_FLAG_KEY;
else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
- pkt->flags |= PKT_FLAG_KEY;
+ pkt->flags |= AV_PKT_FLAG_KEY;
}
if (pc)
pkt->convergence_duration = pc->convergence_duration;
compute_pkt_fields(s, st, NULL, pkt);
s->cur_st = NULL;
if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
- (pkt->flags & PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
+ (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
ff_reduce_index(s, st->index);
av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
}
pkt->pts = st->parser->pts;
pkt->dts = st->parser->dts;
pkt->pos = st->parser->pos;
+ if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
+ s->cur_st = NULL;
+ pkt->destruct= st->cur_pkt.destruct;
+ st->cur_pkt.destruct= NULL;
+ st->cur_pkt.data = NULL;
+ assert(st->cur_len == 0);
+ }else{
pkt->destruct = NULL;
+ }
compute_pkt_fields(s, st, st->parser, pkt);
- if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
+ if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
ff_reduce_index(s, st->index);
av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
0, 0, AVINDEX_KEYFRAME);
s->cur_st = st;
st->cur_ptr = st->cur_pkt.data;
st->cur_len = st->cur_pkt.size;
- if (st->need_parsing && !st->parser) {
+ if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
st->parser = av_parser_init(st->codec->codec_id);
if (!st->parser) {
/* no parser available: just output the raw packets */
st->need_parsing = AVSTREAM_PARSE_NONE;
}else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
+ }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
+ st->parser->flags |= PARSER_FLAG_ONCE;
}
if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
st->parser->next_frame_offset=
AVPacket *next_pkt= &pktl->pkt;
if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
+ int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
if( pktl->pkt.stream_index == next_pkt->stream_index
- && next_pkt->dts < pktl->pkt.dts
- && pktl->pkt.pts != pktl->pkt.dts //not b frame
- /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
+ && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
+ && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
next_pkt->pts= pktl->pkt.dts;
}
pktl= pktl->next;
break;
av_free_packet(&pkt);
if(stream_index == pkt.stream_index){
- if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
+ if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
break;
}
}
/*******************************************************/
/**
- * Returns TRUE if the stream has accurate duration in any stream.
+ * Return TRUE if the stream has accurate duration in any stream.
*
* @return TRUE if the stream has accurate duration for at least one component.
*/
return ret;
}
-unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
+unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
{
while (tags->id != CODEC_ID_NONE) {
if (tags->id == id)
return tags[i].id;
}
for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
- if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
- && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
- && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
- && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
+ if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
return tags[i].id;
}
return CODEC_ID_NONE;
st->codec->time_base= st->time_base;
}
//only for the split stuff
- if (!st->parser) {
+ if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
st->parser = av_parser_init(st->codec->codec_id);
if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
/* we did not get all the codec info, but we read too much data */
if (read_size >= ic->probesize) {
ret = count;
- av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
+ av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
break;
}
AVStream *st;
int i;
- if (s->nb_streams >= MAX_STREAMS)
+ if (s->nb_streams >= MAX_STREAMS){
+ av_log(s, AV_LOG_ERROR, "Too many streams\n");
return NULL;
+ }
st = av_mallocz(sizeof(AVStream));
if (!st)
#if LIBAVFORMAT_VERSION_INT < (53<<16)
av_free(chapter->title);
#endif
- av_metadata_set(&chapter->metadata, "title", title);
+ av_metadata_set2(&chapter->metadata, "title", title, 0);
chapter->id = id;
chapter->time_base= time_base;
chapter->start = start;
return 0;
}
+static int validate_codec_tag(AVFormatContext *s, AVStream *st)
+{
+ const AVCodecTag *avctag;
+ int n;
+ enum CodecID id = CODEC_ID_NONE;
+ unsigned int tag = 0;
+
+ /**
+ * Check that tag + id is in the table
+ * If neither is in the table -> OK
+ * If tag is in the table with another id -> FAIL
+ * If id is in the table with another tag -> FAIL unless strict < normal
+ */
+ for (n = 0; s->oformat->codec_tag[n]; n++) {
+ avctag = s->oformat->codec_tag[n];
+ while (avctag->id != CODEC_ID_NONE) {
+ if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
+ id = avctag->id;
+ if (id == st->codec->codec_id)
+ return 1;
+ }
+ if (avctag->id == st->codec->codec_id)
+ tag = avctag->tag;
+ avctag++;
+ }
+ }
+ if (id != CODEC_ID_NONE)
+ return 0;
+ if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
+ return 0;
+ return 1;
+}
+
int av_write_header(AVFormatContext *s)
{
int ret, i;
// some sanity checks
if (s->nb_streams == 0) {
av_log(s, AV_LOG_ERROR, "no streams\n");
- return -1;
+ return AVERROR(EINVAL);
}
for(i=0;i<s->nb_streams;i++) {
case AVMEDIA_TYPE_AUDIO:
if(st->codec->sample_rate<=0){
av_log(s, AV_LOG_ERROR, "sample rate not set\n");
- return -1;
+ return AVERROR(EINVAL);
}
if(!st->codec->block_align)
st->codec->block_align = st->codec->channels *
case AVMEDIA_TYPE_VIDEO:
if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
av_log(s, AV_LOG_ERROR, "time base not set\n");
- return -1;
+ return AVERROR(EINVAL);
}
if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
av_log(s, AV_LOG_ERROR, "dimensions not set\n");
- return -1;
+ return AVERROR(EINVAL);
}
if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
- return -1;
+ return AVERROR(EINVAL);
}
break;
}
if(s->oformat->codec_tag){
+ if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
+ //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
+ st->codec->codec_tag= 0;
+ }
if(st->codec->codec_tag){
- //FIXME
- //check that tag + id is in the table
- //if neither is in the table -> OK
- //if tag is in the table with another id -> FAIL
- //if id is in the table with another tag -> FAIL unless strict < ?
+ if (!validate_codec_tag(s, st)) {
+ char tagbuf[32];
+ av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
+ av_log(s, AV_LOG_ERROR,
+ "Tag %s/0x%08x incompatible with output codec '%s'\n",
+ tagbuf, st->codec->codec_tag, st->codec->codec->name);
+ return AVERROR_INVALIDDATA;
+ }
}else
st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
}
}
/**
- * Interleaves an AVPacket correctly so it can be muxed.
+ * Interleave an AVPacket correctly so it can be muxed.
* @param out the interleaved packet will be output here
* @param in the input packet
* @param flush 1 if no further packets are available as input and all
#undef fprintf
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
PRINT("stream #%d:\n", pkt->stream_index);
- PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
+ PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
/* DTS is _always_ valid after av_read_frame() */
PRINT(" dts=");
pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
}
+#if LIBAVFORMAT_VERSION_MAJOR < 53
+attribute_deprecated
void ff_url_split(char *proto, int proto_size,
char *authorization, int authorization_size,
char *hostname, int hostname_size,
int *port_ptr,
char *path, int path_size,
const char *url)
+{
+ av_url_split(proto, proto_size,
+ authorization, authorization_size,
+ hostname, hostname_size,
+ port_ptr,
+ path, path_size,
+ url);
+}
+#endif
+
+void av_url_split(char *proto, int proto_size,
+ char *authorization, int authorization_size,
+ char *hostname, int hostname_size,
+ int *port_ptr,
+ char *path, int path_size,
+ const char *url)
{
const char *p, *ls, *at, *col, *brk;
str[0] = '\0';
if (proto)
av_strlcatf(str, size, "%s://", proto);
- if (authorization)
+ if (authorization && authorization[0])
av_strlcatf(str, size, "%s@", authorization);
#if CONFIG_NETWORK && defined(AF_INET6)
/* Determine if hostname is a numerical IPv6 address,
}
return strlen(str);
}
+
+int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
+ AVFormatContext *src)
+{
+ AVPacket local_pkt;
+
+ local_pkt = *pkt;
+ local_pkt.stream_index = dst_stream;
+ if (pkt->pts != AV_NOPTS_VALUE)
+ local_pkt.pts = av_rescale_q(pkt->pts,
+ src->streams[pkt->stream_index]->time_base,
+ dst->streams[dst_stream]->time_base);
+ if (pkt->dts != AV_NOPTS_VALUE)
+ local_pkt.dts = av_rescale_q(pkt->dts,
+ src->streams[pkt->stream_index]->time_base,
+ dst->streams[dst_stream]->time_base);
+ return av_write_frame(dst, &local_pkt);
+}
+