ffmpeg / libavutil / rational.h @ b2755007
History  View  Annotate  Download (3.4 KB)
1 
/*


2 
* rational numbers

3 
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>

4 
*

5 
* This file is part of FFmpeg.

6 
*

7 
* FFmpeg is free software; you can redistribute it and/or

8 
* modify it under the terms of the GNU Lesser General Public

9 
* License as published by the Free Software Foundation; either

10 
* version 2.1 of the License, or (at your option) any later version.

11 
*

12 
* FFmpeg is distributed in the hope that it will be useful,

13 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

14 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 
* Lesser General Public License for more details.

16 
*

17 
* You should have received a copy of the GNU Lesser General Public

18 
* License along with FFmpeg; if not, write to the Free Software

19 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

20 
*/

21  
22 
/**

23 
* @file libavutil/rational.h

24 
* rational numbers

25 
* @author Michael Niedermayer <michaelni@gmx.at>

26 
*/

27  
28 
#ifndef AVUTIL_RATIONAL_H

29 
#define AVUTIL_RATIONAL_H

30  
31 
#include <stdint.h> 
32 
#include "common.h" 
33  
34 
/**

35 
* rational number numerator/denominator

36 
*/

37 
typedef struct AVRational{ 
38 
int num; ///< numerator 
39 
int den; ///< denominator 
40 
} AVRational; 
41  
42 
/**

43 
* Compares two rationals.

44 
* @param a first rational

45 
* @param b second rational

46 
* @return 0 if a==b, 1 if a>b and 1 if a<b

47 
*/

48 
static inline int av_cmp_q(AVRational a, AVRational b){ 
49 
const int64_t tmp= a.num * (int64_t)b.den  b.num * (int64_t)a.den;

50  
51 
if(tmp) return (tmp>>63)1; 
52 
else return 0; 
53 
} 
54  
55 
/**

56 
* Converts rational to double.

57 
* @param a rational to convert

58 
* @return (double) a

59 
*/

60 
static inline double av_q2d(AVRational a){ 
61 
return a.num / (double) a.den; 
62 
} 
63  
64 
/**

65 
* Reduces a fraction.

66 
* This is useful for framerate calculations.

67 
* @param dst_num destination numerator

68 
* @param dst_den destination denominator

69 
* @param num source numerator

70 
* @param den source denominator

71 
* @param max the maximum allowed for dst_num & dst_den

72 
* @return 1 if exact, 0 otherwise

73 
*/

74 
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max); 
75  
76 
/**

77 
* Multiplies two rationals.

78 
* @param b first rational

79 
* @param c second rational

80 
* @return b*c

81 
*/

82 
AVRational av_mul_q(AVRational b, AVRational c) av_const; 
83  
84 
/**

85 
* Divides one rational by another.

86 
* @param b first rational

87 
* @param c second rational

88 
* @return b/c

89 
*/

90 
AVRational av_div_q(AVRational b, AVRational c) av_const; 
91  
92 
/**

93 
* Adds two rationals.

94 
* @param b first rational

95 
* @param c second rational

96 
* @return b+c

97 
*/

98 
AVRational av_add_q(AVRational b, AVRational c) av_const; 
99  
100 
/**

101 
* Subtracts one rational from another.

102 
* @param b first rational

103 
* @param c second rational

104 
* @return bc

105 
*/

106 
AVRational av_sub_q(AVRational b, AVRational c) av_const; 
107  
108 
/**

109 
* Converts a double precision floating point number to a rational.

110 
* @param d double to convert

111 
* @param max the maximum allowed numerator and denominator

112 
* @return (AVRational) d

113 
*/

114 
AVRational av_d2q(double d, int max) av_const; 
115  
116 
/**

117 
* @return 1 if \q1 is nearer to \p q than \p q2, 1 if \p q2 is nearer

118 
* than \p q1, 0 if they have the same distance.

119 
*/

120 
int av_nearer_q(AVRational q, AVRational q1, AVRational q2);

121  
122 
/**

123 
* Finds the nearest value in \p q_list to \p q.

124 
* @param q_list an array of rationals terminated by {0, 0}

125 
* @return the index of the nearest value found in the array

126 
*/

127 
int av_find_nearest_q_idx(AVRational q, const AVRational* q_list); 
128  
129 
#endif /* AVUTIL_RATIONAL_H */ 