Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
4349 Serge 1
/*
2
 * This file is part of FFmpeg.
3
 *
4
 * FFmpeg is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2.1 of the License, or (at your option) any later version.
8
 *
9
 * FFmpeg is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with FFmpeg; if not, write to the Free Software
16
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
 */
18
 
19
/**
20
 * @file
21
 * Replacements for frequently missing libm functions
22
 */
23
 
24
#ifndef AVUTIL_LIBM_H
25
#define AVUTIL_LIBM_H
26
 
27
#include 
28
#include "config.h"
29
#include "attributes.h"
30
#include "intfloat.h"
31
 
32
#if HAVE_MIPSFPU && HAVE_INLINE_ASM
33
#include "libavutil/mips/libm_mips.h"
34
#endif /* HAVE_MIPSFPU && HAVE_INLINE_ASM*/
35
 
36
#if !HAVE_ATANF
37
#undef atanf
38
#define atanf(x) ((float)atan(x))
39
#endif
40
 
41
#if !HAVE_ATAN2F
42
#undef atan2f
43
#define atan2f(y, x) ((float)atan2(y, x))
44
#endif
45
 
46
#if !HAVE_POWF
47
#undef powf
48
#define powf(x, y) ((float)pow(x, y))
49
#endif
50
 
51
#if !HAVE_CBRT
52
static av_always_inline double cbrt(double x)
53
{
54
    return x < 0 ? -pow(-x, 1.0 / 3.0) : pow(x, 1.0 / 3.0);
55
}
56
#endif
57
 
58
#if !HAVE_CBRTF
59
static av_always_inline float cbrtf(float x)
60
{
61
    return x < 0 ? -powf(-x, 1.0 / 3.0) : powf(x, 1.0 / 3.0);
62
}
63
#endif
64
 
65
#if !HAVE_COSF
66
#undef cosf
67
#define cosf(x) ((float)cos(x))
68
#endif
69
 
70
#if !HAVE_EXPF
71
#undef expf
72
#define expf(x) ((float)exp(x))
73
#endif
74
 
75
#if !HAVE_EXP2
76
#undef exp2
77
#define exp2(x) exp((x) * 0.693147180559945)
78
#endif /* HAVE_EXP2 */
79
 
80
#if !HAVE_EXP2F
81
#undef exp2f
82
#define exp2f(x) ((float)exp2(x))
83
#endif /* HAVE_EXP2F */
84
 
85
#if !HAVE_ISINF
86
static av_always_inline av_const int isinf(float x)
87
{
88
    uint32_t v = av_float2int(x);
89
    if ((v & 0x7f800000) != 0x7f800000)
90
        return 0;
91
    return !(v & 0x007fffff);
92
}
93
#endif /* HAVE_ISINF */
94
 
95
#if !HAVE_ISNAN
96
static av_always_inline av_const int isnan(float x)
97
{
98
    uint32_t v = av_float2int(x);
99
    if ((v & 0x7f800000) != 0x7f800000)
100
        return 0;
101
    return v & 0x007fffff;
102
}
103
#endif /* HAVE_ISNAN */
104
 
105
#if !HAVE_LDEXPF
106
#undef ldexpf
107
#define ldexpf(x, exp) ((float)ldexp(x, exp))
108
#endif
109
 
110
#if !HAVE_LLRINT
111
#undef llrint
112
#define llrint(x) ((long long)rint(x))
113
#endif /* HAVE_LLRINT */
114
 
115
#if !HAVE_LLRINTF
116
#undef llrintf
117
#define llrintf(x) ((long long)rint(x))
118
#endif /* HAVE_LLRINT */
119
 
120
#if !HAVE_LOG2
121
#undef log2
122
#define log2(x) (log(x) * 1.44269504088896340736)
123
#endif /* HAVE_LOG2 */
124
 
125
#if !HAVE_LOG2F
126
#undef log2f
127
#define log2f(x) ((float)log2(x))
128
#endif /* HAVE_LOG2F */
129
 
130
#if !HAVE_LOG10F
131
#undef log10f
132
#define log10f(x) ((float)log10(x))
133
#endif
134
 
135
#if !HAVE_SINF
136
#undef sinf
137
#define sinf(x) ((float)sin(x))
138
#endif
139
 
140
#if !HAVE_RINT
141
static inline double rint(double x)
142
{
143
    return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5);
144
}
145
#endif /* HAVE_RINT */
146
 
147
#if !HAVE_LRINT
148
static av_always_inline av_const long int lrint(double x)
149
{
150
    return rint(x);
151
}
152
#endif /* HAVE_LRINT */
153
 
154
#if !HAVE_LRINTF
155
static av_always_inline av_const long int lrintf(float x)
156
{
157
    return (int)(rint(x));
158
}
159
#endif /* HAVE_LRINTF */
160
 
161
#if !HAVE_ROUND
162
static av_always_inline av_const double round(double x)
163
{
164
    return (x > 0) ? floor(x + 0.5) : ceil(x - 0.5);
165
}
166
#endif /* HAVE_ROUND */
167
 
168
#if !HAVE_ROUNDF
169
static av_always_inline av_const float roundf(float x)
170
{
171
    return (x > 0) ? floor(x + 0.5) : ceil(x - 0.5);
172
}
173
#endif /* HAVE_ROUNDF */
174
 
175
#if !HAVE_TRUNC
176
static av_always_inline av_const double trunc(double x)
177
{
178
    return (x > 0) ? floor(x) : ceil(x);
179
}
180
#endif /* HAVE_TRUNC */
181
 
182
#if !HAVE_TRUNCF
183
static av_always_inline av_const float truncf(float x)
184
{
185
    return (x > 0) ? floor(x) : ceil(x);
186
}
187
#endif /* HAVE_TRUNCF */
188
 
189
#endif /* AVUTIL_LIBM_H */