开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
common.h
资源名称：ffh264libxxxx.rar　[点击查看]
上传用户：shlianrong
上传日期：2022-07-08
资源大小：309k
文件大小：15k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

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