Loading...
Searching...
No Matches
Mathematics
libavutil

Mathematical utilities for working with timestamp and time base. More...

## Modules

| Colorspace Utility
| AVRational
| Rational number calculation.

## Enumerations

enum | AVRounding { AV_ROUND_ZERO = 0 , AV_ROUND_INF = 1 , AV_ROUND_DOWN = 2 , AV_ROUND_UP = 3 , AV_ROUND_NEAR_INF = 5 , AV_ROUND_PASS_MINMAX = 8192 }
| Rounding methods. More...

## Functions

int64_t av_const | av_gcd (int64_t a, int64_t b)
| Compute the greatest common divisor of two integer operands.
int64_t | av_rescale (int64_t a, int64_t b, int64_t c) av_const
| Rescale a 64-bit integer with rounding to nearest.
int64_t | av_rescale_rnd (int64_t a, int64_t b, int64_t c, enum AVRounding rnd) av_const
| Rescale a 64-bit integer with specified rounding.
int64_t | av_rescale_q (int64_t a, AVRational bq, AVRational cq) av_const
| Rescale a 64-bit integer by 2 rational numbers.
int64_t | av_rescale_q_rnd (int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd) av_const
| Rescale a 64-bit integer by 2 rational numbers with specified rounding.
int | av_compare_ts (int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
| Compare two timestamps each in its own time base.
int64_t | av_compare_mod (uint64_t a, uint64_t b, uint64_t mod)
| Compare the remainders of two integer operands divided by a common divisor.
int64_t | av_rescale_delta (AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb)
| Rescale a timestamp while preserving known durations.
int64_t | av_add_stable (AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc)
| Add a value to a timestamp.
double | av_bessel_i0 (double x)
| 0th order modified bessel function of the first kind.

## Detailed Description

Mathematical utilities for working with timestamp and time base.

## Enumeration Type Documentation

## AVRounding

enum AVRounding

Rounding methods.

Enumerator
AV_ROUND_ZERO | Round toward zero.
AV_ROUND_INF | Round away from zero.
AV_ROUND_DOWN | Round toward -infinity.
AV_ROUND_UP | Round toward +infinity.
AV_ROUND_NEAR_INF | Round to nearest and halfway cases away from zero.

AV_ROUND_PASS_MINMAX

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.

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
av_rescale_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 with specified rounding.
AV_ROUND_PASS_MINMAX
@ AV_ROUND_PASS_MINMAX
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
Definition mathematics.h:159
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition mathematics.h:134
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition avutil.h:248

Definition at line 130 of file mathematics.h.

## Function Documentation

## av_gcd()

int64_t av_const av_gcd | ( | int64_t | a,
|  | int64_t | b
| ) |  |

Compute the greatest common divisor of two integer operands.

Parameters

  a | Operand
  b | Operand

Returns
  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.

## av_rescale()

int64_t av_rescale | ( | int64_t | a,
|  | int64_t | b,
|  | int64_t | c
| ) |  | const

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 also
  av_rescale_rnd(), av_rescale_q(), av_rescale_q_rnd()

## av_rescale_rnd()

int64_t av_rescale_rnd | ( | int64_t | a,
|  | int64_t | b,
|  | int64_t | c,
|  | enum AVRounding | rnd
| ) |  | 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. If the result is not representable then INT64_MIN is returned.

See also
  av_rescale(), av_rescale_q(), av_rescale_q_rnd()

Examples
  resample_audio.c.

Referenced by main().

## av_rescale_q()

int64_t av_rescale_q | ( | int64_t | a,
|  | AVRational | bq,
|  | AVRational | cq
| ) |  | 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 also
  av_rescale(), av_rescale_rnd(), av_rescale_q_rnd()

Examples
  decode_filter_video.c, mux.c, qsv_transcode.c, and transcode.c.

Referenced by dec_enc(), display_frame(), encode_write_frame(), and write_audio_frame().

## av_rescale_q_rnd()

int64_t av_rescale_q_rnd | ( | int64_t | a,
|  | AVRational | bq,
|  | AVRational | cq,
|  | enum AVRounding | rnd
| ) |  | const

Rescale a 64-bit integer by 2 rational numbers with specified rounding.

The operation is mathematically equivalent to `a * bq / cq`.

See also
  av_rescale(), av_rescale_rnd(), av_rescale_q()

## av_compare_ts()

int av_compare_ts | ( | int64_t | ts_a,
|  | AVRational | tb_a,
|  | int64_t | ts_b,
|  | AVRational | tb_b
| ) |  |

Compare two timestamps each in its own time base.

Returns
  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.

Examples
  mux.c.

Referenced by get_audio_frame(), get_video_frame(), and main().

## av_compare_mod()

int64_t av_compare_mod | ( | uint64_t | a,
|  | uint64_t | b,
|  | uint64_t | mod
| ) |  |

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`.

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)
av_compare_mod
int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod)
Compare the remainders of two integer operands divided by a common divisor.

Parameters

  a | Operand
  b | Operand
  mod | Divisor; must be a power of 2

Returns
  - a negative value if `a % mod < b % mod`
  - a positive value if `a % mod > b % mod`
  - zero if `a % mod == b % mod`

## av_rescale_delta()

int64_t av_rescale_delta | ( | AVRational | in_tb,
|  | int64_t | in_ts,
|  | AVRational | fs_tb,
|  | int | duration,
|  | int64_t * | last,
|  | AVRational | out_tb
| ) |  |

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.

Parameters

  [in] | in_tb | Input time base
  [in] | in_ts | Input timestamp
  [in] | fs_tb | Duration time base; typically this is finer-grained (greater) than `in_tb` and `out_tb`
  [in] | duration | Duration till the next call to this function (i.e. duration of the current packet/frame)
  [in,out] | last | Pointer to a timestamp expressed in terms of `fs_tb`, acting as a state variable
  [in] | out_tb | Output timebase

Returns
  Timestamp expressed in terms of `out_tb`

Note
  In the context of this function, "duration" is in term of samples, not seconds.

## av_add_stable()

int64_t av_add_stable | ( | AVRational | ts_tb,
|  | int64_t | ts,
|  | AVRational | inc_tb,
|  | int64_t | inc
| ) |  |

Add a value to a timestamp.

This function guarantees that when the same value is repeatly added that no accumulation of rounding errors occurs.

Parameters

  [in] | ts | Input timestamp
  [in] | ts_tb | Input timestamp time base
  [in] | inc | Value to be added
  [in] | inc_tb | Time base of `inc`

## av_bessel_i0()

double av_bessel_i0 | ( | double | x | ) |

0th order modified bessel function of the first kind.