上传完整项目文件
This commit is contained in:
1 parent
e63d58df8d
commit
aa0dd45839
8663 files changed
+2393125
No files matched your search
@@ -0,0 +1,598 @@
|
||||
/*
|
||||
* various utility functions for use within FFmpeg
|
||||
* Copyright (c) 2000, 2001, 2002 Fabrice Bellard
|
||||
*
|
||||
* This file is part of FFmpeg.
|
||||
*
|
||||
* FFmpeg is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* FFmpeg is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with FFmpeg; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#include "libavutil/avstring.h"
|
||||
#include "libavutil/bprint.h"
|
||||
#include "libavutil/internal.h"
|
||||
#include "libavutil/mem.h"
|
||||
#include "libavutil/time.h"
|
||||
|
||||
#include "libavcodec/internal.h"
|
||||
|
||||
#include "avformat.h"
|
||||
#include "avio_internal.h"
|
||||
#include "internal.h"
|
||||
#if CONFIG_NETWORK
|
||||
#include "network.h"
|
||||
#endif
|
||||
#include "os_support.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* various utility functions for use within FFmpeg
|
||||
*/
|
||||
|
||||
/* an arbitrarily chosen "sane" max packet size -- 50M */
|
||||
#define SANE_CHUNK_SIZE (50000000)
|
||||
|
||||
/* Read the data in sane-sized chunks and append to pkt.
|
||||
* Return the number of bytes read or an error. */
|
||||
static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
|
||||
{
|
||||
int orig_size = pkt->size;
|
||||
int ret;
|
||||
|
||||
do {
|
||||
int prev_size = pkt->size;
|
||||
int read_size;
|
||||
|
||||
/* When the caller requests a lot of data, limit it to the amount
|
||||
* left in file or SANE_CHUNK_SIZE when it is not known. */
|
||||
read_size = size;
|
||||
if (read_size > SANE_CHUNK_SIZE/10) {
|
||||
read_size = ffio_limit(s, read_size);
|
||||
// If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
|
||||
if (ffiocontext(s)->maxsize < 0)
|
||||
read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
|
||||
}
|
||||
|
||||
ret = av_grow_packet(pkt, read_size);
|
||||
if (ret < 0)
|
||||
break;
|
||||
|
||||
ret = avio_read(s, pkt->data + prev_size, read_size);
|
||||
if (ret != read_size) {
|
||||
av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
|
||||
break;
|
||||
}
|
||||
|
||||
size -= read_size;
|
||||
} while (size > 0);
|
||||
if (size > 0)
|
||||
pkt->flags |= AV_PKT_FLAG_CORRUPT;
|
||||
|
||||
if (!pkt->size)
|
||||
av_packet_unref(pkt);
|
||||
return pkt->size > orig_size ? pkt->size - orig_size : ret;
|
||||
}
|
||||
|
||||
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
|
||||
{
|
||||
#if FF_API_INIT_PACKET
|
||||
FF_DISABLE_DEPRECATION_WARNINGS
|
||||
av_init_packet(pkt);
|
||||
pkt->data = NULL;
|
||||
pkt->size = 0;
|
||||
FF_ENABLE_DEPRECATION_WARNINGS
|
||||
#else
|
||||
av_packet_unref(pkt);
|
||||
#endif
|
||||
pkt->pos = avio_tell(s);
|
||||
|
||||
return append_packet_chunked(s, pkt, size);
|
||||
}
|
||||
|
||||
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
|
||||
{
|
||||
if (!pkt->size)
|
||||
return av_get_packet(s, pkt, size);
|
||||
return append_packet_chunked(s, pkt, size);
|
||||
}
|
||||
|
||||
int av_filename_number_test(const char *filename)
|
||||
{
|
||||
char buf[1024];
|
||||
return filename &&
|
||||
(av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
|
||||
}
|
||||
|
||||
/**********************************************************/
|
||||
|
||||
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
|
||||
{
|
||||
while (tags->id != AV_CODEC_ID_NONE) {
|
||||
if (tags->id == id)
|
||||
return tags->tag;
|
||||
tags++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
|
||||
{
|
||||
for (int i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
|
||||
if (tag == tags[i].tag)
|
||||
return tags[i].id;
|
||||
for (int i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
|
||||
if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
|
||||
return tags[i].id;
|
||||
return AV_CODEC_ID_NONE;
|
||||
}
|
||||
|
||||
enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
|
||||
{
|
||||
if (bps <= 0 || bps > 64)
|
||||
return AV_CODEC_ID_NONE;
|
||||
|
||||
if (flt) {
|
||||
switch (bps) {
|
||||
case 32:
|
||||
return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
|
||||
case 64:
|
||||
return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
|
||||
default:
|
||||
return AV_CODEC_ID_NONE;
|
||||
}
|
||||
} else {
|
||||
bps += 7;
|
||||
bps >>= 3;
|
||||
if (sflags & (1 << (bps - 1))) {
|
||||
switch (bps) {
|
||||
case 1:
|
||||
return AV_CODEC_ID_PCM_S8;
|
||||
case 2:
|
||||
return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
|
||||
case 3:
|
||||
return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
|
||||
case 4:
|
||||
return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
|
||||
case 8:
|
||||
return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
|
||||
default:
|
||||
return AV_CODEC_ID_NONE;
|
||||
}
|
||||
} else {
|
||||
switch (bps) {
|
||||
case 1:
|
||||
return AV_CODEC_ID_PCM_U8;
|
||||
case 2:
|
||||
return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
|
||||
case 3:
|
||||
return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
|
||||
case 4:
|
||||
return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
|
||||
default:
|
||||
return AV_CODEC_ID_NONE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
|
||||
{
|
||||
unsigned int tag;
|
||||
if (!av_codec_get_tag2(tags, id, &tag))
|
||||
return 0;
|
||||
return tag;
|
||||
}
|
||||
|
||||
int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
|
||||
unsigned int *tag)
|
||||
{
|
||||
for (int i = 0; tags && tags[i]; i++) {
|
||||
const AVCodecTag *codec_tags = tags[i];
|
||||
while (codec_tags->id != AV_CODEC_ID_NONE) {
|
||||
if (codec_tags->id == id) {
|
||||
*tag = codec_tags->tag;
|
||||
return 1;
|
||||
}
|
||||
codec_tags++;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
|
||||
{
|
||||
for (int i = 0; tags && tags[i]; i++) {
|
||||
enum AVCodecID id = ff_codec_get_id(tags[i], tag);
|
||||
if (id != AV_CODEC_ID_NONE)
|
||||
return id;
|
||||
}
|
||||
return AV_CODEC_ID_NONE;
|
||||
}
|
||||
|
||||
int ff_alloc_extradata(AVCodecParameters *par, int size)
|
||||
{
|
||||
av_freep(&par->extradata);
|
||||
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)
|
||||
return AVERROR(ENOMEM);
|
||||
|
||||
memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
|
||||
par->extradata_size = size;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*******************************************************/
|
||||
|
||||
uint64_t ff_ntp_time(void)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
|
||||
{
|
||||
uint64_t sec = ntp_ts >> 32;
|
||||
uint64_t frac_part = ntp_ts & 0xFFFFFFFFULL;
|
||||
uint64_t usec = (frac_part * 1000000) / 0xFFFFFFFFULL;
|
||||
|
||||
return (sec * 1000000) + usec;
|
||||
}
|
||||
|
||||
int ff_get_frame_filename(char *buf, int buf_size, const char *path, int64_t number, int flags)
|
||||
{
|
||||
const char *p;
|
||||
char *q, buf1[20], c;
|
||||
int nd, len, percentd_found;
|
||||
|
||||
q = buf;
|
||||
p = path;
|
||||
percentd_found = 0;
|
||||
for (;;) {
|
||||
c = *p++;
|
||||
if (c == '\0')
|
||||
break;
|
||||
if (c == '%') {
|
||||
do {
|
||||
nd = 0;
|
||||
while (av_isdigit(*p)) {
|
||||
if (nd >= INT_MAX / 10 - 255)
|
||||
goto fail;
|
||||
nd = nd * 10 + *p++ - '0';
|
||||
}
|
||||
c = *p++;
|
||||
} while (av_isdigit(c));
|
||||
|
||||
switch (c) {
|
||||
case '%':
|
||||
goto addchar;
|
||||
case 'd':
|
||||
if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
|
||||
goto fail;
|
||||
percentd_found = 1;
|
||||
if (number < 0)
|
||||
nd += 1;
|
||||
snprintf(buf1, sizeof(buf1), "%0*" PRId64, nd, number);
|
||||
len = strlen(buf1);
|
||||
if ((q - buf + len) > buf_size - 1)
|
||||
goto fail;
|
||||
memcpy(q, buf1, len);
|
||||
q += len;
|
||||
break;
|
||||
default:
|
||||
goto fail;
|
||||
}
|
||||
} else {
|
||||
addchar:
|
||||
if ((q - buf) < buf_size - 1)
|
||||
*q++ = c;
|
||||
}
|
||||
}
|
||||
if (!percentd_found)
|
||||
goto fail;
|
||||
*q = '\0';
|
||||
return 0;
|
||||
fail:
|
||||
*q = '\0';
|
||||
return -1;
|
||||
}
|
||||
|
||||
int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
|
||||
{
|
||||
return ff_get_frame_filename(buf, buf_size, path, number, flags);
|
||||
}
|
||||
|
||||
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
|
||||
{
|
||||
return ff_get_frame_filename(buf, buf_size, path, number, 0);
|
||||
}
|
||||
|
||||
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, *at2, *col, *brk;
|
||||
|
||||
if (port_ptr)
|
||||
*port_ptr = -1;
|
||||
if (proto_size > 0)
|
||||
proto[0] = 0;
|
||||
if (authorization_size > 0)
|
||||
authorization[0] = 0;
|
||||
if (hostname_size > 0)
|
||||
hostname[0] = 0;
|
||||
if (path_size > 0)
|
||||
path[0] = 0;
|
||||
|
||||
/* parse protocol */
|
||||
if ((p = strchr(url, ':'))) {
|
||||
av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
|
||||
p++; /* skip ':' */
|
||||
if (*p == '/')
|
||||
p++;
|
||||
if (*p == '/')
|
||||
p++;
|
||||
} else {
|
||||
/* no protocol means plain filename */
|
||||
av_strlcpy(path, url, path_size);
|
||||
return;
|
||||
}
|
||||
|
||||
/* separate path from hostname */
|
||||
ls = p + strcspn(p, "/?#");
|
||||
av_strlcpy(path, ls, path_size);
|
||||
|
||||
/* the rest is hostname, use that to parse auth/port */
|
||||
if (ls != p) {
|
||||
/* authorization (user[:pass]@hostname) */
|
||||
at2 = p;
|
||||
while ((at = strchr(p, '@')) && at < ls) {
|
||||
av_strlcpy(authorization, at2,
|
||||
FFMIN(authorization_size, at + 1 - at2));
|
||||
p = at + 1; /* skip '@' */
|
||||
}
|
||||
|
||||
if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
|
||||
/* [host]:port */
|
||||
av_strlcpy(hostname, p + 1,
|
||||
FFMIN(hostname_size, brk - p));
|
||||
if (brk[1] == ':' && port_ptr)
|
||||
*port_ptr = atoi(brk + 2);
|
||||
} else if ((col = strchr(p, ':')) && col < ls) {
|
||||
av_strlcpy(hostname, p,
|
||||
FFMIN(col + 1 - p, hostname_size));
|
||||
if (port_ptr)
|
||||
*port_ptr = atoi(col + 1);
|
||||
} else
|
||||
av_strlcpy(hostname, p,
|
||||
FFMIN(ls + 1 - p, hostname_size));
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
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 (int i = 0; i < s; i++) {
|
||||
buff[i * 2] = hex_table[src[i] >> 4];
|
||||
buff[i * 2 + 1] = hex_table[src[i] & 0xF];
|
||||
}
|
||||
buff[2 * s] = '\0';
|
||||
|
||||
return buff;
|
||||
}
|
||||
|
||||
int ff_hex_to_data(uint8_t *data, const char *p)
|
||||
{
|
||||
int c, len, v;
|
||||
|
||||
len = 0;
|
||||
v = 1;
|
||||
for (;;) {
|
||||
p += strspn(p, SPACE_CHARS);
|
||||
if (*p == '\0')
|
||||
break;
|
||||
c = av_toupper((unsigned char) *p++);
|
||||
if (c >= '0' && c <= '9')
|
||||
c = c - '0';
|
||||
else if (c >= 'A' && c <= 'F')
|
||||
c = c - 'A' + 10;
|
||||
else
|
||||
break;
|
||||
v = (v << 4) | c;
|
||||
if (v & 0x100) {
|
||||
if (data)
|
||||
data[len] = v;
|
||||
len++;
|
||||
v = 1;
|
||||
}
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
|
||||
void *context)
|
||||
{
|
||||
const char *ptr = str;
|
||||
|
||||
/* Parse key=value pairs. */
|
||||
for (;;) {
|
||||
const char *key;
|
||||
char *dest = NULL, *dest_end;
|
||||
int key_len, dest_len = 0;
|
||||
|
||||
/* Skip whitespace and potential commas. */
|
||||
while (*ptr && (av_isspace(*ptr) || *ptr == ','))
|
||||
ptr++;
|
||||
if (!*ptr)
|
||||
break;
|
||||
|
||||
key = ptr;
|
||||
|
||||
if (!(ptr = strchr(key, '=')))
|
||||
break;
|
||||
ptr++;
|
||||
key_len = ptr - key;
|
||||
|
||||
callback_get_buf(context, key, key_len, &dest, &dest_len);
|
||||
dest_end = dest ? dest + dest_len - 1 : NULL;
|
||||
|
||||
if (*ptr == '\"') {
|
||||
ptr++;
|
||||
while (*ptr && *ptr != '\"') {
|
||||
if (*ptr == '\\') {
|
||||
if (!ptr[1])
|
||||
break;
|
||||
if (dest && dest < dest_end)
|
||||
*dest++ = ptr[1];
|
||||
ptr += 2;
|
||||
} else {
|
||||
if (dest && dest < dest_end)
|
||||
*dest++ = *ptr;
|
||||
ptr++;
|
||||
}
|
||||
}
|
||||
if (*ptr == '\"')
|
||||
ptr++;
|
||||
} else {
|
||||
for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
|
||||
if (dest && dest < dest_end)
|
||||
*dest++ = *ptr;
|
||||
}
|
||||
if (dest)
|
||||
*dest = 0;
|
||||
}
|
||||
}
|
||||
|
||||
int avformat_network_init(void)
|
||||
{
|
||||
#if CONFIG_NETWORK
|
||||
int ret;
|
||||
if ((ret = ff_network_init()) < 0)
|
||||
return ret;
|
||||
if ((ret = ff_tls_init()) < 0)
|
||||
return ret;
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
int avformat_network_deinit(void)
|
||||
{
|
||||
#if CONFIG_NETWORK
|
||||
ff_network_close();
|
||||
ff_tls_deinit();
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ff_is_http_proto(const char *filename) {
|
||||
const char *proto = avio_find_protocol_name(filename);
|
||||
return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
|
||||
}
|
||||
|
||||
int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
|
||||
{
|
||||
int ret;
|
||||
char *str;
|
||||
|
||||
ret = av_bprint_finalize(buf, &str);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (!av_bprint_is_complete(buf)) {
|
||||
av_free(str);
|
||||
return AVERROR(ENOMEM);
|
||||
}
|
||||
|
||||
par->extradata = str;
|
||||
/* Note: the string is NUL terminated (so extradata can be read as a
|
||||
* string), but the ending character is not accounted in the size (in
|
||||
* binary formats you are likely not supposed to mux that character). When
|
||||
* extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
|
||||
* zeros. */
|
||||
par->extradata_size = buf->len;
|
||||
return 0;
|
||||
}
|
||||
Reference in new issue
Block a user