## ffmpeg / libavutil / mathematics.h @ 65db0587

History | View | Annotate | Download (3.41 KB)

1 | 04d7f601 | Diego Biurrun | ```
/*
``` |
---|---|---|---|

2 | ```
* copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
``` |
||

3 | ```
*
``` |
||

4 | b78e7197 | Diego Biurrun | ```
* This file is part of FFmpeg.
``` |

5 | ```
*
``` |
||

6 | ```
* FFmpeg is free software; you can redistribute it and/or
``` |
||

7 | 04d7f601 | Diego Biurrun | ```
* modify it under the terms of the GNU Lesser General Public
``` |

8 | ```
* License as published by the Free Software Foundation; either
``` |
||

9 | b78e7197 | Diego Biurrun | ```
* version 2.1 of the License, or (at your option) any later version.
``` |

10 | 04d7f601 | Diego Biurrun | ```
*
``` |

11 | b78e7197 | Diego Biurrun | ```
* FFmpeg is distributed in the hope that it will be useful,
``` |

12 | 04d7f601 | Diego Biurrun | ```
* but WITHOUT ANY WARRANTY; without even the implied warranty of
``` |

13 | ```
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
``` |
||

14 | ```
* Lesser General Public License for more details.
``` |
||

15 | ```
*
``` |
||

16 | ```
* You should have received a copy of the GNU Lesser General Public
``` |
||

17 | b78e7197 | Diego Biurrun | ```
* License along with FFmpeg; if not, write to the Free Software
``` |

18 | 04d7f601 | Diego Biurrun | ```
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
``` |

19 | ```
*/
``` |
||

20 | |||

21 | 98790382 | Stefano Sabatini | ```
#ifndef AVUTIL_MATHEMATICS_H
``` |

22 | ```
#define AVUTIL_MATHEMATICS_H
``` |
||

23 | c11c2bc2 | Alexander Strasser | |

24 | 6ef29128 | Diego Biurrun | #include <stdint.h> |

25 | d1a12956 | Aurelien Jacobs | #include <math.h> |

26 | 2ed6f399 | Måns Rullgård | #include "attributes.h" |

27 | c11c2bc2 | Alexander Strasser | #include "rational.h" |

28 | |||

29 | d1a12956 | Aurelien Jacobs | ```
#ifndef M_E
``` |

30 | #define M_E 2.7182818284590452354 /* e */ |
||

31 | ```
#endif
``` |
||

32 | ```
#ifndef M_LN2
``` |
||

33 | #define M_LN2 0.69314718055994530942 /* log_e 2 */ |
||

34 | ```
#endif
``` |
||

35 | ```
#ifndef M_LN10
``` |
||

36 | #define M_LN10 2.30258509299404568402 /* log_e 10 */ |
||

37 | ```
#endif
``` |
||

38 | e4a35244 | Måns Rullgård | ```
#ifndef M_LOG2_10
``` |

39 | 94a5218c | Måns Rullgård | #define M_LOG2_10 3.32192809488736234787 /* log_2 10 */ |

40 | e4a35244 | Måns Rullgård | ```
#endif
``` |

41 | 5af4f1f3 | Aurelien Jacobs | ```
#ifndef M_PI
``` |

42 | #define M_PI 3.14159265358979323846 /* pi */ |
||

43 | ```
#endif
``` |
||

44 | d1a12956 | Aurelien Jacobs | ```
#ifndef M_SQRT1_2
``` |

45 | #define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ |
||

46 | ```
#endif
``` |
||

47 | b9f60bd8 | Alex Converse | ```
#ifndef M_SQRT2
``` |

48 | #define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ |
||

49 | ```
#endif
``` |
||

50 | bd41c06f | Måns Rullgård | ```
#ifndef NAN
``` |

51 | #define NAN (0.0/0.0) |
||

52 | ```
#endif
``` |
||

53 | ```
#ifndef INFINITY
``` |
||

54 | #define INFINITY (1.0/0.0) |
||

