/*

 * 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 <time.h>

#include "config.h"

#include "libavutil/avassert.h"

#include "libavutil/avstring.h"

#include "libavutil/bprint.h"

#include "libavutil/dict.h"

#include "libavutil/internal.h"

#include "libavutil/mem.h"

#include "libavutil/opt.h"

#include "libavutil/parseutils.h"

#include "libavutil/time.h"

#include "libavutil/time_internal.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"

#include "urldecode.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)

{

    AVBPrint bp;

    if (!filename)

        return 0;

    av_bprint_init(&bp, 0, AV_BPRINT_SIZE_COUNT_ONLY);

    return (ff_bprint_get_frame_filename(&bp, filename, 1, AV_FRAME_FILENAME_FLAGS_IGNORE_TRUNCATION) >= 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 microseconds

    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_bprint_get_frame_filename(struct AVBPrint *buf, const char *path, int64_t number, int flags)

{

    const char *p;

    char c;

    int nd, percentd_found;

    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;

                av_bprintf(buf, "%0*" PRId64, nd, number);

                break;

            default:

                goto fail;

            }

        } else {

addchar:

            av_bprint_chars(buf, c, 1);

        }

    }

    if (!percentd_found)

        goto fail;

    if (!(flags & AV_FRAME_FILENAME_FLAGS_IGNORE_TRUNCATION) && !av_bprint_is_complete(buf))

        return AVERROR(ENOMEM);

    return 0;

fail:

    return AVERROR(EINVAL);

}

static int get_frame_filename(char *buf, int buf_size, const char *path, int64_t number, int flags)

{

    AVBPrint bp;

    av_bprint_init_for_buffer(&bp, buf, buf_size);

    return ff_bprint_get_frame_filename(&bp, path, number, flags) < 0 ? -1 : 0;

}

int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)

{

    return 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 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);

            if (ret < 0 && errno != EEXIST) {

                int err = errno;

                av_free(temp);

                errno = err;

                return ret;

            }

            *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;

}

int ff_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)

{

    int microsecs = timestamp % 1000000;

    time_t seconds = timestamp / 1000000 - (microsecs < 0);

    struct tm *ptm, tmbuf;

    ptm = gmtime_r(&seconds, &tmbuf);

    if (ptm) {

        char buf[32];

        if (!strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S", ptm))

            return AVERROR_EXTERNAL;

        av_strlcatf(buf, sizeof(buf), ".%06dZ", microsecs + (microsecs < 0) * 1000000);

        return av_dict_set(dict, key, buf, 0);

    } else {

        return AVERROR_EXTERNAL;

    }

}

static const AVOption* find_opt(void *obj, const char *name, size_t len)

{

    char decoded_name[128];

    if (ff_urldecode_len(decoded_name, sizeof(decoded_name), name, len, 1) < 0)

        return NULL;

    return av_opt_find(obj, decoded_name, NULL, 0, 0);

}

int ff_parse_opts_from_query_string(void *obj, const char *str, int allow_unknown)

{

    const AVOption *opt;

    char optval[512];

    int ret;

    if (*str == '?')

        str++;

    while (*str) {

        size_t len = strcspn(str, "=&");

        opt = find_opt(obj, str, len);

        if (!opt) {

            if (!allow_unknown) {

                av_log(obj, AV_LOG_ERROR, "Query string option '%.*s' does not exist\n", (int)len, str);

                return AVERROR_OPTION_NOT_FOUND;

            }

            av_log(obj, AV_LOG_VERBOSE, "Ignoring unknown query string option '%.*s'\n", (int)len, str);

        }

        str += len;

        if (!opt) {

            len = strcspn(str, "&");

            str += len;

        } else if (*str == '&' || *str == '\0') {

            /* Check for bool options without value, e.g. "?verify".

             * Unfortunately "listen" is a tri-state INT for some protocols so

             * we also have to allow that for backward compatibility. */

            if (opt->type != AV_OPT_TYPE_BOOL && strcmp(opt->name, "listen")) {

                av_log(obj, AV_LOG_ERROR, "Non-bool query string option '%s' has no value\n", opt->name);

                return AVERROR(EINVAL);

            }

            ret = av_opt_set_int(obj, opt->name, 1, 0);

            if (ret < 0)

                return ret;

        } else {

            av_assert2(*str == '=');

            str++;

            len = strcspn(str, "&");

            if (ff_urldecode_len(optval, sizeof(optval), str, len, 1) < 0) {

                av_log(obj, AV_LOG_ERROR, "Query string option '%s' value is too long\n", opt->name);

                return AVERROR(EINVAL);

            }

            ret = av_opt_set(obj, opt->name, optval, 0);

            if (ret < 0)

                return ret;

            str += len;

        }

        if (*str)

            str++;

    }

    return 0;

}

void *ff_bprint_finalize_as_fam(struct AVBPrint *bp, const void *struct_ptr, size_t fam_offset)

{

    if (!av_bprint_is_complete(bp)) {

        av_bprint_finalize(bp, NULL);

        return NULL;

    }

    uint8_t *p = av_malloc(fam_offset + bp->len);

    if (!p) {

        av_bprint_finalize(bp, NULL);

        return NULL;

    }

    memcpy(p, struct_ptr, fam_offset);

    memcpy(p + fam_offset, bp->str, bp->len);

    av_bprint_finalize(bp, NULL);

    return p;

}