#include "metadata.h"
#include "libavutil/avstring.h"
#include "riff.h"
+#include "audiointerleave.h"
#include <sys/time.h>
#include <time.h>
#include <strings.h>
+#include <stdarg.h>
+#if CONFIG_NETWORK
+#include "network.h"
+#endif
#undef NDEBUG
#include <assert.h>
return LIBAVFORMAT_VERSION_INT;
}
-const char * avformat_configuration(void)
+const char *avformat_configuration(void)
{
return FFMPEG_CONFIGURATION;
}
-const char * avformat_license(void)
+const char *avformat_license(void)
{
#define LICENSE_PREFIX "libavformat license: "
return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
format->next = NULL;
}
-int match_ext(const char *filename, const char *extensions)
+int av_match_ext(const char *filename, const char *extensions)
{
const char *ext, *p;
char ext1[32], *q;
return !strcasecmp(name, names);
}
+#if LIBAVFORMAT_VERSION_MAJOR < 53
AVOutputFormat *guess_format(const char *short_name, const char *filename,
const char *mime_type)
+{
+ return av_guess_format(short_name, filename, mime_type);
+}
+#endif
+
+AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
+ const char *mime_type)
{
AVOutputFormat *fmt, *fmt_found;
int score_max, score;
if (!short_name && filename &&
av_filename_number_test(filename) &&
av_guess_image2_codec(filename) != CODEC_ID_NONE) {
- return guess_format("image2", NULL, NULL);
+ return av_guess_format("image2", NULL, NULL);
}
#endif
/* Find the proper file type. */
if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
score += 10;
if (filename && fmt->extensions &&
- match_ext(filename, fmt->extensions)) {
+ av_match_ext(filename, fmt->extensions)) {
score += 5;
}
if (score > score_max) {
return fmt_found;
}
+#if LIBAVFORMAT_VERSION_MAJOR < 53
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
const char *mime_type)
{
- AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
+ AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
if (fmt) {
AVOutputFormat *stream_fmt;
char stream_format_name[64];
snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
- stream_fmt = guess_format(stream_format_name, NULL, NULL);
+ stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
if (stream_fmt)
fmt = stream_fmt;
return fmt;
}
+#endif
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
const char *filename, const char *mime_type, enum CodecType type){
if (fmt1->read_probe) {
score = fmt1->read_probe(pd);
} else if (fmt1->extensions) {
- if (match_ext(pd->filename, fmt1->extensions)) {
+ if (av_match_ext(pd->filename, fmt1->extensions)) {
score = 50;
}
}
#define PROBE_BUF_MIN 2048
#define PROBE_BUF_MAX (1<<20)
+int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
+ const char *filename, void *logctx,
+ unsigned int offset, unsigned int max_probe_size)
+{
+ AVProbeData pd = { filename ? filename : "", NULL, -offset };
+ unsigned char *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);
+ }
+
+ for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0; probe_size<<=1){
+ int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
+ int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
+
+ if (probe_size < offset) {
+ continue;
+ }
+
+ /* read probe data */
+ buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
+ if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 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[offset];
+
+ memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
+
+ /* guess file format */
+ *fmt = av_probe_input_format2(&pd, 1, &score);
+ if(*fmt){
+ if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
+ 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);
+ }
+ }
+
+ av_free(buf);
+ if (url_fseek(*pb, 0, SEEK_SET) < 0) {
+ url_fclose(*pb);
+ if (url_fopen(pb, filename, URL_RDONLY) < 0)
+ return AVERROR(EIO);
+ }
+
+ return 0;
+}
+
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
AVInputFormat *fmt,
int buf_size,
AVFormatParameters *ap)
{
- int err, probe_size;
+ int err;
AVProbeData probe_data, *pd = &probe_data;
ByteIOContext *pb = NULL;
void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
if (buf_size > 0) {
url_setbufsize(pb, buf_size);
}
-
- for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
- int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
- /* read probe data */
- pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
- pd->buf_size = get_buffer(pb, pd->buf, probe_size);
-
- if ((int)pd->buf_size < 0) {
- err = pd->buf_size;
- goto fail;
- }
-
- memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
- if (url_fseek(pb, 0, SEEK_SET) < 0) {
- url_fclose(pb);
- if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
- pb = NULL;
- err = AVERROR(EIO);
- goto fail;
- }
- }
- /* guess file format */
- fmt = av_probe_input_format2(pd, 1, &score);
- if(fmt){
- if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
- 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 ((err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, 0)) < 0) {
+ goto fail;
}
- av_freep(&pd->buf);
}
/* if still no format found, error */
if (!fmt) {
- err = AVERROR_NOFMT;
+ err = AVERROR_INVALIDDATA;
goto fail;
}
if(st->codec->codec_id == CODEC_ID_PROBE){
AVProbeData *pd = &st->probe_data;
-
+ av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
--st->probe_packets;
pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
if(st->codec->codec_id != CODEC_ID_PROBE){
pd->buf_size=0;
av_freep(&pd->buf);
+ av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
}
}
}
int num, den, presentation_delayed, delay, i;
int64_t offset;
+ if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
+ pkt->dts= AV_NOPTS_VALUE;
+
if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
//FIXME Set low_delay = 0 when has_b_frames = 1
st->codec->has_b_frames = 1;
/**
* Flush the frame reader.
*/
-void av_read_frame_flush(AVFormatContext *s)
+void ff_read_frame_flush(AVFormatContext *s)
{
AVStream *st;
int i, j;
a = - 1;
b = nb_entries;
+ //optimize appending index entries at the end
+ if(b && entries[b-1].timestamp < wanted_timestamp)
+ a= b-1;
+
while (b - a > 1) {
m = (a + b) >> 1;
timestamp = entries[m].timestamp;
index = av_index_search_timestamp(st, timestamp, flags);
+ if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
+ return -1;
+
if(index < 0 || index==st->nb_index_entries-1){
int i;
AVPacket pkt;
if (index < 0)
return -1;
- av_read_frame_flush(s);
+ ff_read_frame_flush(s);
if (s->iformat->read_seek){
if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
return 0;
int ret;
AVStream *st;
- av_read_frame_flush(s);
+ ff_read_frame_flush(s);
if(flags & AVSEEK_FLAG_BYTE)
return av_seek_frame_byte(s, stream_index, timestamp, flags);
if(min_ts > ts || max_ts < ts)
return -1;
- av_read_frame_flush(s);
+ ff_read_frame_flush(s);
if (s->iformat->read_seek2)
return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
}
#define DURATION_MAX_READ_SIZE 250000
+#define DURATION_MAX_RETRY 3
/* only usable for MPEG-PS streams */
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
AVPacket pkt1, *pkt = &pkt1;
AVStream *st;
int read_size, i, ret;
- int64_t end_time;
+ int64_t end_time, start_time[MAX_STREAMS];
int64_t filesize, offset, duration;
+ int retry=0;
ic->cur_st = NULL;
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
+ if(st->start_time != AV_NOPTS_VALUE){
+ start_time[i]= st->start_time;
+ }else if(st->first_dts != AV_NOPTS_VALUE){
+ start_time[i]= st->first_dts;
+ }else
+ av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
+
if (st->parser) {
av_parser_close(st->parser);
st->parser= NULL;
}
}
- /* we read the first packets to get the first PTS (not fully
- accurate, but it is enough now) */
- url_fseek(ic->pb, 0, SEEK_SET);
- read_size = 0;
- for(;;) {
- if (read_size >= DURATION_MAX_READ_SIZE)
- break;
- /* if all info is available, we can stop */
- for(i = 0;i < ic->nb_streams; i++) {
- st = ic->streams[i];
- if (st->start_time == AV_NOPTS_VALUE)
- break;
- }
- if (i == ic->nb_streams)
- break;
-
- do{
- ret = av_read_packet(ic, pkt);
- }while(ret == AVERROR(EAGAIN));
- if (ret != 0)
- break;
- read_size += pkt->size;
- st = ic->streams[pkt->stream_index];
- if (pkt->pts != AV_NOPTS_VALUE) {
- if (st->start_time == AV_NOPTS_VALUE)
- st->start_time = pkt->pts;
- }
- av_free_packet(pkt);
- }
-
/* estimate the end time (duration) */
/* XXX: may need to support wrapping */
filesize = ic->file_size;
- offset = filesize - DURATION_MAX_READ_SIZE;
+ end_time = AV_NOPTS_VALUE;
+ do{
+ offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
if (offset < 0)
offset = 0;
url_fseek(ic->pb, offset, SEEK_SET);
read_size = 0;
for(;;) {
- if (read_size >= DURATION_MAX_READ_SIZE)
+ if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
break;
do{
read_size += pkt->size;
st = ic->streams[pkt->stream_index];
if (pkt->pts != AV_NOPTS_VALUE &&
- st->start_time != AV_NOPTS_VALUE) {
+ start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
end_time = pkt->pts;
- duration = end_time - st->start_time;
+ duration = end_time - start_time[pkt->stream_index];
+ if (duration < 0)
+ duration += 1LL<<st->pts_wrap_bits;
if (duration > 0) {
if (st->duration == AV_NOPTS_VALUE ||
st->duration < duration)
}
av_free_packet(pkt);
}
+ }while( end_time==AV_NOPTS_VALUE
+ && filesize > (DURATION_MAX_READ_SIZE<<retry)
+ && ++retry <= DURATION_MAX_RETRY);
fill_all_stream_timings(ic);
if(!enc->frame_size &&
(enc->codec_id == CODEC_ID_VORBIS ||
enc->codec_id == CODEC_ID_AAC ||
+ enc->codec_id == CODEC_ID_MP1 ||
+ enc->codec_id == CODEC_ID_MP2 ||
enc->codec_id == CODEC_ID_MP3 ||
enc->codec_id == CODEC_ID_SPEEX))
return 0;
double (*duration_error)[MAX_STD_TIMEBASES];
int64_t old_offset = url_ftell(ic->pb);
int64_t codec_info_duration[MAX_STREAMS]={0};
- int codec_info_nb_frames[MAX_STREAMS]={0};
duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
if (!duration_error) return AVERROR(ENOMEM);
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
+ if (st->codec->codec_id == CODEC_ID_AAC) {
+ st->codec->sample_rate = 0;
+ st->codec->frame_size = 0;
+ st->codec->channels = 0;
+ }
if(st->codec->codec_type == CODEC_TYPE_VIDEO){
/* if(!st->time_base.num)
st->time_base= */
st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
}
}
+ assert(!st->codec->codec);
+ //try to just open decoders, in case this is enough to get parameters
+ if(!has_codec_parameters(st->codec)){
+ AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
+ if (codec)
+ avcodec_open(st->codec, codec);
+ }
}
for(i=0;i<MAX_STREAMS;i++){
if (!has_codec_parameters(st->codec))
break;
/* variable fps and no guess at the real fps */
- if( tb_unreliable(st->codec)
+ if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
&& duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
break;
if(st->parser && st->parser->parser->split && !st->codec->extradata)
read_size += pkt->size;
st = ic->streams[pkt->stream_index];
- if(codec_info_nb_frames[st->index]>1) {
+ if(st->codec_info_nb_frames>1) {
if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
break;
}
codec_info_duration[st->index] += pkt->duration;
}
- if (pkt->duration != 0)
- codec_info_nb_frames[st->index]++;
+ st->codec_info_nb_frames++;
{
int index= pkt->stream_index;
}
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
- if(codec_info_nb_frames[i]>2)
+ if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
- (codec_info_nb_frames[i]-2)*(int64_t)st->time_base.den,
+ (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
codec_info_duration[i] *(int64_t)st->time_base.num, 60000);
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
// the check for tb_unreliable() is not completely correct, since this is not about handling
// a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
// ipmovie.c produces.
- if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
+ if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
- if(duration_count[i]
+ if(duration_count[i] && !st->r_frame_rate.num
&& tb_unreliable(st->codec) /*&&
//FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
AVStream *st;
// some sanity checks
+ if (s->nb_streams == 0) {
+ av_log(s, AV_LOG_ERROR, "no streams\n");
+ return -1;
+ }
+
for(i=0;i<s->nb_streams;i++) {
st = s->streams[i];
av_log(s, AV_LOG_ERROR, "time base not set\n");
return -1;
}
- if(st->codec->width<=0 || st->codec->height<=0){
+ 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;
}
ff_metadata_mux_compat(s);
#endif
+ /* set muxer identification string */
+ if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
+ AVMetadata *m;
+ AVMetadataTag *t;
+
+ if (!(m = av_mallocz(sizeof(AVMetadata))))
+ return AVERROR(ENOMEM);
+ av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
+ metadata_conv(&m, s->oformat->metadata_conv, NULL);
+ if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
+ av_metadata_set2(&s->metadata, t->key, t->value, 0);
+ av_metadata_free(&m);
+ }
+
if(s->oformat->write_header){
ret = s->oformat->write_header(s);
if (ret < 0)
if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
st->pts_buffer[0]= pkt->pts;
for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
- st->pts_buffer[i]= (i-delay-1) * pkt->duration;
+ st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
{
AVStream *st = s->streams[ pkt ->stream_index];
AVStream *st2= s->streams[ next->stream_index];
- int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
- int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
-
- if (pkt->dts == AV_NOPTS_VALUE)
- return 0;
-
- return next->dts * left > pkt->dts * right; //FIXME this can overflow
+ int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
+ int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
+ return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
}
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
fail:
if(ret == 0)
ret=url_ferror(s->pb);
- for(i=0;i<s->nb_streams;i++)
+ for(i=0;i<s->nb_streams;i++) {
av_freep(&s->streams[i]->priv_data);
+ av_freep(&s->streams[i]->index_entries);
+ }
av_freep(&s->priv_data);
return ret;
}
-void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
+void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
{
int i, j;
AVProgram *program=NULL;
else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
}
+static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
+{
+ if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
+ AVMetadataTag *tag=NULL;
+
+ av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
+ while((tag=av_metadata_get(m, "", tag, AV_METADATA_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)
{
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", st->time_base.num/g, st->time_base.den/g);
+ 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)) {
print_fps(1/av_q2d(st->codec->time_base), "tbc");
}
av_log(NULL, AV_LOG_INFO, "\n");
+ dump_metadata(NULL, st->metadata, " ");
}
void dump_format(AVFormatContext *ic,
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) {
}
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++) {
"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;
if (!printed[i])
dump_stream_format(ic, i, index, is_output);
- if (ic->metadata) {
- AVMetadataTag *tag=NULL;
- av_log(NULL, AV_LOG_INFO, " Metadata\n");
- while((tag=av_metadata_get(ic->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
- av_log(NULL, AV_LOG_INFO, " %-16s: %s\n", tag->key, tag->value);
- }
- }
av_free(printed);
}
return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
}
+uint64_t ff_ntp_time(void)
+{
+ return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
+}
+
int64_t parse_date(const char *datestr, int duration)
{
const char *p;
pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
}
-void 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)
+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)
{
const char *p, *ls, *at, *col, *brk;
}
}
-char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
+char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
{
int i;
- static const char hex_table[16] = { '0', '1', '2', '3',
- '4', '5', '6', '7',
- '8', '9', 'A', 'B',
- 'C', 'D', 'E', 'F' };
+ static const char hex_table_uc[16] = { '0', '1', '2', '3',
+ '4', '5', '6', '7',
+ '8', '9', 'A', 'B',
+ 'C', 'D', 'E', 'F' };
+ static const char hex_table_lc[16] = { '0', '1', '2', '3',
+ '4', '5', '6', '7',
+ '8', '9', 'a', 'b',
+ 'c', 'd', 'e', 'f' };
+ const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
for(i = 0; i < s; i++) {
buff[i * 2] = hex_table[src[i] >> 4];
if(!s->time_base.num || !s->time_base.den)
s->time_base.num= s->time_base.den= 0;
}
+
+int ff_url_join(char *str, int size, const char *proto,
+ const char *authorization, const char *hostname,
+ int port, const char *fmt, ...)
+{
+#if CONFIG_NETWORK
+ struct addrinfo hints, *ai;
+#endif
+
+ str[0] = '\0';
+ if (proto)
+ av_strlcatf(str, size, "%s://", proto);
+ if (authorization)
+ av_strlcatf(str, size, "%s@", authorization);
+#if CONFIG_NETWORK && defined(AF_INET6)
+ /* Determine if hostname is a numerical IPv6 address,
+ * properly escape it within [] in that case. */
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_flags = AI_NUMERICHOST;
+ if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
+ if (ai->ai_family == AF_INET6) {
+ av_strlcat(str, "[", size);
+ av_strlcat(str, hostname, size);
+ av_strlcat(str, "]", size);
+ } else {
+ av_strlcat(str, hostname, size);
+ }
+ freeaddrinfo(ai);
+ } else
+#endif
+ /* Not an IPv6 address, just output the plain string. */
+ av_strlcat(str, hostname, size);
+
+ if (port >= 0)
+ av_strlcatf(str, size, ":%d", port);
+ if (fmt) {
+ va_list vl;
+ int len = strlen(str);
+
+ va_start(vl, fmt);
+ vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
+ va_end(vl);
+ }
+ return strlen(str);
+}
projects / ffmpeg / blobdiff