55 | ```
#endif
``` |
||

56 | d1a12956 | Aurelien Jacobs | |

57 | c11c2bc2 | Alexander Strasser | ```
enum AVRounding {
``` |

58 | 89c9ff50 | Diego Biurrun | AV_ROUND_ZERO = 0, ///< Round toward zero. |

59 | AV_ROUND_INF = 1, ///< Round away from zero. |
||

60 | AV_ROUND_DOWN = 2, ///< Round toward -infinity. |
||

61 | AV_ROUND_UP = 3, ///< Round toward +infinity. |
||

62 | AV_ROUND_NEAR_INF = 5, ///< Round to nearest and halfway cases away from zero. |
||

63 | c11c2bc2 | Alexander Strasser | }; |

64 | |||

65 | 03703cb3 | Michael Niedermayer | ```
/**
``` |

66 | ```
* Returns the greatest common divisor of a and b.
``` |
||

67 | bac24dd2 | Michael Niedermayer | ```
* If both a and b are 0 or either or both are <0 then behavior is
``` |

68 | 03703cb3 | Michael Niedermayer | ```
* undefined.
``` |

69 | ```
*/
``` |
||

70 | 9ce6c138 | Aurelien Jacobs | int64_t av_const av_gcd(int64_t a, int64_t b); |

71 | |||

72 | c11c2bc2 | Alexander Strasser | ```
/**
``` |

73 | 89c9ff50 | Diego Biurrun | ```
* Rescales a 64-bit integer with rounding to nearest.
``` |

74 | ```
* A simple a*b/c isn't possible as it can overflow.
``` |
||

75 | c11c2bc2 | Alexander Strasser | ```
*/
``` |

76 | 85074d3c | Zuxy Meng | int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const; |

77 | c11c2bc2 | Alexander Strasser | |

78 | ```
/**
``` |
||

79 | 89c9ff50 | Diego Biurrun | ```
* Rescales a 64-bit integer with specified rounding.
``` |

80 | ```
* A simple a*b/c isn't possible as it can overflow.
``` |
||

81 | c11c2bc2 | Alexander Strasser | ```
*/
``` |

82 | 85074d3c | Zuxy Meng | ```
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding) av_const;
``` |

83 | c11c2bc2 | Alexander Strasser | |

84 | ```
/**
``` |
||

85 | 89c9ff50 | Diego Biurrun | ```
* Rescales a 64-bit integer by 2 rational numbers.
``` |

86 | c11c2bc2 | Alexander Strasser | ```
*/
``` |

87 | 85074d3c | Zuxy Meng | int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const; |

88 | c11c2bc2 | Alexander Strasser | |

89 | 78b01823 | Michael Niedermayer | ```
/**
``` |

90 | ```
* Compares 2 timestamps each in its own timebases.
``` |
||

91 | ```
* The result of the function is undefined if one of the timestamps
``` |
||

92 | ```
* is outside the int64_t range when represented in the others timebase.
``` |
||

93 | 32e543f8 | Benoit Fouet | ```
* @return -1 if ts_a is before ts_b, 1 if ts_a is after ts_b or 0 if they represent the same position
``` |

94 | 78b01823 | Michael Niedermayer | ```
*/
``` |

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

96 | |||

97 | 65db0587 | Michael Niedermayer | ```
/**
``` |

98 | ```
* Compare 2 integers modulo mod.
``` |
||

99 | ```
* That is we compare integers a and b for which only the least significant log2(mod) bits are known
``` |
||

100 | ```
* @param mod must be a power of 2
``` |
||

101 | ```
* @returns a negative value if a is smaller than b
``` |
||

102 | ```
* a positiv value if a is greater than b
``` |
||

103 | ```
* 0 if a equals b
``` |
||

104 | ```
*/
``` |
||

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

106 | 78b01823 | Michael Niedermayer | |

107 | 98790382 | Stefano Sabatini | #endif /* AVUTIL_MATHEMATICS_H */ |