common.h 10.4 KB
Newer Older
1 2 3
/*
 * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
 *
4
 * This file is part of Libav.
5
 *
6
 * Libav is free software; you can redistribute it and/or
7 8
 * modify it under the terms of the GNU Lesser General Public
 * 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 13 14 15 16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 19 20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

Michael Niedermayer's avatar
Michael Niedermayer committed
21
/**
22
 * @file
Diego Biurrun's avatar
Diego Biurrun committed
23
 * common internal and external API header
Michael Niedermayer's avatar
Michael Niedermayer committed
24 25
 */

26 27
#ifndef AVUTIL_COMMON_H
#define AVUTIL_COMMON_H
Fabrice Bellard's avatar
Fabrice Bellard committed
28

29 30
#include <ctype.h>
#include <errno.h>
31
#include <inttypes.h>
32 33 34 35 36
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
37
#include "attributes.h"
Måns Rullgård's avatar
Måns Rullgård committed
38
#include "libavutil/avconfig.h"
39 40

#if AV_HAVE_BIGENDIAN
41
#   define AV_NE(be, le) (be)
42
#else
43
#   define AV_NE(be, le) (le)
44
#endif
45

46
//rounded division & shift
Michael Niedermayer's avatar
Michael Niedermayer committed
47
#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
48 49
/* assume b>0 */
#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
Diego Biurrun's avatar
Diego Biurrun committed
50
#define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
51
#define FFSIGN(a) ((a) > 0 ? 1 : -1)
52

Michael Niedermayer's avatar
Michael Niedermayer committed
53
#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
54
#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
Michael Niedermayer's avatar
Michael Niedermayer committed
55
#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
Baptiste Coudurier's avatar
Baptiste Coudurier committed
56
#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
57

Diego Biurrun's avatar
Diego Biurrun committed
58
#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
59
#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
60
#define FFALIGN(x, a) (((x)+(a)-1)&~((a)-1))
Michael Niedermayer's avatar
SWAP  
Michael Niedermayer committed
61

Fabrice Bellard's avatar
Fabrice Bellard committed
62
/* misc math functions */
63
extern const uint8_t ff_log2_tab[256];
Fabrice Bellard's avatar
Fabrice Bellard committed
64

65 66
extern const uint8_t av_reverse[256];

