lavu: Rename ycgco color space appropriately
[ffmpeg.git] / libavutil / common.h
1 /*
2  * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * 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  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * common internal and external API header
24  */
25
26 #ifndef AVUTIL_COMMON_H
27 #define AVUTIL_COMMON_H
28
29 #include <errno.h>
30 #include <inttypes.h>
31 #include <limits.h>
32 #include <math.h>
33 #include <stdint.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37
38 #include "attributes.h"
39 #include "macros.h"
40 #include "version.h"
41 #include "libavutil/avconfig.h"
42
43 #if AV_HAVE_BIGENDIAN
44 #   define AV_NE(be, le) (be)
45 #else
46 #   define AV_NE(be, le) (le)
47 #endif
48
49 //rounded division & shift
50 #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
51 /* assume b>0 */
52 #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
53
54 /**
55  * Fast a / (1 << b) rounded toward +inf, assuming a >= 0 and b >= 0.
56  */
57 #define AV_CEIL_RSHIFT(a, b) \
58     (av_builtin_constant_p(b) ? ((a) + (1 << (b)) - 1) >> (b) \
59                               : -((-(a)) >> (b)))
60
61 #define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
62 #define FFSIGN(a) ((a) > 0 ? 1 : -1)
63
64 #define FFMAX(a,b) ((a) > (b) ? (a) : (b))
65 #define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
66 #define FFMIN(a,b) ((a) > (b) ? (b) : (a))
67 #define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
68
69 #define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
70 #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
71
72 /* misc math functions */
73
74 #ifdef HAVE_AV_CONFIG_H
75 #   include "config.h"
76 #   include "intmath.h"
77 #endif
78
79 /* Pull in unguarded fallback defines at the end of this file. */
80 #include "common.h"
81
82 #ifndef av_log2
83 av_const int av_log2(unsigned v);
84 #endif
85
86 #ifndef av_log2_16bit
87 av_const int av_log2_16bit(unsigned v);
88 #endif
89
90 /**
91  * Clip a signed integer value into the amin-amax range.
92  * @param a value to clip
93  * @param amin minimum value of the clip range
94  * @param amax maximum value of the clip range
95  * @return clipped value
96  */
97 static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
98 {
99     if      (a < amin) return amin;
100     else if (a > amax) return amax;
101     else               return a;
102 }
103
104 /**
105  * Clip a signed integer value into the 0-255 range.
106  * @param a value to clip
107  * @return clipped value
108  */
109 static av_always_inline av_const uint8_t av_clip_uint8_c(int a)
110 {
111     if (a&(~0xFF)) return (-a)>>31;
112     else           return a;
113 }
114
115 /**
116  * Clip a signed integer value into the -128,127 range.
117  * @param a value to clip
118  * @return clipped value
119  */
120 static av_always_inline av_const int8_t av_clip_int8_c(int a)
121 {
122     if ((a+0x80) & ~0xFF) return (a>>31) ^ 0x7F;
123     else                  return a;
124 }
125
126 /**
127  * Clip a signed integer value into the 0-65535 range.
128  * @param a value to clip
129  * @return clipped value
130  */
131 static av_always_inline av_const uint16_t av_clip_uint16_c(int a)
132 {
133     if (a&(~0xFFFF)) return (-a)>>31;
134     else             return a;
135 }
136
137 /**
138  * Clip a signed integer value into the -32768,32767 range.
139  * @param a value to clip
140  * @return clipped value
141  */
142 static av_always_inline av_const int16_t av_clip_int16_c(int a)
143 {
144     if ((a+0x8000) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
145     else                      return a;
146 }
147
148 /**
149  * Clip a signed 64-bit integer value into the -2147483648,2147483647 range.
150  * @param a value to clip
151  * @return clipped value
152  */
153 static av_always_inline av_const int32_t av_clipl_int32_c(int64_t a)
154 {
155     if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (a>>63) ^ 0x7FFFFFFF;
156     else                                         return a;
157 }
158
159 /**
160  * Clip a signed integer into the -(2^p),(2^p-1) range.
161  * @param  a value to clip
162  * @param  p bit position to clip at
163  * @return clipped value
164  */
165 static av_always_inline av_const int av_clip_intp2_c(int a, int p)
166 {
167     if ((a + (1 << p)) & ~((1 << (p + 1)) - 1))
168         return (a >> 31) ^ ((1 << p) - 1);
169     else
170         return a;
171 }
172
173 /**
174  * Clip a signed integer to an unsigned power of two range.
175  * @param  a value to clip
176  * @param  p bit position to clip at
177  * @return clipped value
178  */
179 static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
180 {
181     if (a & ~((1<<p) - 1)) return -a >> 31 & ((1<<p) - 1);
182     else                   return  a;
183 }
184
185 /**
186  * Add two signed 32-bit values with saturation.
187  *
188  * @param  a one value
189  * @param  b another value
190  * @return sum with signed saturation
191  */
192 static av_always_inline int av_sat_add32_c(int a, int b)
193 {
194     return av_clipl_int32((int64_t)a + b);
195 }
196
197 /**
198  * Add a doubled value to another value with saturation at both stages.
199  *
200  * @param  a first value
201  * @param  b value doubled and added to a
202  * @return sum with signed saturation
203  */
204 static av_always_inline int av_sat_dadd32_c(int a, int b)
205 {
206     return av_sat_add32(a, av_sat_add32(b, b));
207 }
208
209 /**
210  * Clip a float value into the amin-amax range.
211  * @param a value to clip
212  * @param amin minimum value of the clip range
213  * @param amax maximum value of the clip range
214  * @return clipped value
215  */
216 static av_always_inline av_const float av_clipf_c(float a, float amin, float amax)
217 {
218     if      (a < amin) return amin;
219     else if (a > amax) return amax;
220     else               return a;
221 }
222
223 /** Compute ceil(log2(x)).
224  * @param x value used to compute ceil(log2(x))
225  * @return computed ceiling of log2(x)
226  */
227 static av_always_inline av_const int av_ceil_log2_c(int x)
228 {
229     return av_log2((x - 1) << 1);
230 }
231
232 /**
233  * Count number of bits set to one in x
234  * @param x value to count bits of
235  * @return the number of bits set to one in x
236  */
237 static av_always_inline av_const int av_popcount_c(uint32_t x)
238 {
239     x -= (x >> 1) & 0x55555555;
240     x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
241     x = (x + (x >> 4)) & 0x0F0F0F0F;
242     x += x >> 8;
243     return (x + (x >> 16)) & 0x3F;
244 }
245
246 /**
247  * Count number of bits set to one in x
248  * @param x value to count bits of
249  * @return the number of bits set to one in x
250  */
251 static av_always_inline av_const int av_popcount64_c(uint64_t x)
252 {
253     return av_popcount(x) + av_popcount(x >> 32);
254 }
255
256 #define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
257 #define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
258
259 /**
260  * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
261  *
262  * @param val      Output value, must be an lvalue of type uint32_t.
263  * @param GET_BYTE Expression reading one byte from the input.
264  *                 Evaluated up to 7 times (4 for the currently
265  *                 assigned Unicode range).  With a memory buffer
266  *                 input, this could be *ptr++.
267  * @param ERROR    Expression to be evaluated on invalid input,
268  *                 typically a goto statement.
269  */
270 #define GET_UTF8(val, GET_BYTE, ERROR)\
271     val= GET_BYTE;\
272     {\
273         uint32_t top = (val & 128) >> 1;\
274         if ((val & 0xc0) == 0x80)\
275             ERROR\
276         while (val & top) {\
277             int tmp= GET_BYTE - 128;\
278             if(tmp>>6)\
279                 ERROR\
280             val= (val<<6) + tmp;\
281             top <<= 5;\
282         }\
283         val &= (top << 1) - 1;\
284     }
285
286 /**
287  * Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form.
288  *
289  * @param val       Output value, must be an lvalue of type uint32_t.
290  * @param GET_16BIT Expression returning two bytes of UTF-16 data converted
291  *                  to native byte order.  Evaluated one or two times.
292  * @param ERROR     Expression to be evaluated on invalid input,
293  *                  typically a goto statement.
294  */
295 #define GET_UTF16(val, GET_16BIT, ERROR)\
296     val = GET_16BIT;\
297     {\
298         unsigned int hi = val - 0xD800;\
299         if (hi < 0x800) {\
300             val = GET_16BIT - 0xDC00;\
301             if (val > 0x3FFU || hi > 0x3FFU)\
302                 ERROR\
303             val += (hi<<10) + 0x10000;\
304         }\
305     }\
306
307 /**
308  * @def PUT_UTF8(val, tmp, PUT_BYTE)
309  * Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
310  * @param val is an input-only argument and should be of type uint32_t. It holds
311  * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If
312  * val is given as a function it is executed only once.
313  * @param tmp is a temporary variable and should be of type uint8_t. It
314  * represents an intermediate value during conversion that is to be
315  * output by PUT_BYTE.
316  * @param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
317  * It could be a function or a statement, and uses tmp as the input byte.
318  * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
319  * executed up to 4 times for values in the valid UTF-8 range and up to
320  * 7 times in the general case, depending on the length of the converted
321  * Unicode character.
322  */
323 #define PUT_UTF8(val, tmp, PUT_BYTE)\
324     {\
325         int bytes, shift;\
326         uint32_t in = val;\
327         if (in < 0x80) {\
328             tmp = in;\
329             PUT_BYTE\
330         } else {\
331             bytes = (av_log2(in) + 4) / 5;\
332             shift = (bytes - 1) * 6;\
333             tmp = (256 - (256 >> bytes)) | (in >> shift);\
334             PUT_BYTE\
335             while (shift >= 6) {\
336                 shift -= 6;\
337                 tmp = 0x80 | ((in >> shift) & 0x3f);\
338                 PUT_BYTE\
339             }\
340         }\
341     }
342
343 /**
344  * @def PUT_UTF16(val, tmp, PUT_16BIT)
345  * Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes).
346  * @param val is an input-only argument and should be of type uint32_t. It holds
347  * a UCS-4 encoded Unicode character that is to be converted to UTF-16. If
348  * val is given as a function it is executed only once.
349  * @param tmp is a temporary variable and should be of type uint16_t. It
350  * represents an intermediate value during conversion that is to be
351  * output by PUT_16BIT.
352  * @param PUT_16BIT writes the converted UTF-16 data to any proper destination
353  * in desired endianness. It could be a function or a statement, and uses tmp
354  * as the input byte.  For example, PUT_BYTE could be "*output++ = tmp;"
355  * PUT_BYTE will be executed 1 or 2 times depending on input character.
356  */
357 #define PUT_UTF16(val, tmp, PUT_16BIT)\
358     {\
359         uint32_t in = val;\
360         if (in < 0x10000) {\
361             tmp = in;\
362             PUT_16BIT\
363         } else {\
364             tmp = 0xD800 | ((in - 0x10000) >> 10);\
365             PUT_16BIT\
366             tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
367             PUT_16BIT\
368         }\
369     }\
370
371
372
373 #include "mem.h"
374
375 #ifdef HAVE_AV_CONFIG_H
376 #    include "internal.h"
377 #endif /* HAVE_AV_CONFIG_H */
378
379 #endif /* AVUTIL_COMMON_H */
380
381 /*
382  * The following definitions are outside the multiple inclusion guard
383  * to ensure they are immediately available in intmath.h.
384  */
385
386 #ifndef av_ceil_log2
387 #   define av_ceil_log2     av_ceil_log2_c
388 #endif
389 #ifndef av_clip
390 #   define av_clip          av_clip_c
391 #endif
392 #ifndef av_clip_uint8
393 #   define av_clip_uint8    av_clip_uint8_c
394 #endif
395 #ifndef av_clip_int8
396 #   define av_clip_int8     av_clip_int8_c
397 #endif
398 #ifndef av_clip_uint16
399 #   define av_clip_uint16   av_clip_uint16_c
400 #endif
401 #ifndef av_clip_int16
402 #   define av_clip_int16    av_clip_int16_c
403 #endif
404 #ifndef av_clipl_int32
405 #   define av_clipl_int32   av_clipl_int32_c
406 #endif
407 #ifndef av_clip_intp2
408 #   define av_clip_intp2    av_clip_intp2_c
409 #endif
410 #ifndef av_clip_uintp2
411 #   define av_clip_uintp2   av_clip_uintp2_c
412 #endif
413 #ifndef av_sat_add32
414 #   define av_sat_add32     av_sat_add32_c
415 #endif
416 #ifndef av_sat_dadd32
417 #   define av_sat_dadd32    av_sat_dadd32_c
418 #endif
419 #ifndef av_clipf
420 #   define av_clipf         av_clipf_c
421 #endif
422 #ifndef av_popcount
423 #   define av_popcount      av_popcount_c
424 #endif
425 #ifndef av_popcount64
426 #   define av_popcount64    av_popcount64_c
427 #endif