common.h
上传用户:lctgjx
上传日期:2022-06-04
资源大小:8887k
文件大小:11k
源码类别:

流媒体/Mpeg4/MP4

开发平台:

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 FFMPEG_COMMON_H
  25. #define FFMPEG_COMMON_H
  26. #if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
  27. #    define CONFIG_WIN32
  28. #endif
  29. #if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(EMULATE_INTTYPES)
  30. #    define EMULATE_INTTYPES
  31. #endif
  32. #ifndef EMULATE_INTTYPES
  33. #   include <inttypes.h>
  34. #else
  35.     typedef signed char  int8_t;
  36.     typedef signed short int16_t;
  37.     typedef signed int   int32_t;
  38.     typedef unsigned char  uint8_t;
  39.     typedef unsigned short uint16_t;
  40.     typedef unsigned int   uint32_t;
  41. #   ifdef CONFIG_WIN32
  42.         typedef signed __int64   int64_t;
  43.         typedef unsigned __int64 uint64_t;
  44. #   else /* other OS */
  45.         typedef signed long long   int64_t;
  46.         typedef unsigned long long uint64_t;
  47. #   endif /* other OS */
  48. #endif /* EMULATE_INTTYPES */
  49. #ifdef HAVE_AV_CONFIG_H
  50. /* only include the following when compiling package */
  51. #    include "config.h"
  52. #    include <stdlib.h>
  53. #    include <stdio.h>
  54. #    include <string.h>
  55. #    include <ctype.h>
  56. #    include <limits.h>
  57. #    include <errno.h>
  58. #    include <math.h>
  59. #endif /* HAVE_AV_CONFIG_H */
  60. #ifndef av_always_inline
  61. #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
  62. #    define av_always_inline __attribute__((always_inline)) inline
  63. #else
  64. #    define av_always_inline inline
  65. #endif
  66. #endif
  67. #ifndef av_noinline
  68. #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
  69. #    define av_noinline __attribute__((noinline))
  70. #else
  71. #    define av_noinline
  72. #endif
  73. #endif
  74. #ifndef av_pure
  75. #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
  76. #    define av_pure __attribute__((pure))
  77. #else
  78. #    define av_pure
  79. #endif
  80. #endif
  81. #ifndef av_const
  82. #if defined(__GNUC__) && (__GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ > 5)
  83. #    define av_const __attribute__((const))
  84. #else
  85. #    define av_const
  86. #endif
  87. #endif
  88. #ifndef av_cold
  89. #if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ > 2)
  90. #    define av_cold __attribute__((cold))
  91. #else
  92. #    define av_cold
  93. #endif
  94. #endif
  95. #ifdef HAVE_AV_CONFIG_H
  96. #    include "internal.h"
  97. #endif /* HAVE_AV_CONFIG_H */
  98. #ifndef attribute_deprecated
  99. #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
  100. #    define attribute_deprecated __attribute__((deprecated))
  101. #else
  102. #    define attribute_deprecated
  103. #endif
  104. #endif
  105. #ifndef av_unused
  106. #if defined(__GNUC__)
  107. #    define av_unused __attribute__((unused))
  108. #else
  109. #    define av_unused
  110. #endif
  111. #endif
  112. #define inline _inline
  113. #include "mem.h"
  114. //rounded divison & shift
  115. #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
  116. /* assume b>0 */
  117. #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
  118. #define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
  119. #define FFSIGN(a) ((a) > 0 ? 1 : -1)
  120. #define FFMAX(a,b) ((a) > (b) ? (a) : (b))
  121. #define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
  122. #define FFMIN(a,b) ((a) > (b) ? (b) : (a))
  123. #define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
  124. #define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
  125. /* misc math functions */
  126. extern const uint8_t ff_log2_tab[256];
  127. static inline av_const int av_log2(unsigned int v)
  128. {
  129.     int n = 0;
  130.     if (v & 0xffff0000) {
  131.         v >>= 16;
  132.         n += 16;
  133.     }
  134.     if (v & 0xff00) {
  135.         v >>= 8;
  136.         n += 8;
  137.     }
  138.     n += ff_log2_tab[v];
  139.     return n;
  140. }
  141. static inline av_const int av_log2_16bit(unsigned int v)
  142. {
  143.     int n = 0;
  144.     if (v & 0xff00) {
  145.         v >>= 8;
  146.         n += 8;
  147.     }
  148.     n += ff_log2_tab[v];
  149.     return n;
  150. }
  151. /* median of 3 */
  152. static inline av_const int mid_pred(int a, int b, int c)
  153. {
  154. #ifdef HAVE_CMOV
  155.     int i=b;
  156.     asm volatile(
  157.         "cmp    %2, %1 nt"
  158.         "cmovg  %1, %0 nt"
  159.         "cmovg  %2, %1 nt"
  160.         "cmp    %3, %1 nt"
  161.         "cmovl  %3, %1 nt"
  162.         "cmp    %1, %0 nt"
  163.         "cmovg  %1, %0 nt"
  164.         :"+&r"(i), "+&r"(a)
  165.         :"r"(b), "r"(c)
  166.     );
  167.     return i;
  168. #elif 0
  169.     int t= (a-b)&((a-b)>>31);
  170.     a-=t;
  171.     b+=t;
  172.     b-= (b-c)&((b-c)>>31);
  173.     b+= (a-b)&((a-b)>>31);
  174.     return b;
  175. #else
  176.     if(a>b){
  177.         if(c>b){
  178.             if(c>a) b=a;
  179.             else    b=c;
  180.         }
  181.     }else{
  182.         if(b>c){
  183.             if(c>a) b=c;
  184.             else    b=a;
  185.         }
  186.     }
  187.     return b;
  188. #endif
  189. }
  190. /**
  191.  * clip a signed integer value into the amin-amax range
  192.  * @param a value to clip
  193.  * @param amin minimum value of the clip range
  194.  * @param amax maximum value of the clip range
  195.  * @return clipped value
  196.  */
  197. static inline av_const int av_clip(int a, int amin, int amax)
  198. {
  199.     if      (a < amin) return amin;
  200.     else if (a > amax) return amax;
  201.     else               return a;
  202. }
  203. /**
  204.  * clip a signed integer value into the 0-255 range
  205.  * @param a value to clip
  206.  * @return clipped value
  207.  */
  208. static inline av_const uint8_t av_clip_uint8(int a)
  209. {
  210.     if (a&(~255)) return (-a)>>31;
  211.     else          return a;
  212. }
  213. /**
  214.  * clip a signed integer value into the -32768,32767 range
  215.  * @param a value to clip
  216.  * @return clipped value
  217.  */
  218. static inline av_const int16_t av_clip_int16(int a)
  219. {
  220.     if ((a+32768) & ~65535) return (a>>31) ^ 32767;
  221.     else                    return a;
  222. }
  223. /* math */
  224. int64_t av_const ff_gcd(int64_t a, int64_t b);
  225. /**
  226.  * converts fourcc string to int
  227.  */
  228. static inline av_pure int ff_get_fourcc(const char *s){
  229. #ifdef HAVE_AV_CONFIG_H
  230.     assert( strlen(s)==4 );
  231. #endif
  232.     return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);
  233. }
  234. #define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
  235. #define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))
  236. /*!
  237.  * def GET_UTF8(val, GET_BYTE, ERROR)
  238.  * converts a UTF-8 character (up to 4 bytes long) to its 32-bit UCS-4 encoded form
  239.  * param val is the output and should be of type uint32_t. It holds the converted
  240.  * UCS-4 character and should be a left value.
  241.  * param GET_BYTE gets UTF-8 encoded bytes from any proper source. It can be
  242.  * a function or a statement whose return value or evaluated value is of type
  243.  * uint8_t. It will be executed up to 4 times for values in the valid UTF-8 range,
  244.  * and up to 7 times in the general case.
  245.  * param ERROR action that should be taken when an invalid UTF-8 byte is returned
  246.  * from GET_BYTE. It should be a statement that jumps out of the macro,
  247.  * like exit(), goto, return, break, or continue.
  248.  */
  249. #define GET_UTF8(val, GET_BYTE, ERROR)
  250.     val= GET_BYTE;
  251.     {
  252.         int ones= 7 - av_log2(val ^ 255);
  253.         if(ones==1)
  254.             ERROR
  255.         val&= 127>>ones;
  256.         while(--ones > 0){
  257.             int tmp= GET_BYTE - 128;
  258.             if(tmp>>6)
  259.                 ERROR
  260.             val= (val<<6) + tmp;
  261.         }
  262.     }
  263. /*!
  264.  * def PUT_UTF8(val, tmp, PUT_BYTE)
  265.  * converts a 32-bit unicode character to its UTF-8 encoded form (up to 4 bytes long).
  266.  * param val is an input only argument and should be of type uint32_t. It holds
  267.  * a ucs4 encoded unicode character that is to be converted to UTF-8. If
  268.  * val is given as a function it's executed only once.
  269.  * param tmp is a temporary variable and should be of type uint8_t. It
  270.  * represents an intermediate value during conversion that is to be
  271.  * outputted by PUT_BYTE.
  272.  * param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
  273.  * It could be a function or a statement, and uses tmp as the input byte.
  274.  * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
  275.  * executed up to 4 times for values in the valid UTF-8 range and up to
  276.  * 7 times in the general case, depending on the length of the converted
  277.  * unicode character.
  278.  */
  279. #define PUT_UTF8(val, tmp, PUT_BYTE)
  280.     {
  281.         int bytes, shift;
  282.         uint32_t in = val;
  283.         if (in < 0x80) {
  284.             tmp = in;
  285.             PUT_BYTE
  286.         } else {
  287.             bytes = (av_log2(in) + 4) / 5;
  288.             shift = (bytes - 1) * 6;
  289.             tmp = (256 - (256 >> bytes)) | (in >> shift);
  290.             PUT_BYTE
  291.             while (shift >= 6) {
  292.                 shift -= 6;
  293.                 tmp = 0x80 | ((in >> shift) & 0x3f);
  294.                 PUT_BYTE
  295.             }
  296.         }
  297.     }
  298. #if defined(ARCH_X86) || defined(ARCH_POWERPC) || defined(ARCH_BFIN)
  299. #define AV_READ_TIME read_time
  300. #if defined(ARCH_X86_64)
  301. static inline uint64_t read_time(void)
  302. {
  303.     uint64_t a, d;
  304.     asm volatile("rdtscnt"
  305.                  : "=a" (a), "=d" (d));
  306.     return (d << 32) | (a & 0xffffffff);
  307. }
  308. #elif defined(ARCH_X86_32)
  309. static inline long long read_time(void)
  310. {
  311.     long long l;
  312.     asm volatile("rdtscnt"
  313.                  : "=A" (l));
  314.     return l;
  315. }
  316. #elif ARCH_BFIN
  317. static inline uint64_t read_time(void)
  318. {
  319.     union {
  320.         struct {
  321.             unsigned lo;
  322.             unsigned hi;
  323.         } p;
  324.         unsigned long long c;
  325.     } t;
  326.     asm volatile ("%0=cycles; %1=cycles2;" : "=d" (t.p.lo), "=d" (t.p.hi));
  327.     return t.c;
  328. }
  329. #else //FIXME check ppc64
  330. static inline uint64_t read_time(void)
  331. {
  332.     uint32_t tbu, tbl, temp;
  333.      /* from section 2.2.1 of the 32-bit PowerPC PEM */
  334.      asm volatile(
  335.          "1:n"
  336.          "mftbu  %2n"
  337.          "mftb   %0n"
  338.          "mftbu  %1n"
  339.          "cmpw   %2,%1n"
  340.          "bne    1bn"
  341.      : "=r"(tbl), "=r"(tbu), "=r"(temp)
  342.      :
  343.      : "cc");
  344.      return (((uint64_t)tbu)<<32) | (uint64_t)tbl;
  345. }
  346. #endif
  347. #elif defined(HAVE_GETHRTIME)
  348. #define AV_READ_TIME gethrtime
  349. #endif
  350. #ifdef AV_READ_TIME
  351. #define START_TIMER 
  352. uint64_t tend;
  353. uint64_t tstart= AV_READ_TIME();
  354. #define STOP_TIMER(id) 
  355. tend= AV_READ_TIME();
  356. {
  357.     static uint64_t tsum=0;
  358.     static int tcount=0;
  359.     static int tskip_count=0;
  360.     if(tcount<2 || tend - tstart < FFMAX(8*tsum/tcount, 2000)){
  361.         tsum+= tend - tstart;
  362.         tcount++;
  363.     }else
  364.         tskip_count++;
  365.     if(((tcount+tskip_count)&(tcount+tskip_count-1))==0){
  366.         av_log(NULL, AV_LOG_ERROR, "%"PRIu64" dezicycles in %s, %d runs, %d skipsn",
  367.                tsum*10/tcount, id, tcount, tskip_count);
  368.     }
  369. }
  370. #else
  371. #define START_TIMER
  372. #define STOP_TIMER(id) {}
  373. #endif
  374. /**
  375.  * Returns NULL if CONFIG_SMALL is defined otherwise the argument
  376.  * without modifications, used to disable the definition of strings
  377.  * (for example AVCodec long_names).
  378.  */
  379. #ifdef CONFIG_SMALL
  380. #   define NULL_IF_CONFIG_SMALL(x) NULL
  381. #else
  382. #   define NULL_IF_CONFIG_SMALL(x) x
  383. #endif
  384. #endif /* FFMPEG_COMMON_H */