FFmpeg中有关时间戳的函数

以你之姓@ 2022-07-15 01:44 137阅读 0赞

/**
     * @file
     * @addtogroup lavu_math
     * Mathematical utilities for working with timestamp and time base.
     */
    
    
    #ifndef AVUTIL_MATHEMATICS_H
    #define AVUTIL_MATHEMATICS_H
    
    
    #include <stdint.h>
    #include <math.h>
    #include "attributes.h"
    #include "rational.h"
    #include "intfloat.h"
    
    
    #ifndef M_E
    #define M_E            2.7182818284590452354   /* e */
    #endif
    #ifndef M_LN2
    #define M_LN2          0.69314718055994530942  /* log_e 2 */
    #endif
    #ifndef M_LN10
    #define M_LN10         2.30258509299404568402  /* log_e 10 */
    #endif
    #ifndef M_LOG2_10
    #define M_LOG2_10      3.32192809488736234787  /* log_2 10 */
    #endif
    #ifndef M_PHI
    #define M_PHI          1.61803398874989484820   /* phi / golden ratio */
    #endif
    #ifndef M_PI
    #define M_PI           3.14159265358979323846  /* pi */
    #endif
    #ifndef M_PI_2
    #define M_PI_2         1.57079632679489661923  /* pi/2 */
    #endif
    #ifndef M_SQRT1_2
    #define M_SQRT1_2      0.70710678118654752440  /* 1/sqrt(2) */
    #endif
    #ifndef M_SQRT2
    #define M_SQRT2        1.41421356237309504880  /* sqrt(2) */
    #endif
    #ifndef NAN
    #define NAN            av_int2float(0x7fc00000)
    #endif
    #ifndef INFINITY
    #define INFINITY       av_int2float(0x7f800000)
    #endif
    
    
    /**
     * @addtogroup lavu_math
     *
     * @{
     */
    
    
    /**
     * Rounding methods.
     */
    enum AVRounding {
        AV_ROUND_ZERO     = 0, ///< Round toward zero.
        AV_ROUND_INF      = 1, ///< Round away from zero.
        AV_ROUND_DOWN     = 2, ///< Round toward -infinity.
        AV_ROUND_UP       = 3, ///< Round toward +infinity.
        AV_ROUND_NEAR_INF = 5, ///< Round to nearest and halfway cases away from zero.
        /**
         * Flag telling rescaling functions to pass `INT64_MIN`/`MAX` through
         * unchanged, avoiding special cases for #AV_NOPTS_VALUE.
         *
         * Unlike other values of the enumeration AVRounding, this value is a
         * bitmask that must be used in conjunction with another value of the
         * enumeration through a bitwise OR, in order to set behavior for normal
         * cases.
         *
         * @code{.c}
         * av_rescale_rnd(3, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
         * // Rescaling 3:
         * //     Calculating 3 * 1 / 2
         * //     3 / 2 is rounded up to 2
         * //     => 2
         *
         * av_rescale_rnd(AV_NOPTS_VALUE, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
         * // Rescaling AV_NOPTS_VALUE:
         * //     AV_NOPTS_VALUE == INT64_MIN
         * //     AV_NOPTS_VALUE is passed through
         * //     => AV_NOPTS_VALUE
         * @endcode
         */
        AV_ROUND_PASS_MINMAX = 8192,
    };
    
    
    /**
     * Compute the greatest common divisor of two integer operands.
     *
     * @param a,b Operands
     * @return GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0;
     * if a == 0 and b == 0, returns 0.
     */
    int64_t av_const av_gcd(int64_t a, int64_t b);
    
    
    /**
     * Rescale a 64-bit integer with rounding to nearest.
     *
     * The operation is mathematically equivalent to `a * b / c`, but writing that
     * directly can overflow.
     *
     * This function is equivalent to av_rescale_rnd() with #AV_ROUND_NEAR_INF.
     *
     * @see av_rescale_rnd(), av_rescale_q(), av_rescale_q_rnd()
     */
    int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const;
    
    
    /**
     * Rescale a 64-bit integer with specified rounding.
     *
     * The operation is mathematically equivalent to `a * b / c`, but writing that
     * directly can overflow, and does not support different rounding methods.
     *
     * @see av_rescale(), av_rescale_q(), av_rescale_q_rnd()
     */
    int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd) av_const;
    
    
    /**
     * Rescale a 64-bit integer by 2 rational numbers.
     *
     * The operation is mathematically equivalent to `a * bq / cq`.
     *
     * This function is equivalent to av_rescale_q_rnd() with #AV_ROUND_NEAR_INF.
     *
     * @see av_rescale(), av_rescale_rnd(), av_rescale_q_rnd()
     */
    int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
    
    
    /**
     * Rescale a 64-bit integer by 2 rational numbers with specified rounding.
     *
     * The operation is mathematically equivalent to `a * bq / cq`.
     *
     * @see av_rescale(), av_rescale_rnd(), av_rescale_q()
     */
    int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
                             enum AVRounding rnd) av_const;
    
    
    /**
     * Compare two timestamps each in its own time base.
     *
     * @return One of the following values:
     *         - -1 if `ts_a` is before `ts_b`
     *         - 1 if `ts_a` is after `ts_b`
     *         - 0 if they represent the same position
     *
     * @warning
     * The result of the function is undefined if one of the timestamps is outside
     * the `int64_t` range when represented in the other's timebase.
     */
    int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
    
    
    /**
     * Compare the remainders of two integer operands divided by a common divisor.
     *
     * In other words, compare the least significant `log2(mod)` bits of integers
     * `a` and `b`.
     *
     * @code{.c}
     * av_compare_mod(0x11, 0x02, 0x10) < 0 // since 0x11 % 0x10  (0x1) < 0x02 % 0x10  (0x2)
     * av_compare_mod(0x11, 0x02, 0x20) > 0 // since 0x11 % 0x20 (0x11) > 0x02 % 0x20 (0x02)
     * @endcode
     *
     * @param a,b Operands
     * @param mod Divisor; must be a power of 2
     * @return
     *         - a negative value if `a % mod < b % mod`
     *         - a positive value if `a % mod > b % mod`
     *         - zero             if `a % mod == b % mod`
     */
    int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod);
    
    
    /**
     * Rescale a timestamp while preserving known durations.
     *
     * This function is designed to be called per audio packet to scale the input
     * timestamp to a different time base. Compared to a simple av_rescale_q()
     * call, this function is robust against possible inconsistent frame durations.
     *
     * The `last` parameter is a state variable that must be preserved for all
     * subsequent calls for the same stream. For the first call, `*last` should be
     * initialized to #AV_NOPTS_VALUE.
     *
     * @param[in]     in_tb    Input time base
     * @param[in]     in_ts    Input timestamp
     * @param[in]     fs_tb    Duration time base; typically this is finer-grained
     *                         (greater) than `in_tb` and `out_tb`
     * @param[in]     duration Duration till the next call to this function (i.e.
     *                         duration of the current packet/frame)
     * @param[in,out] last     Pointer to a timestamp expressed in terms of
     *                         `fs_tb`, acting as a state variable
     * @param[in]     out_tb   Output timebase
     * @return        Timestamp expressed in terms of `out_tb`
     *
     * @note In the context of this function, "duration" is in term of samples, not
     *       seconds.
     */
    int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts,  AVRational fs_tb, int duration, int64_t *last, AVRational out_tb);
    
    
    /**
     * Add a value to a timestamp.
     *
     * This function guarantees that when the same value is repeatly added that
     * no accumulation of rounding errors occurs.
     *
     * @param[in] ts     Input timestamp
     * @param[in] ts_tb  Input timestamp time base
     * @param[in] inc    Value to be added
     * @param[in] inc_tb Time base of `inc`
     */
    int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc);
    
    
    
    
    /**
     * @}
     */
    
    
    #endif /* AVUTIL_MATHEMATICS_H */
    
    
    
    
    
    
    
    /*
     * Copyright (c) 2005-2012 Michael Niedermayer <michaelni@gmx.at>
     *
     * 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
     */
    
    
    /**
     * @file
     * miscellaneous math routines and tables
     */
    
    
    #include <stdint.h>
    #include <limits.h>
    
    
    #include "mathematics.h"
    #include "libavutil/intmath.h"
    #include "libavutil/common.h"
    #include "avassert.h"
    #include "version.h"
    
    
    /* Stein's binary GCD algorithm:
     * https://en.wikipedia.org/wiki/Binary_GCD_algorithm */
    int64_t av_gcd(int64_t a, int64_t b) {
        int za, zb, k;
        int64_t u, v;
        if (a == 0)
            return b;
        if (b == 0)
            return a;
        za = ff_ctzll(a);
        zb = ff_ctzll(b);
        k  = FFMIN(za, zb);
        u = llabs(a >> za);
        v = llabs(b >> zb);
        while (u != v) {
            if (u > v)
                FFSWAP(int64_t, v, u);
            v -= u;
            v >>= ff_ctzll(v);
        }
        return (uint64_t)u << k;
    }
    
    
    int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
    {
        int64_t r = 0;
        av_assert2(c > 0);
        av_assert2(b >=0);
        av_assert2((unsigned)(rnd&~AV_ROUND_PASS_MINMAX)<=5 && (rnd&~AV_ROUND_PASS_MINMAX)!=4);
    
    
        if (c <= 0 || b < 0 || !((unsigned)(rnd&~AV_ROUND_PASS_MINMAX)<=5 && (rnd&~AV_ROUND_PASS_MINMAX)!=4))
            return INT64_MIN;
    
    
        if (rnd & AV_ROUND_PASS_MINMAX) {
            if (a == INT64_MIN || a == INT64_MAX)
                return a;
            rnd -= AV_ROUND_PASS_MINMAX;
        }
    
    
        if (a < 0)
            return -(uint64_t)av_rescale_rnd(-FFMAX(a, -INT64_MAX), b, c, rnd ^ ((rnd >> 1) & 1));
    
    
        if (rnd == AV_ROUND_NEAR_INF)
            r = c / 2;
        else if (rnd & 1)
            r = c - 1;
    
    
        if (b <= INT_MAX && c <= INT_MAX) {
            if (a <= INT_MAX)
                return (a * b + r) / c;
            else {
                int64_t ad = a / c;
                int64_t a2 = (a % c * b + r) / c;
                if (ad >= INT32_MAX && b && ad > (INT64_MAX - a2) / b)
                    return INT64_MIN;
                return ad * b + a2;
            }
        } else {
    #if 1
            uint64_t a0  = a & 0xFFFFFFFF;
            uint64_t a1  = a >> 32;
            uint64_t b0  = b & 0xFFFFFFFF;
            uint64_t b1  = b >> 32;
            uint64_t t1  = a0 * b1 + a1 * b0;
            uint64_t t1a = t1 << 32;
            int i;
    
    
            a0  = a0 * b0 + t1a;
            a1  = a1 * b1 + (t1 >> 32) + (a0 < t1a);
            a0 += r;
            a1 += a0 < r;
    
    
            for (i = 63; i >= 0; i--) {
                a1 += a1 + ((a0 >> i) & 1);
                t1 += t1;
                if (c <= a1) {
                    a1 -= c;
                    t1++;
                }
            }
            if (t1 > INT64_MAX)
                return INT64_MIN;
            return t1;
        }
    #else
            AVInteger ai;
            ai = av_mul_i(av_int2i(a), av_int2i(b));
            ai = av_add_i(ai, av_int2i(r));
    
    
            return av_i2int(av_div_i(ai, av_int2i(c)));
        }
    #endif
    }
    
    
    int64_t av_rescale(int64_t a, int64_t b, int64_t c)
    {
        return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
    }
    
    
    int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
                             enum AVRounding rnd)
    {
        int64_t b = bq.num * (int64_t)cq.den;
        int64_t c = cq.num * (int64_t)bq.den;
        return av_rescale_rnd(a, b, c, rnd);
    }
    
    
    int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
    {
        return av_rescale_q_rnd(a, bq, cq, AV_ROUND_NEAR_INF);
    }
    
    
    int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
    {
        int64_t a = tb_a.num * (int64_t)tb_b.den;
        int64_t b = tb_b.num * (int64_t)tb_a.den;
        if ((FFABS(ts_a)|a|FFABS(ts_b)|b) <= INT_MAX)
            return (ts_a*a > ts_b*b) - (ts_a*a < ts_b*b);
        if (av_rescale_rnd(ts_a, a, b, AV_ROUND_DOWN) < ts_b)
            return -1;
        if (av_rescale_rnd(ts_b, b, a, AV_ROUND_DOWN) < ts_a)
            return 1;
        return 0;
    }
    
    
    int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod)
    {
        int64_t c = (a - b) & (mod - 1);
        if (c > (mod >> 1))
            c -= mod;
        return c;
    }
    
    
    int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts,  AVRational fs_tb, int duration, int64_t *last, AVRational out_tb){
        int64_t a, b, this;
    
    
        av_assert0(in_ts != AV_NOPTS_VALUE);
        av_assert0(duration >= 0);
    
    
        if (*last == AV_NOPTS_VALUE || !duration || in_tb.num*(int64_t)out_tb.den <= out_tb.num*(int64_t)in_tb.den) {
    simple_round:
            *last = av_rescale_q(in_ts, in_tb, fs_tb) + duration;
            return av_rescale_q(in_ts, in_tb, out_tb);
        }
    
    
        a =  av_rescale_q_rnd(2*in_ts-1, in_tb, fs_tb, AV_ROUND_DOWN)   >>1;
        b = (av_rescale_q_rnd(2*in_ts+1, in_tb, fs_tb, AV_ROUND_UP  )+1)>>1;
        if (*last < 2*a - b || *last > 2*b - a)
            goto simple_round;
    
    
        this = av_clip64(*last, a, b);
        *last = this + duration;
    
    
        return av_rescale_q(this, fs_tb, out_tb);
    }
    
    
    int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc)
    {
        int64_t m, d;
    
    
        if (inc != 1)
            inc_tb = av_mul_q(inc_tb, (AVRational) {inc, 1});
    
    
        m = inc_tb.num * (int64_t)ts_tb.den;
        d = inc_tb.den * (int64_t)ts_tb.num;
    
    
        if (m % d == 0)
            return ts + m / d;
        if (m < d)
            return ts;
    
    
        {
            int64_t old = av_rescale_q(ts, ts_tb, inc_tb);
            int64_t old_ts = av_rescale_q(old, inc_tb, ts_tb);
            return av_rescale_q(old + 1, inc_tb, ts_tb) + (ts - old_ts);
        }
    }