{ 0 }
};
int score;
- AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
+ const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
if (fmt) {
int i;
s, 0, s->format_probesize);
}
-static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
- AVPacketList **plast_pktl, int ref)
+int ff_packet_list_put(AVPacketList **packet_buffer,
+ AVPacketList **plast_pktl,
+ AVPacket *pkt, int flags)
{
AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
int ret;
if (!pktl)
return AVERROR(ENOMEM);
- if (ref) {
+ if (flags & FF_PACKETLIST_FLAG_REF_PACKET) {
if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
av_free(pktl);
return ret;
}
} else {
+ // TODO: Adapt callers in this file so the line below can use
+ // av_packet_move_ref() to effectively move the reference
+ // to the list.
pktl->pkt = *pkt;
}
continue;
}
- ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
- &s->streams[i]->attached_pic,
- &s->internal->raw_packet_buffer_end, 1);
+ ret = ff_packet_list_put(&s->internal->raw_packet_buffer,
+ &s->internal->raw_packet_buffer_end,
+ &s->streams[i]->attached_pic,
+ FF_PACKETLIST_FLAG_REF_PACKET);
if (ret < 0)
return ret;
}
int avformat_open_input(AVFormatContext **ps, const char *filename,
- AVInputFormat *fmt, AVDictionary **options)
+ ff_const59 AVInputFormat *fmt, AVDictionary **options)
{
AVFormatContext *s = *ps;
int i, ret = 0;
if (id3v2_extra_meta) {
if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
- !strcmp(s->iformat->name, "tta")) {
+ !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
goto fail;
if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
continue;
}
- if (!pkt->buf) {
- AVPacket tmp = { 0 };
- err = av_packet_ref(&tmp, pkt);
- if (err < 0)
- return err;
- *pkt = tmp;
- }
+ err = av_packet_make_refcounted(pkt);
+ if (err < 0)
+ return err;
if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
(pkt->flags & AV_PKT_FLAG_CORRUPT)) {
if (!pktl && st->request_probe <= 0)
return ret;
- err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
- &s->internal->raw_packet_buffer_end, 0);
+ err = ff_packet_list_put(&s->internal->raw_packet_buffer,
+ &s->internal->raw_packet_buffer_end,
+ pkt, 0);
if (err)
return err;
s->internal->raw_packet_buffer_remaining_size -= pkt->size;
if (st->first_dts != AV_NOPTS_VALUE ||
dts == AV_NOPTS_VALUE ||
st->cur_dts == AV_NOPTS_VALUE ||
+ st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
is_relative(dts))
return;
}
if (st->start_time == AV_NOPTS_VALUE) {
- st->start_time = pts;
+ if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
+ st->start_time = pts;
+ }
if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
}
presentation_delayed = 1;
if (s->debug & FF_FDEBUG_TS)
- av_log(s, AV_LOG_TRACE,
+ av_log(s, AV_LOG_DEBUG,
"IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
/* This is tricky: the dts must be incremented by the duration
* of the frame we are displaying, i.e. the last I- or P-frame. */
- if (st->last_IP_duration == 0)
+ if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
st->last_IP_duration = pkt->duration;
if (pkt->dts != AV_NOPTS_VALUE)
st->cur_dts = pkt->dts + st->last_IP_duration;
next_pts != AV_NOPTS_VALUE)
pkt->pts = next_dts;
- st->last_IP_duration = pkt->duration;
+ if ((uint64_t)pkt->duration <= INT32_MAX)
+ st->last_IP_duration = pkt->duration;
st->last_IP_pts = pkt->pts;
/* Cannot compute PTS if not present (we can compute it only
* by knowing the future. */
st->cur_dts = pkt->dts;
if (s->debug & FF_FDEBUG_TS)
- av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
- presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
+ av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
+ presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
/* update flags */
- if (is_intra_only(st->codecpar->codec_id))
+ if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || is_intra_only(st->codecpar->codec_id))
pkt->flags |= AV_PKT_FLAG_KEY;
#if FF_API_CONVERGENCE_DURATION
FF_DISABLE_DEPRECATION_WARNINGS
#endif
}
-static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
+void ff_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
{
- while (*pkt_buf) {
- AVPacketList *pktl = *pkt_buf;
- *pkt_buf = pktl->next;
+ AVPacketList *tmp = *pkt_buf;
+
+ while (tmp) {
+ AVPacketList *pktl = tmp;
+ tmp = pktl->next;
av_packet_unref(&pktl->pkt);
av_freep(&pktl);
}
+ *pkt_buf = NULL;
*pkt_buf_end = NULL;
}
if (!out_pkt.size)
continue;
+ if (pkt->buf && out_pkt.data == pkt->data) {
+ /* reference pkt->buf only when out_pkt.data is guaranteed to point
+ * to data in it and not in the parser's internal buffer. */
+ /* XXX: Ensure this is the case with all parsers when st->parser->flags
+ * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
+ out_pkt.buf = av_buffer_ref(pkt->buf);
+ if (!out_pkt.buf) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+ } else {
+ ret = av_packet_make_refcounted(&out_pkt);
+ if (ret < 0)
+ goto fail;
+ }
+
if (pkt->side_data) {
out_pkt.side_data = pkt->side_data;
out_pkt.side_data_elems = pkt->side_data_elems;
compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
- ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
- &s->internal->parse_queue_end, 1);
- av_packet_unref(&out_pkt);
- if (ret < 0)
+ ret = ff_packet_list_put(&s->internal->parse_queue,
+ &s->internal->parse_queue_end,
+ &out_pkt, 0);
+ if (ret < 0) {
+ av_packet_unref(&out_pkt);
goto fail;
+ }
}
/* end of the stream => close and free the parser */
return ret;
}
-static int read_from_packet_buffer(AVPacketList **pkt_buffer,
- AVPacketList **pkt_buffer_end,
- AVPacket *pkt)
+int ff_packet_list_get(AVPacketList **pkt_buffer,
+ AVPacketList **pkt_buffer_end,
+ AVPacket *pkt)
{
AVPacketList *pktl;
av_assert0(*pkt_buffer);
}
if (!got_packet && s->internal->parse_queue)
- ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
+ ret = ff_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
if (ret >= 0) {
AVStream *st = s->streams[pkt->stream_index];
if (!genpts) {
ret = s->internal->packet_buffer
- ? read_from_packet_buffer(&s->internal->packet_buffer,
+ ? ff_packet_list_get(&s->internal->packet_buffer,
&s->internal->packet_buffer_end, pkt)
: read_frame_internal(s, pkt);
if (ret < 0)
st = s->streams[next_pkt->stream_index];
if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
- ret = read_from_packet_buffer(&s->internal->packet_buffer,
+ ret = ff_packet_list_get(&s->internal->packet_buffer,
&s->internal->packet_buffer_end, pkt);
goto return_packet;
}
return ret;
}
- ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
- &s->internal->packet_buffer_end, 1);
+ ret = ff_packet_list_put(&s->internal->packet_buffer,
+ &s->internal->packet_buffer_end,
+ pkt, FF_PACKETLIST_FLAG_REF_PACKET);
av_packet_unref(pkt);
if (ret < 0)
return ret;
{
if (!s->internal)
return;
- 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);
+ ff_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
+ ff_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
+ ff_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
}
int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
int64_t target_ts, int flags)
{
- AVInputFormat *avif = s->iformat;
+ const AVInputFormat *avif = s->iformat;
int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
int64_t ts_min, ts_max, ts;
int index;
static void update_stream_timings(AVFormatContext *ic)
{
int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
- int64_t duration, duration1, filesize;
+ int64_t duration, duration1, duration_text, filesize;
int i;
- AVStream *st;
AVProgram *p;
start_time = INT64_MAX;
end_time = INT64_MIN;
end_time_text = INT64_MIN;
duration = INT64_MIN;
+ duration_text = INT64_MIN;
+
for (i = 0; i < ic->nb_streams; i++) {
- st = ic->streams[i];
+ AVStream *st = ic->streams[i];
+ int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
+ st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
start_time1 = av_rescale_q(st->start_time, st->time_base,
AV_TIME_BASE_Q);
- if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
- if (start_time1 < start_time_text)
- start_time_text = start_time1;
- } else
+ if (is_text)
+ start_time_text = FFMIN(start_time_text, start_time1);
+ else
start_time = FFMIN(start_time, start_time1);
end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
AV_TIME_BASE_Q,
AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
end_time1 += start_time1;
- if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
+ if (is_text)
end_time_text = FFMAX(end_time_text, end_time1);
else
end_time = FFMAX(end_time, end_time1);
if (st->duration != AV_NOPTS_VALUE) {
duration1 = av_rescale_q(st->duration, st->time_base,
AV_TIME_BASE_Q);
- duration = FFMAX(duration, duration1);
+ if (is_text)
+ duration_text = FFMAX(duration_text, duration1);
+ else
+ duration = FFMAX(duration, duration1);
}
}
- if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
+ if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
start_time = start_time_text;
else if (start_time > start_time_text)
av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
- if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
+ if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
end_time = end_time_text;
- } else if (end_time < end_time_text) {
+ else if (end_time < end_time_text)
av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
- }
+
+ if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
+ duration = duration_text;
+ else if (duration < duration_text)
+ av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
if (start_time != INT64_MAX) {
ic->start_time = start_time;
}
}
+ if (ic->skip_estimate_duration_from_pts) {
+ av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
+ goto skip_duration_calc;
+ }
+
av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
/* estimate the end time (duration) */
/* XXX: may need to support wrapping */
}
}
}
+skip_duration_calc:
fill_all_stream_timings(ic);
avio_seek(ic->pb, old_offset, SEEK_SET);
AVStream av_unused *st;
for (i = 0; i < ic->nb_streams; i++) {
st = ic->streams[i];
+ if (st->time_base.den)
av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
(double) st->start_time * av_q2d(st->time_base),
(double) st->duration * av_q2d(st->time_base));
int ff_alloc_extradata(AVCodecParameters *par, int size)
{
- int ret;
+ av_freep(&par->extradata);
+ par->extradata_size = 0;
- if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
- par->extradata = NULL;
- par->extradata_size = 0;
+ if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
return AVERROR(EINVAL);
- }
+
par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
- if (par->extradata) {
- memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
- par->extradata_size = size;
- ret = 0;
- } else {
- par->extradata_size = 0;
- ret = AVERROR(ENOMEM);
- }
- return ret;
+ if (!par->extradata)
+ return AVERROR(ENOMEM);
+
+ memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+ par->extradata_size = size;
+
+ return 0;
}
int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
}
}
}
- st->info->duration_count++;
- st->info->rfps_duration_sum += duration;
+ if (st->info->rfps_duration_sum <= INT64_MAX - duration) {
+ st->info->duration_count++;
+ st->info->rfps_duration_sum += duration;
+ }
if (st->info->duration_count % 10 == 0) {
int n = st->info->duration_count;
static int extract_extradata_init(AVStream *st)
{
- AVStreamInternal *i = st->internal;
+ AVStreamInternal *sti = st->internal;
const AVBitStreamFilter *f;
int ret;
if (!ret)
goto finish;
- i->extract_extradata.pkt = av_packet_alloc();
- if (!i->extract_extradata.pkt)
+ sti->extract_extradata.pkt = av_packet_alloc();
+ if (!sti->extract_extradata.pkt)
return AVERROR(ENOMEM);
- ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
+ ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
if (ret < 0)
goto fail;
- ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
+ ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
st->codecpar);
if (ret < 0)
goto fail;
- i->extract_extradata.bsf->time_base_in = st->time_base;
+ sti->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;
- }
+ ret = av_bsf_init(sti->extract_extradata.bsf);
+ if (ret < 0)
+ goto fail;
finish:
- i->extract_extradata.inited = 1;
+ sti->extract_extradata.inited = 1;
return 0;
fail:
- av_bsf_free(&i->extract_extradata.bsf);
- av_packet_free(&i->extract_extradata.pkt);
+ av_bsf_free(&sti->extract_extradata.bsf);
+ av_packet_free(&sti->extract_extradata.pkt);
return ret;
}
static int extract_extradata(AVStream *st, AVPacket *pkt)
{
- AVStreamInternal *i = st->internal;
+ AVStreamInternal *sti = st->internal;
AVPacket *pkt_ref;
int ret;
- if (!i->extract_extradata.inited) {
+ if (!sti->extract_extradata.inited) {
ret = extract_extradata_init(st);
if (ret < 0)
return ret;
}
- if (i->extract_extradata.inited && !i->extract_extradata.bsf)
+ if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
return 0;
- pkt_ref = i->extract_extradata.pkt;
+ pkt_ref = sti->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);
+ ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
if (ret < 0) {
av_packet_unref(pkt_ref);
return ret;
}
- while (ret >= 0 && !i->avctx->extradata) {
+ while (ret >= 0 && !sti->avctx->extradata) {
int extradata_size;
uint8_t *extradata;
- ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
+ ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
if (ret < 0) {
if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
return ret;
&extradata_size);
if (extradata) {
- i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
- if (!i->avctx->extradata) {
+ av_assert0(!sti->avctx->extradata);
+ if ((unsigned)extradata_size < FF_MAX_EXTRADATA_SIZE)
+ sti->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+ if (!sti->avctx->extradata) {
av_packet_unref(pkt_ref);
return AVERROR(ENOMEM);
}
- memcpy(i->avctx->extradata, extradata, extradata_size);
- i->avctx->extradata_size = extradata_size;
+ memcpy(sti->avctx->extradata, extradata, extradata_size);
+ sti->avctx->extradata_size = extradata_size;
}
av_packet_unref(pkt_ref);
}
pkt = &pkt1;
if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
- ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
- &ic->internal->packet_buffer_end, 0);
+ ret = ff_packet_list_put(&ic->internal->packet_buffer,
+ &ic->internal->packet_buffer_end,
+ pkt, 0);
if (ret < 0)
goto find_stream_info_err;
}
* sequence, we treat it as a discontinuity. */
if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
- (pkt->dts - st->info->fps_last_dts) / 1000 >
- (st->info->fps_last_dts - st->info->fps_first_dts) /
+ (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
+ (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
(st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
av_log(ic, AV_LOG_WARNING,
"DTS discontinuity in stream %d: packet %d with DTS "
break;
}
if (pkt->duration) {
- if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
+ if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
} else
st->info->codec_info_duration += pkt->duration;
continue;
}
}
- disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
+ disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
+ + !! (st->disposition & AV_DISPOSITION_DEFAULT);
count = st->codec_info_nb_frames;
bitrate = par->bit_rate;
multiframe = FFMIN(5, count);
return NULL;
dynarray_add(&ac->programs, &ac->nb_programs, program);
program->discard = AVDISCARD_NONE;
+ program->pmt_version = -1;
}
program->id = id;
program->pts_wrap_reference = AV_NOPTS_VALUE;
return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
}
+uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
+{
+ uint64_t ntp_ts, frac_part, sec;
+ uint32_t usec;
+
+ //current ntp time in seconds and micro seconds
+ sec = ntp_time_us / 1000000;
+ usec = ntp_time_us % 1000000;
+
+ //encoding in ntp timestamp format
+ frac_part = usec * 0xFFFFFFFFULL;
+ frac_part /= 1000000;
+
+ if (sec > 0xFFFFFFFFULL)
+ av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
+
+ ntp_ts = sec << 32;
+ ntp_ts |= frac_part;
+
+ return ntp_ts;
+}
+
int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
{
const char *p;
}
}
+int ff_mkdir_p(const char *path)
+{
+ int ret = 0;
+ char *temp = av_strdup(path);
+ char *pos = temp;
+ char tmp_ch = '\0';
+
+ if (!path || !temp) {
+ return -1;
+ }
+
+ if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
+ pos++;
+ } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
+ pos += 2;
+ }
+
+ for ( ; *pos != '\0'; ++pos) {
+ if (*pos == '/' || *pos == '\\') {
+ tmp_ch = *pos;
+ *pos = '\0';
+ ret = mkdir(temp, 0755);
+ *pos = tmp_ch;
+ }
+ }
+
+ if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
+ ret = mkdir(temp, 0755);
+ }
+
+ av_free(temp);
+ return ret;
+}
+
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
{
int i;
return fr;
}
-int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
- const char *spec)
-{
- if (*spec <= '9' && *spec >= '0') /* opt:index */
- return strtol(spec, NULL, 0) == st->index;
- else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
- *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
- enum AVMediaType type;
- int nopic = 0;
+/**
+ * Matches a stream specifier (but ignores requested index).
+ *
+ * @param indexptr set to point to the requested stream index if there is one
+ *
+ * @return <0 on error
+ * 0 if st is NOT a matching stream
+ * >0 if st is a matching stream
+ */
+static int match_stream_specifier(AVFormatContext *s, AVStream *st,
+ const char *spec, const char **indexptr, AVProgram **p)
+{
+ int match = 1; /* Stores if the specifier matches so far. */
+ while (*spec) {
+ if (*spec <= '9' && *spec >= '0') { /* opt:index */
+ if (indexptr)
+ *indexptr = spec;
+ return match;
+ } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
+ *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
+ enum AVMediaType type;
+ int nopic = 0;
+
+ switch (*spec++) {
+ case 'v': type = AVMEDIA_TYPE_VIDEO; break;
+ case 'a': type = AVMEDIA_TYPE_AUDIO; break;
+ case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
+ case 'd': type = AVMEDIA_TYPE_DATA; break;
+ case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
+ case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
+ default: av_assert0(0);
+ }
+ if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
+ return AVERROR(EINVAL);
- switch (*spec++) {
- case 'v': type = AVMEDIA_TYPE_VIDEO; break;
- case 'a': type = AVMEDIA_TYPE_AUDIO; break;
- case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
- case 'd': type = AVMEDIA_TYPE_DATA; break;
- case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
- case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
- default: av_assert0(0);
- }
-#if FF_API_LAVF_AVCTX
-FF_DISABLE_DEPRECATION_WARNINGS
- if (type != st->codecpar->codec_type
- && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
- return 0;
-FF_ENABLE_DEPRECATION_WARNINGS
-#else
- if (type != st->codecpar->codec_type)
- return 0;
-#endif
- if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
- return 0;
- if (*spec++ == ':') { /* possibly followed by :index */
- int i, index = strtol(spec, NULL, 0);
- for (i = 0; i < s->nb_streams; i++) {
#if FF_API_LAVF_AVCTX
FF_DISABLE_DEPRECATION_WARNINGS
- if ((s->streams[i]->codecpar->codec_type == type
- || s->streams[i]->codec->codec_type == type
- ) &&
- !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
- index-- == 0)
- return i == st->index;
-FF_ENABLE_DEPRECATION_WARNINGS
+ if (type != st->codecpar->codec_type
+ && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
+ match = 0;
+ FF_ENABLE_DEPRECATION_WARNINGS
#else
- if ((s->streams[i]->codecpar->codec_type == type) &&
- !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
- index-- == 0)
- return i == st->index;
+ if (type != st->codecpar->codec_type)
+ match = 0;
#endif
- }
- return 0;
- }
- return 1;
- } else if (*spec == 'p' && *(spec + 1) == ':') {
- int prog_id, i, j;
- char *endptr;
- spec += 2;
- prog_id = strtol(spec, &endptr, 0);
- for (i = 0; i < s->nb_programs; i++) {
- if (s->programs[i]->id != prog_id)
- continue;
+ if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
+ match = 0;
+ } else if (*spec == 'p' && *(spec + 1) == ':') {
+ int prog_id, i, j;
+ int found = 0;
+ char *endptr;
+ spec += 2;
+ prog_id = strtol(spec, &endptr, 0);
+ /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
+ if (spec == endptr || (*endptr && *endptr++ != ':'))
+ return AVERROR(EINVAL);
+ spec = endptr;
+ if (match) {
+ for (i = 0; i < s->nb_programs; i++) {
+ if (s->programs[i]->id != prog_id)
+ continue;
- if (*endptr++ == ':') {
- int stream_idx = strtol(endptr, NULL, 0);
- return stream_idx >= 0 &&
- stream_idx < s->programs[i]->nb_stream_indexes &&
- st->index == s->programs[i]->stream_index[stream_idx];
+ for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
+ if (st->index == s->programs[i]->stream_index[j]) {
+ found = 1;
+ if (p)
+ *p = s->programs[i];
+ i = s->nb_programs;
+ break;
+ }
+ }
+ }
}
-
- for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
- if (st->index == s->programs[i]->stream_index[j])
- return 1;
- }
- return 0;
- } else if (*spec == '#' ||
- (*spec == 'i' && *(spec + 1) == ':')) {
- int stream_id;
- char *endptr;
- spec += 1 + (*spec == 'i');
- stream_id = strtol(spec, &endptr, 0);
- if (!*endptr)
- return stream_id == st->id;
- } else if (*spec == 'm' && *(spec + 1) == ':') {
- AVDictionaryEntry *tag;
- char *key, *val;
- int ret;
-
- spec += 2;
- val = strchr(spec, ':');
-
- key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
- if (!key)
- return AVERROR(ENOMEM);
-
- tag = av_dict_get(st->metadata, key, NULL, 0);
- if (tag) {
- if (!val || !strcmp(tag->value, val + 1))
- ret = 1;
- else
- ret = 0;
- } else
- ret = 0;
-
- av_freep(&key);
- return ret;
- } else if (*spec == 'u') {
- AVCodecParameters *par = st->codecpar;
+ if (!found)
+ match = 0;
+ } else if (*spec == '#' ||
+ (*spec == 'i' && *(spec + 1) == ':')) {
+ int stream_id;
+ char *endptr;
+ spec += 1 + (*spec == 'i');
+ stream_id = strtol(spec, &endptr, 0);
+ if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
+ return AVERROR(EINVAL);
+ return match && (stream_id == st->id);
+ } else if (*spec == 'm' && *(spec + 1) == ':') {
+ AVDictionaryEntry *tag;
+ char *key, *val;
+ int ret;
+
+ if (match) {
+ spec += 2;
+ val = strchr(spec, ':');
+
+ key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
+ if (!key)
+ return AVERROR(ENOMEM);
+
+ tag = av_dict_get(st->metadata, key, NULL, 0);
+ if (tag) {
+ if (!val || !strcmp(tag->value, val + 1))
+ ret = 1;
+ else
+ ret = 0;
+ } else
+ ret = 0;
+
+ av_freep(&key);
+ }
+ return match && ret;
+ } else if (*spec == 'u' && *(spec + 1) == '\0') {
+ AVCodecParameters *par = st->codecpar;
#if FF_API_LAVF_AVCTX
FF_DISABLE_DEPRECATION_WARNINGS
- AVCodecContext *codec = st->codec;
+ AVCodecContext *codec = st->codec;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
- int val;
- switch (par->codec_type) {
- case AVMEDIA_TYPE_AUDIO:
- val = par->sample_rate && par->channels;
+ int val;
+ switch (par->codec_type) {
+ case AVMEDIA_TYPE_AUDIO:
+ val = par->sample_rate && par->channels;
#if FF_API_LAVF_AVCTX
- val = val || (codec->sample_rate && codec->channels);
+ val = val || (codec->sample_rate && codec->channels);
#endif
- if (par->format == AV_SAMPLE_FMT_NONE
+ if (par->format == AV_SAMPLE_FMT_NONE
#if FF_API_LAVF_AVCTX
- && codec->sample_fmt == AV_SAMPLE_FMT_NONE
+ && codec->sample_fmt == AV_SAMPLE_FMT_NONE
#endif
- )
- return 0;
- break;
- case AVMEDIA_TYPE_VIDEO:
- val = par->width && par->height;
+ )
+ return 0;
+ break;
+ case AVMEDIA_TYPE_VIDEO:
+ val = par->width && par->height;
#if FF_API_LAVF_AVCTX
- val = val || (codec->width && codec->height);
+ val = val || (codec->width && codec->height);
#endif
- if (par->format == AV_PIX_FMT_NONE
+ if (par->format == AV_PIX_FMT_NONE
#if FF_API_LAVF_AVCTX
- && codec->pix_fmt == AV_PIX_FMT_NONE
+ && codec->pix_fmt == AV_PIX_FMT_NONE
#endif
- )
- return 0;
- break;
- case AVMEDIA_TYPE_UNKNOWN:
- val = 0;
- break;
- default:
- val = 1;
- break;
- }
+ )
+ return 0;
+ break;
+ case AVMEDIA_TYPE_UNKNOWN:
+ val = 0;
+ break;
+ default:
+ val = 1;
+ break;
+ }
#if FF_API_LAVF_AVCTX
- return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
+ return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
#else
- return par->codec_id != AV_CODEC_ID_NONE && val != 0;
+ return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
#endif
- } else if (!*spec) /* empty specifier, matches everything */
- return 1;
+ } else {
+ return AVERROR(EINVAL);
+ }
+ }
+
+ return match;
+}
- av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
- return AVERROR(EINVAL);
+
+int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
+ const char *spec)
+{
+ int ret, index;
+ char *endptr;
+ const char *indexptr = NULL;
+ AVProgram *p = NULL;
+ int nb_streams;
+
+ ret = match_stream_specifier(s, st, spec, &indexptr, &p);
+ if (ret < 0)
+ goto error;
+
+ if (!indexptr)
+ return ret;
+
+ index = strtol(indexptr, &endptr, 0);
+ if (*endptr) { /* We can't have anything after the requested index. */
+ ret = AVERROR(EINVAL);
+ goto error;
+ }
+
+ /* This is not really needed but saves us a loop for simple stream index specifiers. */
+ if (spec == indexptr)
+ return (index == st->index);
+
+ /* If we requested a matching stream index, we have to ensure st is that. */
+ nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
+ for (int i = 0; i < nb_streams && index >= 0; i++) {
+ AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
+ ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
+ if (ret < 0)
+ goto error;
+ if (ret > 0 && index-- == 0 && st == candidate)
+ return 1;
+ }
+ return 0;
+
+error:
+ if (ret == AVERROR(EINVAL))
+ av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
+ return ret;
}
int ff_generate_avci_extradata(AVStream *st)
projects / ffmpeg / blobdiff