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 libavutil/common.h 23 * common internal and external API header 24 */ 25 26#ifndef AVUTIL_COMMON_H 27#define AVUTIL_COMMON_H 28 29#include <ctype.h> 30#include <errno.h> 31#include <inttypes.h> 32#include <limits.h> 33#include <math.h> 34#include <stdio.h> 35#include <stdlib.h> 36#include <string.h> 37 38#ifdef __GNUC__ 39# define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > x || __GNUC__ == x && __GNUC_MINOR__ >= y) 40#else 41# define AV_GCC_VERSION_AT_LEAST(x,y) 0 42#endif 43 44#ifndef av_always_inline 45#if AV_GCC_VERSION_AT_LEAST(3,1) 46# define av_always_inline __attribute__((always_inline)) inline 47#else 48# define av_always_inline inline 49#endif 50#endif 51 52#ifndef av_noinline 53#if AV_GCC_VERSION_AT_LEAST(3,1) 54# define av_noinline __attribute__((noinline)) 55#else 56# define av_noinline 57#endif 58#endif 59 60#ifndef av_pure 61#if AV_GCC_VERSION_AT_LEAST(3,1) 62# define av_pure __attribute__((pure)) 63#else 64# define av_pure 65#endif 66#endif 67 68#ifndef av_const 69#if AV_GCC_VERSION_AT_LEAST(2,6) 70# define av_const __attribute__((const)) 71#else 72# define av_const 73#endif 74#endif 75 76#ifndef av_cold 77#if (!defined(__ICC) || __ICC > 1100) && AV_GCC_VERSION_AT_LEAST(4,3) 78# define av_cold __attribute__((cold)) 79#else 80# define av_cold 81#endif 82#endif 83 84#ifndef av_flatten 85#if AV_GCC_VERSION_AT_LEAST(4,1) 86# define av_flatten __attribute__((flatten)) 87#else 88# define av_flatten 89#endif 90#endif 91 92#ifndef attribute_deprecated 93#if AV_GCC_VERSION_AT_LEAST(3,1) 94# define attribute_deprecated __attribute__((deprecated)) 95#else 96# define attribute_deprecated 97#endif 98#endif 99 100#ifndef av_unused 101#if defined(__GNUC__) 102# define av_unused __attribute__((unused)) 103#else 104# define av_unused 105#endif 106#endif 107 108#ifndef av_uninit 109#if defined(__GNUC__) && !defined(__ICC) 110# define av_uninit(x) x=x 111#else 112# define av_uninit(x) x 113#endif 114#endif 115 116//rounded division & shift 117#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b)) 118/* assume b>0 */ 119#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b)) 120#define FFABS(a) ((a) >= 0 ? (a) : (-(a))) 121#define FFSIGN(a) ((a) > 0 ? 1 : -1) 122 123#define FFMAX(a,b) ((a) > (b) ? (a) : (b)) 124#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c) 125#define FFMIN(a,b) ((a) > (b) ? (b) : (a)) 126#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c) 127 128#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0) 129#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0])) 130 131/* misc math functions */ 132extern const uint8_t ff_log2_tab[256]; 133 134static inline av_const int av_log2(unsigned int v) 135{ 136 int n = 0; 137 if (v & 0xffff0000) { 138 v >>= 16; 139 n += 16; 140 } 141 if (v & 0xff00) { 142 v >>= 8; 143 n += 8; 144 } 145 n += ff_log2_tab[v]; 146 147 return n; 148} 149 150static inline av_const int av_log2_16bit(unsigned int v) 151{ 152 int n = 0; 153 if (v & 0xff00) { 154 v >>= 8; 155 n += 8; 156 } 157 n += ff_log2_tab[v]; 158 159 return n; 160} 161 162/** 163 * Clips a signed integer value into the amin-amax range. 164 * @param a value to clip 165 * @param amin minimum value of the clip range 166 * @param amax maximum value of the clip range 167 * @return clipped value 168 */ 169static inline av_const int av_clip(int a, int amin, int amax) 170{ 171 if (a < amin) return amin; 172 else if (a > amax) return amax; 173 else return a; 174} 175 176/** 177 * Clips a signed integer value into the 0-255 range. 178 * @param a value to clip 179 * @return clipped value 180 */ 181static inline av_const uint8_t av_clip_uint8(int a) 182{ 183 if (a&(~255)) return (-a)>>31; 184 else return a; 185} 186 187/** 188 * Clips a signed integer value into the -32768,32767 range. 189 * @param a value to clip 190 * @return clipped value 191 */ 192static inline av_const int16_t av_clip_int16(int a) 193{ 194 if ((a+32768) & ~65535) return (a>>31) ^ 32767; 195 else return a; 196} 197 198/** 199 * Clips a float value into the amin-amax range. 200 * @param a value to clip 201 * @param amin minimum value of the clip range 202 * @param amax maximum value of the clip range 203 * @return clipped value 204 */ 205static inline av_const float av_clipf(float a, float amin, float amax) 206{ 207 if (a < amin) return amin; 208 else if (a > amax) return amax; 209 else return a; 210} 211 212#define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24)) 213#define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24)) 214 215/*! 216 * \def GET_UTF8(val, GET_BYTE, ERROR) 217 * Converts a UTF-8 character (up to 4 bytes long) to its 32-bit UCS-4 encoded form 218 * \param val is the output and should be of type uint32_t. It holds the converted 219 * UCS-4 character and should be a left value. 220 * \param GET_BYTE gets UTF-8 encoded bytes from any proper source. It can be 221 * a function or a statement whose return value or evaluated value is of type 222 * uint8_t. It will be executed up to 4 times for values in the valid UTF-8 range, 223 * and up to 7 times in the general case. 224 * \param ERROR action that should be taken when an invalid UTF-8 byte is returned 225 * from GET_BYTE. It should be a statement that jumps out of the macro, 226 * like exit(), goto, return, break, or continue. 227 */ 228#define GET_UTF8(val, GET_BYTE, ERROR)\ 229 val= GET_BYTE;\ 230 {\ 231 int ones= 7 - av_log2(val ^ 255);\ 232 if(ones==1)\ 233 ERROR\ 234 val&= 127>>ones;\ 235 while(--ones > 0){\ 236 int tmp= GET_BYTE - 128;\ 237 if(tmp>>6)\ 238 ERROR\ 239 val= (val<<6) + tmp;\ 240 }\ 241 } 242 243/*! 244 * \def PUT_UTF8(val, tmp, PUT_BYTE) 245 * Converts a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long). 246 * \param val is an input-only argument and should be of type uint32_t. It holds 247 * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If 248 * val is given as a function it is executed only once. 249 * \param tmp is a temporary variable and should be of type uint8_t. It 250 * represents an intermediate value during conversion that is to be 251 * output by PUT_BYTE. 252 * \param PUT_BYTE writes the converted UTF-8 bytes to any proper destination. 253 * It could be a function or a statement, and uses tmp as the input byte. 254 * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be 255 * executed up to 4 times for values in the valid UTF-8 range and up to 256 * 7 times in the general case, depending on the length of the converted 257 * Unicode character. 258 */ 259#define PUT_UTF8(val, tmp, PUT_BYTE)\ 260 {\ 261 int bytes, shift;\ 262 uint32_t in = val;\ 263 if (in < 0x80) {\ 264 tmp = in;\ 265 PUT_BYTE\ 266 } else {\ 267 bytes = (av_log2(in) + 4) / 5;\ 268 shift = (bytes - 1) * 6;\ 269 tmp = (256 - (256 >> bytes)) | (in >> shift);\ 270 PUT_BYTE\ 271 while (shift >= 6) {\ 272 shift -= 6;\ 273 tmp = 0x80 | ((in >> shift) & 0x3f);\ 274 PUT_BYTE\ 275 }\ 276 }\ 277 } 278 279#include "mem.h" 280 281#ifdef HAVE_AV_CONFIG_H 282# include "config.h" 283# include "internal.h" 284#endif /* HAVE_AV_CONFIG_H */ 285 286#endif /* AVUTIL_COMMON_H */ 287