RepoMirrors/ffmpeg
1
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2024-12-18 13:35:13 +00:00
Code Issues Projects Releases Wiki Activity
5c026e6637
ffmpeg/libavformat/utils.c
Andreas Rheinhardt 790f793844 avutil/common: Don't auto-include mem.h 
There are lots of files that don't need it: The number of object
files that actually need it went down from 2011 to 884 here.

Keep it for external users in order to not cause breakages.

Also improve the other headers a bit while just at it.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2024-03-31 00:08:43 +01:00

607 lines
16 KiB
C
Raw Blame History

/*
* 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/thread.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"
static AVMutex avformat_mutex = AV_MUTEX_INITIALIZER;
/**
* @file
* various utility functions for use within FFmpeg
*/
int ff_lock_avformat(void)
{
return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
}
int ff_unlock_avformat(void)
{
return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
}
/* 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 av_get_frame_filename2(char *buf, int buf_size, const char *path, int 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*d", 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_filename(char *buf, int buf_size, const char *path, int number)
{
return av_get_frame_filename2(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 View Git Blame Copy Permalink