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