common.h
上传用户:jylinhe
上传日期:2022-07-11
资源大小:334k
文件大小:15k
源码类别:

多媒体编程

开发平台:

Visual C++

  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.  * @file common.h
  22.  * common internal and external API header
  23.  */
  24. #ifndef AVUTIL_COMMON_H
  25. #define AVUTIL_COMMON_H
  26. //#include <inttypes.h>
  27. #ifndef _SIZE_T_DEFINED
  28. #define size_t unsigned int
  29. #define _SIZE_T_DEFINED
  30. #endif
  31. #ifdef WIN32
  32. #define inline __inline
  33. #endif
  34. #ifndef NULL
  35. #define NULL (void*)0
  36. #endif
  37. #if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
  38. #define CONFIG_WIN32
  39. #endif
  40. #if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(EMULATE_INTTYPES)
  41. #define EMULATE_INTTYPES
  42. #endif
  43. #ifndef M_PI
  44. #define M_PI 3.14159265358979323846
  45. #endif
  46. #include "config.h"
  47. #include <assert.h>
  48. #include <stdlib.h>
  49. #include <stdio.h>
  50. #include <string.h>
  51. #include <ctype.h>
  52. #include <limits.h>
  53. #include <math.h>
  54. #include <stddef.h>
  55. #ifndef __BEOS__
  56. #include <errno.h>
  57. #else
  58. #include "berrno.h"
  59. #endif
  60. #ifndef offsetof
  61. #define offsetof(T,F) ((unsigned int)((char *)&((T *)0)->F))
  62. #endif
  63. #include "bswap.h"
  64. typedef char int8_t;
  65. typedef short int16_t;
  66. typedef int int32_t;
  67. typedef unsigned char uint8_t;
  68. typedef unsigned short uint16_t;
  69. typedef unsigned int uint32_t;
  70. #ifdef CONFIG_WIN32
  71. typedef __int64 int64_t;
  72. typedef unsigned __int64 uint64_t;
  73. #else
  74. typedef long long int64_t;
  75. typedef unsigned long long uint64_t;
  76. #endif
  77. typedef char int_fast8_t;
  78. typedef short int_fast16_t;
  79. typedef int int_fast32_t;
  80. typedef unsigned char uint_fast8_t;
  81. typedef unsigned short uint_fast16_t;
  82. typedef unsigned int uint_fast32_t;
  83. #ifdef CONFIG_WIN32
  84. typedef __int64 int_fast64_t;
  85. typedef unsigned __int64 uint_fast64_t;
  86. #else
  87. typedef long long int_fast64_t;
  88. typedef unsigned long long uint_fast64_t;
  89. #endif
  90. #ifndef PRId64
  91. #define PRId64 "lld"
  92. #endif
  93. #ifndef PRIu64
  94. #define PRIu64 "llu"
  95. #endif
  96. #ifndef PRIx64
  97. #define PRIx64 "llx"
  98. #endif
  99. #ifndef PRId32
  100. #define PRId32 "d"
  101. #endif
  102. #ifndef PRIdFAST16
  103. #define PRIdFAST16 PRId32
  104. #endif
  105. #ifndef PRIdFAST32
  106. #define PRIdFAST32 PRId32
  107. #endif
  108. #ifndef INT16_MIN
  109. #define INT16_MIN       (-0x7fff-1)
  110. #endif
  111. #ifndef INT16_MAX
  112. #define INT16_MAX       0x7fff
  113. #endif
  114. #ifndef INT32_MIN
  115. #define INT32_MIN       (-0x7fffffff-1)
  116. #endif
  117. #ifndef INT32_MAX
  118. #define INT32_MAX       0x7fffffff
  119. #endif
  120. #ifndef UINT32_MAX
  121. #define UINT32_MAX      0xffffffff
  122. #endif
  123. #ifndef INT64_MIN
  124. #define INT64_MIN       (-1-(int64_t)0x7fffffffffffffff)
  125. #endif
  126. #ifndef INT64_MAX
  127. #define INT64_MAX int64_t_C(9223372036854775807)
  128. #endif
  129. #ifndef UINT64_MAX
  130. #define UINT64_MAX uint64_t_C(0xFFFFFFFFFFFFFFFF)
  131. #endif
  132. #ifndef INT_BIT
  133. #if INT_MAX != 2147483647
  134. #define INT_BIT 64
  135. #else
  136. #define INT_BIT 32
  137. #endif
  138. #endif
  139. #if defined(CONFIG_OS2) || defined(CONFIG_SUNOS)
  140. static inline float floorf(float f) 
  141. {
  142.     return floor(f);
  143. }
  144. #endif
  145. #ifdef CONFIG_WIN32 /* windows */
  146. #if !defined(__MINGW32__) && !defined(__CYGWIN__)
  147. #define int64_t_C(c)    (c ## i64)
  148. #define uint64_t_C(c)   (c ## ui64)
  149. #define INT64_C(c) (c ## i64)
  150. #define UINT64_C(c) (c ## ui64)
  151. #ifdef HAVE_AV_CONFIG_H
  152. #define inline __inline
  153. #endif
  154. #else
  155. #define int64_t_C(c)     (c ## LL)
  156. #define uint64_t_C(c)    (c ## ULL)
  157. #endif
  158. #define snprintf _snprintf
  159. #define vsnprintf _vsnprintf
  160. #else
  161. #ifndef int64_t_C
  162. #define int64_t_C(c)     (c ## LL)
  163. #define uint64_t_C(c)    (c ## ULL)
  164. #define INT64_C(c)  (c ## LL)
  165. #define UINT64_C(c)  (c ## ULL)
  166. #endif
  167. #ifdef USE_FASTMEMCPY
  168. #include "fastmemcpy.h"
  169. #endif
  170. #endif
  171. // Use rip-relative addressing if compiling PIC code on x86-64.
  172. #if defined(__MINGW32__) || defined(__CYGWIN__) || defined(__OS2__) || (defined (__OpenBSD__) && !defined(__ELF__))
  173. #if defined(ARCH_X86_64) && defined(PIC)
  174. #define MANGLE(a) "_" #a"(%%rip)"
  175. #else
  176. #define MANGLE(a) "_" #a
  177. #endif
  178. #else
  179. #if defined(ARCH_X86_64) && defined(PIC)
  180. #define MANGLE(a) #a"(%%rip)"
  181. #elif defined(CONFIG_DARWIN)
  182. #define MANGLE(a) "_" #a
  183. #else
  184. //#define MANGLE(a) #a
  185. #endif
  186. #endif
  187. #if defined(CONFIG_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
  188. inline void dprintf(const char* fmt,...) {}
  189. #else
  190. #ifdef DEBUG
  191. #define dprintf(fmt,...) av_log(NULL, AV_LOG_DEBUG, fmt, __VA_ARGS__)
  192. #else
  193. #define dprintf(fmt,...)
  194. #endif
  195. #endif
  196. #ifdef HAVE_AV_CONFIG_H
  197. #include "config.h"
  198. #include <stdlib.h>
  199. #include <stdio.h>
  200. #include <string.h>
  201. #include <ctype.h>
  202. #include <limits.h>
  203. #include <errno.h>
  204. #include <math.h>
  205. #endif
  206. #define AV_GCC_VERSION_AT_LEAST(x,y) (defined(__GNUC__) && (__GNUC__ > x || __GNUC__ == x && __GNUC_MINOR__ >= y))
  207. #ifndef av_always_inline
  208. #if AV_GCC_VERSION_AT_LEAST(3,1)
  209. #define av_always_inline __attribute__((always_inline)) inline
  210. #else
  211. #define av_always_inline inline
  212. #endif
  213. #endif
  214. #ifndef av_noinline
  215. #if AV_GCC_VERSION_AT_LEAST(3,1)
  216. #define av_noinline __attribute__((noinline))
  217. #else
  218. #define av_noinline
  219. #endif
  220. #endif
  221. #ifndef av_pure
  222. #if AV_GCC_VERSION_AT_LEAST(3,1)
  223. #define av_pure __attribute__((pure))
  224. #else
  225. #define av_pure
  226. #endif
  227. #endif
  228. #ifndef av_const
  229. #if AV_GCC_VERSION_AT_LEAST(2,6)
  230. #define av_const __attribute__((const))
  231. #else
  232. #define av_const
  233. #endif
  234. #endif
  235. #ifndef av_cold
  236. #if (!defined(__ICC) || __ICC > 1100) && AV_GCC_VERSION_AT_LEAST(4,3)
  237. #define av_cold __attribute__((cold))
  238. #else
  239. #define av_cold
  240. #endif
  241. #endif
  242. #ifdef HAVE_AV_CONFIG_H
  243. #include "internal.h"
  244. #endif /* HAVE_AV_CONFIG_H */
  245. #ifndef attribute_deprecated
  246. #if AV_GCC_VERSION_AT_LEAST(3,1)
  247. #define attribute_deprecated __attribute__((deprecated))
  248. #else
  249. #define attribute_deprecated
  250. #endif
  251. #endif
  252. #ifndef av_unused
  253. #if defined(__GNUC__)
  254. #define av_unused __attribute__((unused))
  255. #else
  256. #define av_unused
  257. #endif
  258. #endif
  259. #include "mem.h"
  260. #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
  261. #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
  262. #define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
  263. #define FFSIGN(a) ((a) > 0 ? 1 : -1)
  264. #define FFMAX(a,b) ((a) > (b) ? (a) : (b))
  265. #define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
  266. #define FFMIN(a,b) ((a) > (b) ? (b) : (a))
  267. #define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
  268. #define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
  269. #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
  270. /* misc math functions */
  271. extern const uint8_t ff_log2_tab[256];
  272. static inline av_const int av_log2(unsigned int v)
  273. {
  274.     int n = 0;
  275.     if (v & 0xffff0000) {
  276.         v >>= 16;
  277.         n += 16;
  278.     }
  279.     if (v & 0xff00) {
  280.         v >>= 8;
  281.         n += 8;
  282.     }
  283.     n += ff_log2_tab[v];
  284.     return n;
  285. }
  286. static inline av_const int av_log2_16bit(unsigned int v)
  287. {
  288.     int n = 0;
  289.     if (v & 0xff00) {
  290.         v >>= 8;
  291.         n += 8;
  292.     }
  293.     n += ff_log2_tab[v];
  294.     return n;
  295. }
  296. /* median of 3 */
  297. static inline av_const int mid_pred(int a, int b, int c)
  298. {
  299. #ifdef HAVE_CMOV
  300.     int i=b;
  301.     __asm__ volatile(
  302.         "cmp    %2, %1 nt"
  303.         "cmovg  %1, %0 nt"
  304.         "cmovg  %2, %1 nt"
  305.         "cmp    %3, %1 nt"
  306.         "cmovl  %3, %1 nt"
  307.         "cmp    %1, %0 nt"
  308.         "cmovg  %1, %0 nt"
  309.         :"+&r"(i), "+&r"(a)
  310.         :"r"(b), "r"(c)
  311.     );
  312.     return i;
  313. #elif 0
  314.     int t= (a-b)&((a-b)>>31);
  315.     a-=t;
  316.     b+=t;
  317.     b-= (b-c)&((b-c)>>31);
  318.     b+= (a-b)&((a-b)>>31);
  319.     return b;
  320. #else
  321.     if(a>b){
  322.         if(c>b){
  323.             if(c>a) b=a;
  324.             else    b=c;
  325.         }
  326.     }else{
  327.         if(b>c){
  328.             if(c>a) b=c;
  329.             else    b=a;
  330.         }
  331.     }
  332.     return b;
  333. #endif
  334. }
  335. /**
  336.  * clip a signed integer value into the amin-amax range
  337.  * @param a value to clip
  338.  * @param amin minimum value of the clip range
  339.  * @param amax maximum value of the clip range
  340.  * @return clipped value
  341.  */
  342. static inline av_const int av_clip(int a, int amin, int amax)
  343. {
  344.     if      (a < amin) return amin;
  345.     else if (a > amax) return amax;
  346.     else               return a;
  347. }
  348. /**
  349.  * clip a signed integer value into the 0-255 range
  350.  * @param a value to clip
  351.  * @return clipped value
  352.  */
  353. static inline av_const uint8_t av_clip_uint8(int a)
  354. {
  355.     if (a&(~255)) return (-a)>>31;
  356.     else          return a;
  357. }
  358. /**
  359.  * clip a signed integer value into the -32768,32767 range
  360.  * @param a value to clip
  361.  * @return clipped value
  362.  */
  363. static inline av_const int16_t av_clip_int16(int a)
  364. {
  365.     if ((a+32768) & ~65535) return (a>>31) ^ 32767;
  366.     else                    return a;
  367. }
  368. /**
  369.  * clip a float value into the amin-amax range
  370.  * @param a value to clip
  371.  * @param amin minimum value of the clip range
  372.  * @param amax maximum value of the clip range
  373.  * @return clipped value
  374.  */
  375. static inline av_const float av_clipf(float a, float amin, float amax)
  376. {
  377.     if      (a < amin) return amin;
  378.     else if (a > amax) return amax;
  379.     else               return a;
  380. }
  381. /**
  382.  * converts fourcc string to int
  383.  */
  384. static inline av_pure int ff_get_fourcc(const char *s){
  385. #ifdef HAVE_AV_CONFIG_H
  386.     assert( strlen(s)==4 );
  387. #endif
  388.     return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);
  389. }
  390. #define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
  391. #define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))
  392. /*!
  393.  * def GET_UTF8(val, GET_BYTE, ERROR)
  394.  * converts a UTF-8 character (up to 4 bytes long) to its 32-bit UCS-4 encoded form
  395.  * param val is the output and should be of type uint32_t. It holds the converted
  396.  * UCS-4 character and should be a left value.
  397.  * param GET_BYTE gets UTF-8 encoded bytes from any proper source. It can be
  398.  * a function or a statement whose return value or evaluated value is of type
  399.  * uint8_t. It will be executed up to 4 times for values in the valid UTF-8 range,
  400.  * and up to 7 times in the general case.
  401.  * param ERROR action that should be taken when an invalid UTF-8 byte is returned
  402.  * from GET_BYTE. It should be a statement that jumps out of the macro,
  403.  * like exit(), goto, return, break, or continue.
  404.  */
  405. #define GET_UTF8(val, GET_BYTE, ERROR)
  406.     val= GET_BYTE;
  407.     {
  408.         int ones= 7 - av_log2(val ^ 255);
  409.         if(ones==1)
  410.             ERROR
  411.         val&= 127>>ones;
  412.         while(--ones > 0){
  413.             int tmp= GET_BYTE - 128;
  414.             if(tmp>>6)
  415.                 ERROR
  416.             val= (val<<6) + tmp;
  417.         }
  418.     }
  419. /*!
  420.  * def PUT_UTF8(val, tmp, PUT_BYTE)
  421.  * converts a 32-bit unicode character to its UTF-8 encoded form (up to 4 bytes long).
  422.  * param val is an input only argument and should be of type uint32_t. It holds
  423.  * a ucs4 encoded unicode character that is to be converted to UTF-8. If
  424.  * val is given as a function it's executed only once.
  425.  * param tmp is a temporary variable and should be of type uint8_t. It
  426.  * represents an intermediate value during conversion that is to be
  427.  * outputted by PUT_BYTE.
  428.  * param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
  429.  * It could be a function or a statement, and uses tmp as the input byte.
  430.  * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
  431.  * executed up to 4 times for values in the valid UTF-8 range and up to
  432.  * 7 times in the general case, depending on the length of the converted
  433.  * unicode character.
  434.  */
  435. #define PUT_UTF8(val, tmp, PUT_BYTE)
  436.     {
  437.         int bytes, shift;
  438.         uint32_t in = val;
  439.         if (in < 0x80) {
  440.             tmp = in;
  441.             PUT_BYTE
  442.         } else {
  443.             bytes = (av_log2(in) + 4) / 5;
  444.             shift = (bytes - 1) * 6;
  445.             tmp = (256 - (256 >> bytes)) | (in >> shift);
  446.             PUT_BYTE
  447.             while (shift >= 6) {
  448.                 shift -= 6;
  449.                 tmp = 0x80 | ((in >> shift) & 0x3f);
  450.                 PUT_BYTE
  451.             }
  452.         }
  453.     }
  454. #if defined(ARCH_X86) || defined(ARCH_PPC) || defined(ARCH_BFIN)
  455. #define AV_READ_TIME read_time
  456. #if defined(ARCH_X86)
  457. static inline uint64_t read_time(void)
  458. {
  459. uint32_t a, d;
  460. __asm__ volatile("rdtscnt"
  461.  : "=a" (a), "=d" (d));
  462. return ((uint64_t)d << 32) + a;
  463. }
  464. #elif ARCH_BFIN
  465. static inline uint64_t read_time(void)
  466. {
  467. union {
  468. struct {
  469. unsigned lo;
  470. unsigned hi;
  471. } p;
  472. unsigned long long c;
  473. } t;
  474. __asm__ volatile ("%0=cycles; %1=cycles2;" : "=d" (t.p.lo), "=d" (t.p.hi));
  475. return t.c;
  476. }
  477. #else //FIXME check ppc64
  478. static inline uint64_t read_time(void)
  479. {
  480. uint32_t tbu, tbl, temp;
  481.  /* from section 2.2.1 of the 32-bit PowerPC PEM */
  482.  __asm__ volatile(
  483.  "1:n"
  484.  "mftbu  %2n"
  485.  "mftb   %0n"
  486.  "mftbu  %1n"
  487.  "cmpw   %2,%1n"
  488.  "bne    1bn"
  489.  : "=r"(tbl), "=r"(tbu), "=r"(temp)
  490.  :
  491.  : "cc");
  492.  return (((uint64_t)tbu)<<32) | (uint64_t)tbl;
  493. }
  494. #endif
  495. #elif defined(HAVE_GETHRTIME)
  496. #define AV_READ_TIME gethrtime
  497. #endif
  498. #ifdef AV_READ_TIME
  499. #define START_TIMER 
  500. uint64_t tend;
  501. uint64_t tstart= AV_READ_TIME();
  502. #define STOP_TIMER(id) 
  503. tend= AV_READ_TIME();
  504. {
  505. static uint64_t tsum=0;
  506. static int tcount=0;
  507. static int tskip_count=0;
  508. if(tcount<2 || tend - tstart < FFMAX(8*tsum/tcount, 2000)){
  509. tsum+= tend - tstart;
  510. tcount++;
  511. }else
  512. tskip_count++;
  513. if(((tcount+tskip_count)&(tcount+tskip_count-1))==0){
  514. av_log(NULL, AV_LOG_ERROR, "%"PRIu64" dezicycles in %s, %d runs, %d skipsn",
  515.    tsum*10/tcount, id, tcount, tskip_count);
  516. }
  517. }
  518. #else
  519. #define START_TIMER
  520. #define STOP_TIMER(id) {}
  521. #endif
  522. /**
  523.  * Returns NULL if CONFIG_SMALL is defined otherwise the argument
  524.  * without modifications, used to disable the definition of strings
  525.  * (for example AVCodec long_names).
  526.  */
  527. #ifdef CONFIG_SMALL
  528. #define NULL_IF_CONFIG_SMALL(x) NULL
  529. #else
  530. #define NULL_IF_CONFIG_SMALL(x) x
  531. #endif
  532. inline long long llrint(double x)
  533. {
  534.     return (__int64)(x + (x < 0 ? -0.5 : 0.5));
  535. }
  536. #endif /* AVUTIL_COMMON_H */