#include "avformat.h"
#include "internal.h"
#include "libavcodec/opt.h"
+#include "metadata.h"
#include "libavutil/avstring.h"
#include "riff.h"
#include <sys/time.h>
return 0;
}
+static int match_format(const char *name, const char *names)
+{
+ const char *p;
+ int len, namelen;
+
+ if (!name || !names)
+ return 0;
+
+ namelen = strlen(name);
+ while ((p = strchr(names, ','))) {
+ len = FFMAX(p - names, namelen);
+ if (!strncasecmp(name, names, len))
+ return 1;
+ names = p+1;
+ }
+ return !strcasecmp(name, names);
+}
+
AVOutputFormat *guess_format(const char *short_name, const char *filename,
const char *mime_type)
{
int score_max, score;
/* specific test for image sequences */
-#ifdef CONFIG_IMAGE2_MUXER
+#if CONFIG_IMAGE2_MUXER
if (!short_name && filename &&
av_filename_number_test(filename) &&
av_guess_image2_codec(filename) != CODEC_ID_NONE) {
if(type == CODEC_TYPE_VIDEO){
enum CodecID codec_id= CODEC_ID_NONE;
-#ifdef CONFIG_IMAGE2_MUXER
+#if CONFIG_IMAGE2_MUXER
if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
codec_id= av_guess_image2_codec(filename);
}
{
AVInputFormat *fmt;
for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
- if (!strcmp(fmt->name, short_name))
+ if (match_format(short_name, fmt->name))
return fmt;
}
return NULL;
pkt->dts = AV_NOPTS_VALUE;
pkt->pos = -1;
pkt->duration = 0;
+ pkt->convergence_duration = 0;
pkt->flags = 0;
pkt->stream_index = 0;
pkt->destruct= av_destruct_packet_nofree;
int av_dup_packet(AVPacket *pkt)
{
- if (pkt->destruct != av_destruct_packet) {
+ if (((pkt->destruct == av_destruct_packet_nofree) || (pkt->destruct == NULL)) && pkt->data) {
uint8_t *data;
/* We duplicate the packet and don't forget to add the padding again. */
if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
/**
* Open a media file from an IO stream. 'fmt' must be specified.
*/
-static const char* format_to_name(void* ptr)
-{
- AVFormatContext* fc = (AVFormatContext*) ptr;
- if(fc->iformat) return fc->iformat->name;
- else if(fc->oformat) return fc->oformat->name;
- else return "NULL";
-}
-
-#define OFFSET(x) offsetof(AVFormatContext,x)
-#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
-//these names are too long to be readable
-#define E AV_OPT_FLAG_ENCODING_PARAM
-#define D AV_OPT_FLAG_DECODING_PARAM
-
-static const AVOption options[]={
-{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
-{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
-{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
-{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
-{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
-{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
-{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
-{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
-{"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
-{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
-{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
-{"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, 3041280, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
-{"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E|D, "fdebug"},
-{"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E|D, "fdebug"},
-{NULL},
-};
-
-#undef E
-#undef D
-#undef DEFAULT
-
-static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
-
-static void avformat_get_context_defaults(AVFormatContext *s)
-{
- memset(s, 0, sizeof(AVFormatContext));
-
- s->av_class = &av_format_context_class;
-
- av_opt_set_defaults(s);
-}
-
-AVFormatContext *av_alloc_format_context(void)
-{
- AVFormatContext *ic;
- ic = av_malloc(sizeof(AVFormatContext));
- if (!ic) return ic;
- avformat_get_context_defaults(ic);
- ic->av_class = &av_format_context_class;
- return ic;
-}
-
int av_open_input_stream(AVFormatContext **ic_ptr,
ByteIOContext *pb, const char *filename,
AVInputFormat *fmt, AVFormatParameters *ap)
if (pb && !ic->data_offset)
ic->data_offset = url_ftell(ic->pb);
+#if LIBAVFORMAT_VERSION_MAJOR < 53
+ ff_metadata_demux_compat(ic);
+#endif
+
*ic_ptr = ic;
return 0;
fail:
case CODEC_ID_ASV1:
case CODEC_ID_ASV2:
case CODEC_ID_VCR1:
+ case CODEC_ID_DNXHD:
+ case CODEC_ID_JPEG2000:
return 1;
default: break;
}
int num, den, presentation_delayed, delay, i;
int64_t offset;
+ /* do we have a video B-frame ? */
+ delay= st->codec->has_b_frames;
+ presentation_delayed = 0;
+ /* XXX: need has_b_frame, but cannot get it if the codec is
+ not initialized */
+ if (delay &&
+ pc && pc->pict_type != FF_B_TYPE)
+ presentation_delayed = 1;
+
if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
/*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
pkt->dts -= 1LL<<st->pts_wrap_bits;
}
+ // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
+ // we take the conservative approach and discard both
+ // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
+ if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
+ av_log(s, AV_LOG_ERROR, "invalid dts/pts combination\n");
+ pkt->dts= pkt->pts= AV_NOPTS_VALUE;
+ }
+
if (pkt->duration == 0) {
compute_frame_duration(&num, &den, st, pc, pkt);
if (den && num) {
pkt->dts += offset;
}
- /* do we have a video B-frame ? */
- delay= st->codec->has_b_frames;
- presentation_delayed = 0;
- /* XXX: need has_b_frame, but cannot get it if the codec is
- not initialized */
- if (delay &&
- pc && pc->pict_type != FF_B_TYPE)
- presentation_delayed = 1;
/* This may be redundant, but it should not hurt. */
if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
presentation_delayed = 1;
if (!st->need_parsing || !st->parser) {
/* no parsing needed: we just output the packet as is */
/* raw data support */
- *pkt = s->cur_pkt;
+ *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
compute_pkt_fields(s, st, NULL, pkt);
s->cur_st = NULL;
break;
- } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
+ } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
- s->cur_ptr, s->cur_len,
- s->cur_pkt.pts, s->cur_pkt.dts);
- s->cur_pkt.pts = AV_NOPTS_VALUE;
- s->cur_pkt.dts = AV_NOPTS_VALUE;
+ st->cur_ptr, st->cur_len,
+ st->cur_pkt.pts, st->cur_pkt.dts);
+ st->cur_pkt.pts = AV_NOPTS_VALUE;
+ st->cur_pkt.dts = AV_NOPTS_VALUE;
/* increment read pointer */
- s->cur_ptr += len;
- s->cur_len -= len;
+ st->cur_ptr += len;
+ st->cur_len -= len;
/* return packet if any */
if (pkt->size) {
+ pkt->pos = st->cur_pkt.pos; // Isn't quite accurate but close.
got_packet:
- pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
pkt->duration = 0;
pkt->stream_index = st->index;
pkt->pts = st->parser->pts;
}
} else {
/* free packet */
- av_free_packet(&s->cur_pkt);
+ av_free_packet(&st->cur_pkt);
s->cur_st = NULL;
}
} else {
+ AVPacket cur_pkt;
/* read next packet */
- ret = av_read_packet(s, &s->cur_pkt);
+ ret = av_read_packet(s, &cur_pkt);
if (ret < 0) {
if (ret == AVERROR(EAGAIN))
return ret;
/* no more packets: really terminate parsing */
return ret;
}
+ st = s->streams[cur_pkt.stream_index];
+ st->cur_pkt= cur_pkt;
- if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
- s->cur_pkt.dts != AV_NOPTS_VALUE &&
- s->cur_pkt.pts < s->cur_pkt.dts){
+ if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
+ st->cur_pkt.dts != AV_NOPTS_VALUE &&
+ st->cur_pkt.pts < st->cur_pkt.dts){
av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
- s->cur_pkt.stream_index,
- s->cur_pkt.pts,
- s->cur_pkt.dts,
- s->cur_pkt.size);
-// av_free_packet(&s->cur_pkt);
+ st->cur_pkt.stream_index,
+ st->cur_pkt.pts,
+ st->cur_pkt.dts,
+ st->cur_pkt.size);
+// av_free_packet(&st->cur_pkt);
// return -1;
}
- st = s->streams[s->cur_pkt.stream_index];
if(s->debug & FF_FDEBUG_TS)
av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
- s->cur_pkt.stream_index,
- s->cur_pkt.pts,
- s->cur_pkt.dts,
- s->cur_pkt.size,
- s->cur_pkt.flags);
+ st->cur_pkt.stream_index,
+ st->cur_pkt.pts,
+ st->cur_pkt.dts,
+ st->cur_pkt.size,
+ st->cur_pkt.flags);
s->cur_st = st;
- s->cur_ptr = s->cur_pkt.data;
- s->cur_len = s->cur_pkt.size;
+ st->cur_ptr = st->cur_pkt.data;
+ st->cur_len = st->cur_pkt.size;
if (st->need_parsing && !st->parser) {
st->parser = av_parser_init(st->codec->codec_id);
if (!st->parser) {
}
if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
st->parser->next_frame_offset=
- st->parser->cur_offset= s->cur_pkt.pos;
+ st->parser->cur_offset= st->cur_pkt.pos;
}
}
}
flush_packet_queue(s);
- /* free previous packet */
- if (s->cur_st) {
- if (s->cur_st->parser)
- av_free_packet(&s->cur_pkt);
- s->cur_st = NULL;
- }
- /* fail safe */
- s->cur_ptr = NULL;
- s->cur_len = 0;
+ s->cur_st = NULL;
/* for each stream, reset read state */
for(i = 0; i < s->nb_streams; i++) {
if (st->parser) {
av_parser_close(st->parser);
st->parser = NULL;
+ av_free_packet(&st->cur_pkt);
}
st->last_IP_pts = AV_NOPTS_VALUE;
st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
+ /* fail safe */
+ st->cur_ptr = NULL;
+ st->cur_len = 0;
}
}
return ret;
}
for(i=0;; i++) {
- int ret = av_read_frame(s, &pkt);
+ int ret;
+ do{
+ ret = av_read_frame(s, &pkt);
+ }while(ret == AVERROR(EAGAIN));
if(ret<0)
break;
av_free_packet(&pkt);
#define DURATION_MAX_READ_SIZE 250000
/* only usable for MPEG-PS streams */
-static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
+static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
{
AVPacket pkt1, *pkt = &pkt1;
AVStream *st;
int64_t end_time;
int64_t filesize, offset, duration;
- /* free previous packet */
- if (ic->cur_st && ic->cur_st->parser)
- av_free_packet(&ic->cur_pkt);
ic->cur_st = NULL;
/* flush packet queue */
if (st->parser) {
av_parser_close(st->parser);
st->parser= NULL;
+ av_free_packet(&st->cur_pkt);
}
}
if (i == ic->nb_streams)
break;
- ret = av_read_packet(ic, pkt);
+ do{
+ ret = av_read_packet(ic, pkt);
+ }while(ret == AVERROR(EAGAIN));
if (ret != 0)
break;
read_size += pkt->size;
if (read_size >= DURATION_MAX_READ_SIZE)
break;
- ret = av_read_packet(ic, pkt);
+ do{
+ ret = av_read_packet(ic, pkt);
+ }while(ret == AVERROR(EAGAIN));
if (ret != 0)
break;
read_size += pkt->size;
}
}
-static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
+static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
{
int64_t file_size;
return CODEC_ID_NONE;
}
-unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
+unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
{
int i;
for(i=0; tags && tags[i]; i++){
return 0;
}
-enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
+enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
{
int i;
for(i=0; tags && tags[i]; i++){
static int tb_unreliable(AVCodecContext *c){
if( c->time_base.den >= 101L*c->time_base.num
|| c->time_base.den < 5L*c->time_base.num
-/* || c->codec_tag == ff_get_fourcc("DIVX")
- || c->codec_tag == ff_get_fourcc("XVID")*/
+/* || c->codec_tag == AV_RL32("DIVX")
+ || c->codec_tag == AV_RL32("XVID")*/
|| c->codec_id == CODEC_ID_MPEG2VIDEO)
return 1;
return 0;
int64_t last_dts[MAX_STREAMS];
int duration_count[MAX_STREAMS]={0};
double (*duration_error)[MAX_STD_TIMEBASES];
- offset_t old_offset = url_ftell(ic->pb);
+ int64_t old_offset = url_ftell(ic->pb);
int64_t codec_info_duration[MAX_STREAMS]={0};
int codec_info_nb_frames[MAX_STREAMS]={0};
/* NOTE: a new stream can be added there if no header in file
(AVFMTCTX_NOHEADER) */
ret = av_read_frame_internal(ic, &pkt1);
+ if(ret == AVERROR(EAGAIN))
+ continue;
if (ret < 0) {
/* EOF or error */
ret = -1; /* we could not have all the codec parameters before EOF */
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
- if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
+ if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
if(duration_count[i]
}
}
}else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
- if(!st->codec->bits_per_sample)
- st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
+ if(!st->codec->bits_per_coded_sample)
+ st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
}
}
int i;
AVStream *st;
- /* free previous packet */
- if (s->cur_st && s->cur_st->parser)
- av_free_packet(&s->cur_pkt);
-
if (s->iformat->read_close)
s->iformat->read_close(s);
for(i=0;i<s->nb_streams;i++) {
st = s->streams[i];
if (st->parser) {
av_parser_close(st->parser);
+ av_free_packet(&st->cur_pkt);
}
+ av_metadata_free(&st->metadata);
av_free(st->index_entries);
av_free(st->codec->extradata);
av_free(st->codec);
for(i=s->nb_programs-1; i>=0; i--) {
av_freep(&s->programs[i]->provider_name);
av_freep(&s->programs[i]->name);
+ av_metadata_free(&s->programs[i]->metadata);
av_freep(&s->programs[i]->stream_index);
av_freep(&s->programs[i]);
}
av_freep(&s->priv_data);
while(s->nb_chapters--) {
av_free(s->chapters[s->nb_chapters]->title);
+ av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
av_free(s->chapters[s->nb_chapters]);
}
av_freep(&s->chapters);
+ av_metadata_free(&s->metadata);
av_free(s);
}
av_log(s, AV_LOG_ERROR, "sample rate not set\n");
return -1;
}
+ if(!st->codec->block_align)
+ st->codec->block_align = st->codec->channels *
+ av_get_bits_per_sample(st->codec->codec_id) >> 3;
break;
case CODEC_TYPE_VIDEO:
if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
av_log(s, AV_LOG_ERROR, "dimensions not set\n");
return -1;
}
+ 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;
+ }
break;
}
return AVERROR(ENOMEM);
}
+#if LIBAVFORMAT_VERSION_MAJOR < 53
+ ff_metadata_mux_compat(s);
+#endif
+
if(s->oformat->write_header){
ret = s->oformat->write_header(s);
if (ret < 0)
char buf[256];
int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
AVStream *st = ic->streams[i];
- int g = ff_gcd(st->time_base.num, st->time_base.den);
+ int g = av_gcd(st->time_base.num, st->time_base.den);
avcodec_string(buf, sizeof(buf), st->codec, is_output);
av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
/* the pid is an important information, so we display it */
av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
av_log(NULL, AV_LOG_INFO, ": %s", buf);
+ if (st->sample_aspect_ratio.num && // default
+ av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
+ AVRational display_aspect_ratio;
+ av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
+ st->codec->width*st->sample_aspect_ratio.num,
+ st->codec->height*st->sample_aspect_ratio.den,
+ 1024*1024);
+ av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
+ st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
+ display_aspect_ratio.num, display_aspect_ratio.den);
+ }
if(st->codec->codec_type == CODEC_TYPE_VIDEO){
if(st->r_frame_rate.den && st->r_frame_rate.num)
av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
dump_stream_format(ic, i, index, is_output);
}
+#if LIBAVFORMAT_VERSION_MAJOR < 53
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
{
return av_parse_video_frame_size(width_ptr, height_ptr, str);
*frame_rate_den= frame_rate.den;
return ret;
}
+#endif
-/**
- * Gets the current time in microseconds.
- */
int64_t av_gettime(void)
{
struct timeval tv;
q = NULL;
if (!duration) {
/* parse the year-month-day part */
- for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
+ for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
q = small_strptime(p, date_fmt[i], &dt);
if (q) {
break;
p++;
/* parse the hour-minute-second part */
- for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
+ for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
q = small_strptime(p, time_fmt[i], &dt);
if (q) {
break;
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
int pts_num, int pts_den)
{
- unsigned int gcd= ff_gcd(pts_num, pts_den);
+ unsigned int gcd= av_gcd(pts_num, pts_den);
s->pts_wrap_bits = pts_wrap_bits;
s->time_base.num = pts_num/gcd;
s->time_base.den = pts_den/gcd;