67
static av_always_inline av_const int av_log2_c(unsigned int v)
Fabrice Bellard's avatar
Fabrice Bellard committed
68
{
69
    int n = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
70 71 72 73 74 75 76 77
    if (v & 0xffff0000) {
        v >>= 16;
        n += 16;
    }
    if (v & 0xff00) {
        v >>= 8;
        n += 8;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
78 79 80 81 82
    n += ff_log2_tab[v];

    return n;
}

83
static av_always_inline av_const int av_log2_16bit_c(unsigned int v)
Michael Niedermayer's avatar
Michael Niedermayer committed
84
{
85
    int n = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
86 87 88
    if (v & 0xff00) {
        v >>= 8;
        n += 8;
Fabrice Bellard's avatar
Fabrice Bellard committed
89
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
90 91
    n += ff_log2_tab[v];

Fabrice Bellard's avatar
Fabrice Bellard committed
92 93
    return n;
}
94 95 96 97 98 99

#ifdef HAVE_AV_CONFIG_H
#   include "config.h"
#   include "intmath.h"
#endif

100 101
/* Pull in unguarded fallback defines at the end of this file. */
#include "common.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
102

Aurelien Jacobs's avatar
Aurelien Jacobs committed
103
/**
104
 * Clip a signed integer value into the amin-amax range.
Aurelien Jacobs's avatar
Aurelien Jacobs committed
105 106 107
 * @param a value to clip
 * @param amin minimum value of the clip range
 * @param amax maximum value of the clip range
108
 * @return clipped value
Aurelien Jacobs's avatar
Aurelien Jacobs committed
109
 */
110
static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
111
{
Diego Biurrun's avatar
Diego Biurrun committed
112
    if      (a < amin) return amin;
Michael Niedermayer's avatar
Michael Niedermayer committed
113 114
    else if (a > amax) return amax;
    else               return a;
115 116
}

Aurelien Jacobs's avatar
Aurelien Jacobs committed
117
/**
118
 * Clip a signed integer value into the 0-255 range.
Aurelien Jacobs's avatar
Aurelien Jacobs committed
119
 * @param a value to clip
120
 * @return clipped value
Aurelien Jacobs's avatar
Aurelien Jacobs committed
121
 */
122
static av_always_inline av_const uint8_t av_clip_uint8_c(int a)
123
{
124
    if (a&(~0xFF)) return (-a)>>31;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
125
    else           return a;
126 127
}

128
/**
129
 * Clip a signed integer value into the -128,127 range.
130 131 132
 * @param a value to clip
 * @return clipped value
 */
133
static av_always_inline av_const int8_t av_clip_int8_c(int a)
134 135 136 137 138
{
    if ((a+0x80) & ~0xFF) return (a>>31) ^ 0x7F;
    else                  return a;
}

Ramiro Polla's avatar
Ramiro Polla committed
139
/**
140
 * Clip a signed integer value into the 0-65535 range.
Ramiro Polla's avatar
Ramiro Polla committed
141 142 143
 * @param a value to clip
 * @return clipped value
 */
144
static av_always_inline av_const uint16_t av_clip_uint16_c(int a)
Ramiro Polla's avatar
Ramiro Polla committed
145
{
146
    if (a&(~0xFFFF)) return (-a)>>31;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
147
    else             return a;
Ramiro Polla's avatar
Ramiro Polla committed
148 149
}

150
/**
151
 * Clip a signed integer value into the -32768,32767 range.
152 153 154
 * @param a value to clip
 * @return clipped value
 */
155
static av_always_inline av_const int16_t av_clip_int16_c(int a)
156
{
157
    if ((a+0x8000) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
158
    else                      return a;
159 160
}

161
/**
162
 * Clip a signed 64-bit integer value into the -2147483648,2147483647 range.
163 164 165
 * @param a value to clip
 * @return clipped value
 */
166
static av_always_inline av_const int32_t av_clipl_int32_c(int64_t a)
167
{
168
    if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (a>>63) ^ 0x7FFFFFFF;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
169
    else                                         return a;
170 171
}

172
/**
173
 * Clip a float value into the amin-amax range.
174 175 176 177 178
 * @param a value to clip
 * @param amin minimum value of the clip range
 * @param amax maximum value of the clip range
 * @return clipped value
 */
179
static av_always_inline av_const float av_clipf_c(float a, float amin, float amax)
180 181 182 183 184 185
{
    if      (a < amin) return amin;
    else if (a > amax) return amax;
    else               return a;
}

186
/** Compute ceil(log2(x)).
187 188 189
 * @param x value used to compute ceil(log2(x))
 * @return computed ceiling of log2(x)
 */
190
static av_always_inline av_const int av_ceil_log2_c(int x)
191 192 193 194
{
    return av_log2((x - 1) << 1);
}

195 196 197 198 199
/**
 * Count number of bits set to one in x
 * @param x value to count bits of
 * @return the number of bits set to one in x
 */
200
static av_always_inline av_const int av_popcount_c(uint32_t x)
201 202 203 204 205 206 207 208
{
    x -= (x >> 1) & 0x55555555;
    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
    x = (x + (x >> 4)) & 0x0F0F0F0F;
    x += x >> 8;
    return (x + (x >> 16)) & 0x3F;
}

209 210
#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24))
#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((a) << 24))
211

212 213 214 215 216 217 218 219 220 221
/**
 * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
 *
 * @param val      Output value, must be an lvalue of type uint32_t.
 * @param GET_BYTE Expression reading one byte from the input.
 *                 Evaluated up to 7 times (4 for the currently
 *                 assigned Unicode range).  With a memory buffer
 *                 input, this could be *ptr++.
 * @param ERROR    Expression to be evaluated on invalid input,
 *                 typically a goto statement.
222
 */
223 224 225 226 227 228 229 230 231 232 233 234 235 236
#define GET_UTF8(val, GET_BYTE, ERROR)\
    val= GET_BYTE;\
    {\
        int ones= 7 - av_log2(val ^ 255);\
        if(ones==1)\
            ERROR\
        val&= 127>>ones;\
        while(--ones > 0){\
            int tmp= GET_BYTE - 128;\
            if(tmp>>6)\
                ERROR\
            val= (val<<6) + tmp;\
        }\
    }
237

238 239 240 241 242 243 244 245
/**
 * Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form.
 *
 * @param val       Output value, must be an lvalue of type uint32_t.
 * @param GET_16BIT Expression returning two bytes of UTF-16 data converted
 *                  to native byte order.  Evaluated one or two times.
 * @param ERROR     Expression to be evaluated on invalid input,
 *                  typically a goto statement.
246 247 248 249 250 251 252 253 254 255 256 257 258
 */
#define GET_UTF16(val, GET_16BIT, ERROR)\
    val = GET_16BIT;\
    {\
        unsigned int hi = val - 0xD800;\
        if (hi < 0x800) {\
            val = GET_16BIT - 0xDC00;\
            if (val > 0x3FFU || hi > 0x3FFU)\
                ERROR\
            val += (hi<<10) + 0x10000;\
        }\
    }\

259
/*!
260
 * \def PUT_UTF8(val, tmp, PUT_BYTE)
261
 * Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
262 263 264
 * \param val is an input-only argument and should be of type uint32_t. It holds
 * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If
 * val is given as a function it is executed only once.
265 266
 * \param tmp is a temporary variable and should be of type uint8_t. It
 * represents an intermediate value during conversion that is to be
267
 * output by PUT_BYTE.
Diego Biurrun's avatar
Diego Biurrun committed
268
 * \param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
269 270
 * It could be a function or a statement, and uses tmp as the input byte.
 * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
Diego Biurrun's avatar
Diego Biurrun committed
271
 * executed up to 4 times for values in the valid UTF-8 range and up to
272
 * 7 times in the general case, depending on the length of the converted
273
 * Unicode character.
274
 */
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
#define PUT_UTF8(val, tmp, PUT_BYTE)\
    {\
        int bytes, shift;\
        uint32_t in = val;\
        if (in < 0x80) {\
            tmp = in;\
            PUT_BYTE\
        } else {\
            bytes = (av_log2(in) + 4) / 5;\
            shift = (bytes - 1) * 6;\
            tmp = (256 - (256 >> bytes)) | (in >> shift);\
            PUT_BYTE\
            while (shift >= 6) {\
                shift -= 6;\
                tmp = 0x80 | ((in >> shift) & 0x3f);\
                PUT_BYTE\
            }\
        }\
    }

Anton Khirnov's avatar
Anton Khirnov committed
295 296
/*!
 * \def PUT_UTF16(val, tmp, PUT_16BIT)
297
 * Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes).
Anton Khirnov's avatar
Anton Khirnov committed
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
 * \param val is an input-only argument and should be of type uint32_t. It holds
 * a UCS-4 encoded Unicode character that is to be converted to UTF-16. If
 * val is given as a function it is executed only once.
 * \param tmp is a temporary variable and should be of type uint16_t. It
 * represents an intermediate value during conversion that is to be
 * output by PUT_16BIT.
 * \param PUT_16BIT writes the converted UTF-16 data to any proper destination
 * in desired endianness. It could be a function or a statement, and uses tmp
 * as the input byte.  For example, PUT_BYTE could be "*output++ = tmp;"
 * PUT_BYTE will be executed 1 or 2 times depending on input character.
 */
#define PUT_UTF16(val, tmp, PUT_16BIT)\
    {\
        uint32_t in = val;\
        if (in < 0x10000) {\
            tmp = in;\
            PUT_16BIT\
        } else {\
            tmp = 0xD800 | ((in - 0x10000) >> 10);\
            PUT_16BIT\
            tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
            PUT_16BIT\
        }\
    }\



325 326
#include "mem.h"

327 328 329 330
#ifdef HAVE_AV_CONFIG_H
#    include "internal.h"
#endif /* HAVE_AV_CONFIG_H */

331
#endif /* AVUTIL_COMMON_H */
332 333 334 335 336 337 338 339 340 341 342 343

/*
 * The following definitions are outside the multiple inclusion guard
 * to ensure they are immediately available in intmath.h.
 */

#ifndef av_log2
#   define av_log2       av_log2_c
#endif
#ifndef av_log2_16bit
#   define av_log2_16bit av_log2_16bit_c
#endif
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
#ifndef av_ceil_log2
#   define av_ceil_log2     av_ceil_log2_c
#endif
#ifndef av_clip
#   define av_clip          av_clip_c
#endif
#ifndef av_clip_uint8
#   define av_clip_uint8    av_clip_uint8_c
#endif
#ifndef av_clip_int8
#   define av_clip_int8     av_clip_int8_c
#endif
#ifndef av_clip_uint16
#   define av_clip_uint16   av_clip_uint16_c
#endif
#ifndef av_clip_int16
#   define av_clip_int16    av_clip_int16_c
#endif
#ifndef av_clipl_int32
#   define av_clipl_int32   av_clipl_int32_c
#endif
#ifndef av_clipf
#   define av_clipf         av_clipf_c
#endif
368 369 370
#ifndef av_popcount
#   define av_popcount      av_popcount_c
#endif