falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4029 Commits
32 Branches
535MB
Tree: a2c3bf82a7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a2c3bf82a7'
${ noResults }
FFmpeg/libavcodec/common.h

1337 lines
32KB
Raw Blame History 

  1. /**

  2.  * @file common.h

  3.  * common internal api header.

  4.  */

  5. 

  6. #ifndef COMMON_H

  7. #define COMMON_H

  8. 

  9. #if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)

  10. #    define CONFIG_WIN32

  11. #endif

  12. 

  13. //#define ALT_BITSTREAM_WRITER

  14. //#define ALIGNED_BITSTREAM_WRITER

  15. 

  16. #define ALT_BITSTREAM_READER

  17. //#define LIBMPEG2_BITSTREAM_READER

  18. //#define A32_BITSTREAM_READER

  19. #define LIBMPEG2_BITSTREAM_READER_HACK //add BERO

  20. 

  21. #ifndef M_PI

  22. #define M_PI    3.14159265358979323846

  23. #endif

  24. 

  25. #ifdef HAVE_AV_CONFIG_H

  26. /* only include the following when compiling package */

  27. #    include "config.h"

  28. 

  29. #    include <stdlib.h>

  30. #    include <stdio.h>

  31. #    include <string.h>

  32. #    include <ctype.h>

  33. #    include <limits.h>

  34. #    ifndef __BEOS__

  35. #        include <errno.h>

  36. #    else

  37. #        include "berrno.h"

  38. #    endif

  39. #    include <math.h>

  40. 

  41. #    ifndef ENODATA

  42. #        define ENODATA  61

  43. #    endif

  44. 

  45. #include <stddef.h>

  46. #ifndef offsetof

  47. # define offsetof(T,F) ((unsigned int)((char *)&((T *)0)->F))

  48. #endif

  49. 

  50. #define AVOPTION_CODEC_BOOL(name, help, field) \

  51.     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_BOOL }

  52. #define AVOPTION_CODEC_DOUBLE(name, help, field, minv, maxv, defval) \

  53.     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_DOUBLE, minv, maxv, defval }

  54. #define AVOPTION_CODEC_FLAG(name, help, field, flag, defval) \

  55.     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_FLAG, flag, 0, defval }

  56. #define AVOPTION_CODEC_INT(name, help, field, minv, maxv, defval) \

  57.     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_INT, minv, maxv, defval }

  58. #define AVOPTION_CODEC_STRING(name, help, field, str, val) \

  59.     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_STRING, .defval = val, .defstr = str }

  60. #define AVOPTION_CODEC_RCOVERRIDE(name, help, field) \

  61.     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_RCOVERRIDE, .defval = 0, .defstr = NULL }

  62. #define AVOPTION_SUB(ptr) { .name = NULL, .help = (const char*)ptr }

  63. #define AVOPTION_END() AVOPTION_SUB(NULL)

  64. 

  65. struct AVOption;

  66. #ifdef HAVE_MMX

  67. extern const struct AVOption avoptions_common[3 + 5];

  68. #else

  69. extern const struct AVOption avoptions_common[3];

  70. #endif

  71. extern const struct AVOption avoptions_workaround_bug[11];

  72. 

  73. #endif /* HAVE_AV_CONFIG_H */

  74. 

  75. /* Suppress restrict if it was not defined in config.h.  */

  76. #ifndef restrict

  77. #    define restrict

  78. #endif

  79. 

  80. #ifndef always_inline

  81. #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)

  82. #    define always_inline __attribute__((always_inline)) inline

  83. #else

  84. #    define always_inline inline

  85. #endif

  86. #endif

  87. 

  88. #ifndef attribute_used

  89. #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)

  90. #    define attribute_used __attribute__((used))

  91. #else

  92. #    define attribute_used

  93. #endif

  94. #endif

  95. 

  96. #ifndef EMULATE_INTTYPES

  97. #   include <inttypes.h>

  98. #else

  99.     typedef signed char  int8_t;

  100.     typedef signed short int16_t;

  101.     typedef signed int   int32_t;

  102.     typedef unsigned char  uint8_t;

  103.     typedef unsigned short uint16_t;

  104.     typedef unsigned int   uint32_t;

  105. 

  106. #   ifdef CONFIG_WIN32

  107.         typedef signed __int64   int64_t;

  108.         typedef unsigned __int64 uint64_t;

  109. #   else /* other OS */

  110.         typedef signed long long   int64_t;

  111.         typedef unsigned long long uint64_t;

  112. #   endif /* other OS */

  113. #endif /* HAVE_INTTYPES_H */

  114. 

  115. #ifndef INT16_MIN

  116. #define INT16_MIN       (-0x7fff-1)

  117. #endif

  118. 

  119. #ifndef INT16_MAX

  120. #define INT16_MAX       0x7fff

  121. #endif

  122. 

  123. #ifndef INT64_MIN

  124. #define INT64_MIN       (-0x7fffffffffffffffLL-1)

  125. #endif

  126. 

  127. #ifndef INT64_MAX

  128. #define INT64_MAX int64_t_C(9223372036854775807)

  129. #endif

  130. 

  131. #ifndef UINT64_MAX

  132. #define UINT64_MAX uint64_t_C(0xFFFFFFFFFFFFFFFF)

  133. #endif

  134. 

  135. #ifdef EMULATE_FAST_INT

  136. /* note that we don't emulate 64bit ints */

  137. typedef signed char int_fast8_t;

  138. typedef signed int  int_fast16_t;

  139. typedef signed int  int_fast32_t;

  140. typedef unsigned char uint_fast8_t;

  141. typedef unsigned int  uint_fast16_t;

  142. typedef unsigned int  uint_fast32_t;

  143. #endif

  144. 

  145. #ifndef INT_BIT

  146. #    if INT_MAX != 2147483647

  147. #        define INT_BIT 64

  148. #    else

  149. #        define INT_BIT 32

  150. #    endif

  151. #endif

  152. 

  153. #if defined(CONFIG_OS2) || defined(CONFIG_SUNOS)

  154. static inline float floorf(float f) { 

  155.     return floor(f); 

  156. }

  157. #endif

  158. 

  159. #ifdef CONFIG_WIN32

  160. 

  161. /* windows */

  162. 

  163. #    if !defined(__MINGW32__) && !defined(__CYGWIN__)

  164. #        define int64_t_C(c)     (c ## i64)

  165. #        define uint64_t_C(c)    (c ## i64)

  166. 

  167. #    ifdef HAVE_AV_CONFIG_H

  168. #            define inline __inline

  169. #    endif

  170. 

  171. #    else

  172. #        define int64_t_C(c)     (c ## LL)

  173. #        define uint64_t_C(c)    (c ## ULL)

  174. #    endif /* __MINGW32__ */

  175. 

  176. #    ifdef HAVE_AV_CONFIG_H

  177. #        ifdef _DEBUG

  178. #            define DEBUG

  179. #        endif

  180. 

  181. #        define snprintf _snprintf

  182. #        define vsnprintf _vsnprintf

  183. #    endif

  184. 

  185. /* CONFIG_WIN32 end */

  186. #elif defined (CONFIG_OS2)

  187. /* OS/2 EMX */

  188. 

  189. #ifndef int64_t_C

  190. #define int64_t_C(c)     (c ## LL)

  191. #define uint64_t_C(c)    (c ## ULL)

  192. #endif

  193. 

  194. #ifdef HAVE_AV_CONFIG_H

  195. 

  196. #ifdef USE_FASTMEMCPY

  197. #include "fastmemcpy.h"

  198. #endif

  199. 

  200. #include <float.h>

  201. 

  202. #endif /* HAVE_AV_CONFIG_H */

  203. 

  204. /* CONFIG_OS2 end */

  205. #else

  206. 

  207. /* unix */

  208. 

  209. #ifndef int64_t_C

  210. #define int64_t_C(c)     (c ## LL)

  211. #define uint64_t_C(c)    (c ## ULL)

  212. #endif

  213. 

  214. #ifdef HAVE_AV_CONFIG_H

  215. 

  216. #        ifdef USE_FASTMEMCPY

  217. #            include "fastmemcpy.h"

  218. #        endif

  219. #    endif /* HAVE_AV_CONFIG_H */

  220. 

  221. #endif /* !CONFIG_WIN32 && !CONFIG_OS2 */

  222. 

  223. #ifdef HAVE_AV_CONFIG_H

  224. 

  225. #    include "bswap.h"

  226. 

  227. // Use rip-relative addressing if compiling PIC code on x86-64.

  228. #    if defined(__MINGW32__) || defined(__CYGWIN__) || \

  229.         defined(__OS2__) || (defined (__OpenBSD__) && !defined(__ELF__))

  230. #        if defined(ARCH_X86_64) && defined(PIC)

  231. #            define MANGLE(a) "_" #a"(%%rip)"

  232. #        else

  233. #            define MANGLE(a) "_" #a

  234. #        endif

  235. #    else

  236. #        if defined(ARCH_X86_64) && defined(PIC)

  237. #            define MANGLE(a) #a"(%%rip)"

  238. #        else

  239. #            define MANGLE(a) #a

  240. #        endif

  241. #    endif

  242. 

  243. /* debug stuff */

  244. 

  245. #    ifndef DEBUG

  246. #        define NDEBUG

  247. #    endif

  248. #    include <assert.h>

  249. 

  250. /* dprintf macros */

  251. #    if defined(CONFIG_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)

  252. 

  253. inline void dprintf(const char* fmt,...) {}

  254. 

  255. #    else

  256. 

  257. #        ifdef DEBUG

  258. #            define dprintf(fmt,...) av_log(NULL, AV_LOG_DEBUG, fmt, __VA_ARGS__)

  259. #        else

  260. #            define dprintf(fmt,...)

  261. #        endif

  262. 

  263. #    endif /* !CONFIG_WIN32 */

  264. 

  265. #    define av_abort()      do { av_log(NULL, AV_LOG_ERROR, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0)

  266. 

  267. //rounded divison & shift

  268. #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))

  269. /* assume b>0 */

  270. #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))

  271. #define ABS(a) ((a) >= 0 ? (a) : (-(a)))

  272. 

  273. #define FFMAX(a,b) ((a) > (b) ? (a) : (b))

  274. #define FFMIN(a,b) ((a) > (b) ? (b) : (a))

  275. 

  276. extern const uint32_t inverse[256];

  277. 

  278. #if defined(ARCH_X86) || defined(ARCH_X86_64)

  279. #    define FASTDIV(a,b) \

  280.     ({\

  281.         int ret,dmy;\

  282.         asm volatile(\

  283.             "mull %3"\

  284.             :"=d"(ret),"=a"(dmy)\

  285.             :"1"(a),"g"(inverse[b])\

  286.             );\

  287.         ret;\

  288.     })

  289. #elif defined(CONFIG_FASTDIV)

  290. #    define FASTDIV(a,b)   ((uint32_t)((((uint64_t)a)*inverse[b])>>32))

  291. #else

  292. #    define FASTDIV(a,b)   ((a)/(b))

  293. #endif

  294.  

  295. #if defined(ARCH_X86) || defined(ARCH_X86_64)

  296. // avoid +32 for shift optimization (gcc should do that ...)

  297. static inline  int32_t NEG_SSR32( int32_t a, int8_t s){

  298.     asm ("sarl %1, %0\n\t"

  299.          : "+r" (a)

  300.          : "ic" ((uint8_t)(-s))

  301.     );

  302.     return a;

  303. }

  304. static inline uint32_t NEG_USR32(uint32_t a, int8_t s){

  305.     asm ("shrl %1, %0\n\t"

  306.          : "+r" (a)

  307.          : "ic" ((uint8_t)(-s))

  308.     );

  309.     return a;

  310. }

  311. #else

  312. #    define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))

  313. #    define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))

  314. #endif

  315. 

  316. /* bit output */

  317. 

  318. /* buf and buf_end must be present and used by every alternative writer. */

  319. typedef struct PutBitContext {

  320. #ifdef ALT_BITSTREAM_WRITER

  321.     uint8_t *buf, *buf_end;

  322.     int index;

  323. #else

  324.     uint32_t bit_buf;

  325.     int bit_left;

  326.     uint8_t *buf, *buf_ptr, *buf_end;

  327. #endif

  328. } PutBitContext;

  329. 

  330. static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)

  331. {

  332.     s->buf = buffer;

  333.     s->buf_end = s->buf + buffer_size;

  334. #ifdef ALT_BITSTREAM_WRITER

  335.     s->index=0;

  336.     ((uint32_t*)(s->buf))[0]=0;

  337. //    memset(buffer, 0, buffer_size);

  338. #else

  339.     s->buf_ptr = s->buf;

  340.     s->bit_left=32;

  341.     s->bit_buf=0;

  342. #endif

  343. }

  344. 

  345. /* return the number of bits output */

  346. static inline int put_bits_count(PutBitContext *s)

  347. {

  348. #ifdef ALT_BITSTREAM_WRITER

  349.     return s->index;

  350. #else

  351.     return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;

  352. #endif

  353. }

  354. 

  355. /* pad the end of the output stream with zeros */

  356. static inline void flush_put_bits(PutBitContext *s)

  357. {

  358. #ifdef ALT_BITSTREAM_WRITER

  359.     align_put_bits(s);

  360. #else

  361.     s->bit_buf<<= s->bit_left;

  362.     while (s->bit_left < 32) {

  363.         /* XXX: should test end of buffer */

  364.         *s->buf_ptr++=s->bit_buf >> 24;

  365.         s->bit_buf<<=8;

  366.         s->bit_left+=8;

  367.     }

  368.     s->bit_left=32;

  369.     s->bit_buf=0;

  370. #endif

  371. }

  372. 

  373. void align_put_bits(PutBitContext *s);

  374. void put_string(PutBitContext * pbc, char *s, int put_zero);

  375. 

  376. /* bit input */

  377. /* buffer, buffer_end and size_in_bits must be present and used by every reader */

  378. typedef struct GetBitContext {

  379.     const uint8_t *buffer, *buffer_end;

  380. #ifdef ALT_BITSTREAM_READER

  381.     int index;

  382. #elif defined LIBMPEG2_BITSTREAM_READER

  383.     uint8_t *buffer_ptr;

  384.     uint32_t cache;

  385.     int bit_count;

  386. #elif defined A32_BITSTREAM_READER

  387.     uint32_t *buffer_ptr;

  388.     uint32_t cache0;

  389.     uint32_t cache1;

  390.     int bit_count;

  391. #endif

  392.     int size_in_bits;

  393. } GetBitContext;

  394. 

  395. #define VLC_TYPE int16_t

  396. 

  397. typedef struct VLC {

  398.     int bits;

  399.     VLC_TYPE (*table)[2]; ///< code, bits

  400.     int table_size, table_allocated;

  401. } VLC;

  402. 

  403. typedef struct RL_VLC_ELEM {

  404.     int16_t level;

  405.     int8_t len;

  406.     uint8_t run;

  407. } RL_VLC_ELEM;

  408. 

  409. #ifdef ARCH_SPARC

  410. #define UNALIGNED_STORES_ARE_BAD

  411. #endif

  412. 

  413. /* used to avoid missaligned exceptions on some archs (alpha, ...) */

  414. #if defined(ARCH_X86) || defined(ARCH_X86_64)

  415. #    define unaligned32(a) (*(const uint32_t*)(a))

  416. #else

  417. #    ifdef __GNUC__

  418. static inline uint32_t unaligned32(const void *v) {

  419.     struct Unaligned {

  420. 	uint32_t i;

  421.     } __attribute__((packed));

  422. 

  423.     return ((const struct Unaligned *) v)->i;

  424. }

  425. #    elif defined(__DECC)

  426. static inline uint32_t unaligned32(const void *v) {

  427.     return *(const __unaligned uint32_t *) v;

  428. }

  429. #    else

  430. static inline uint32_t unaligned32(const void *v) {

  431.     return *(const uint32_t *) v;

  432. }

  433. #    endif

  434. #endif //!ARCH_X86

  435. 

  436. #ifndef ALT_BITSTREAM_WRITER

  437. static inline void put_bits(PutBitContext *s, int n, unsigned int value)

  438. {

  439.     unsigned int bit_buf;

  440.     int bit_left;

  441. 

  442. #ifdef STATS

  443.     st_out_bit_counts[st_current_index] += n;

  444. #endif

  445.     //    printf("put_bits=%d %x\n", n, value);

  446.     assert(n == 32 || value < (1U << n));

  447.     

  448.     bit_buf = s->bit_buf;

  449.     bit_left = s->bit_left;

  450. 

  451.     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);

  452.     /* XXX: optimize */

  453.     if (n < bit_left) {

  454.         bit_buf = (bit_buf<<n) | value;

  455.         bit_left-=n;

  456.     } else {

  457. 	bit_buf<<=bit_left;

  458.         bit_buf |= value >> (n - bit_left);

  459. #ifdef UNALIGNED_STORES_ARE_BAD

  460.         if (3 & (intptr_t) s->buf_ptr) {

  461.             s->buf_ptr[0] = bit_buf >> 24;

  462.             s->buf_ptr[1] = bit_buf >> 16;

  463.             s->buf_ptr[2] = bit_buf >>  8;

  464.             s->buf_ptr[3] = bit_buf      ;

  465.         } else

  466. #endif

  467.         *(uint32_t *)s->buf_ptr = be2me_32(bit_buf);

  468.         //printf("bitbuf = %08x\n", bit_buf);

  469.         s->buf_ptr+=4;

  470. 	bit_left+=32 - n;

  471.         bit_buf = value;

  472.     }

  473. 

  474.     s->bit_buf = bit_buf;

  475.     s->bit_left = bit_left;

  476. }

  477. #endif

  478. 

  479. 

  480. #ifdef ALT_BITSTREAM_WRITER

  481. static inline void put_bits(PutBitContext *s, int n, unsigned int value)

  482. {

  483. #    ifdef ALIGNED_BITSTREAM_WRITER

  484. #        if defined(ARCH_X86) || defined(ARCH_X86_64)

  485.     asm volatile(

  486. 	"movl %0, %%ecx			\n\t"

  487. 	"xorl %%eax, %%eax		\n\t"

  488. 	"shrdl %%cl, %1, %%eax		\n\t"

  489. 	"shrl %%cl, %1			\n\t"

  490. 	"movl %0, %%ecx			\n\t"

  491. 	"shrl $3, %%ecx			\n\t"

  492. 	"andl $0xFFFFFFFC, %%ecx	\n\t"

  493. 	"bswapl %1			\n\t"

  494. 	"orl %1, (%2, %%ecx)		\n\t"

  495. 	"bswapl %%eax			\n\t"

  496. 	"addl %3, %0			\n\t"

  497. 	"movl %%eax, 4(%2, %%ecx)	\n\t"

  498. 	: "=&r" (s->index), "=&r" (value)

  499. 	: "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))

  500. 	: "%eax", "%ecx"

  501.     );

  502. #        else

  503.     int index= s->index;

  504.     uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);

  505.     

  506.     value<<= 32-n; 

  507.     

  508.     ptr[0] |= be2me_32(value>>(index&31));

  509.     ptr[1]  = be2me_32(value<<(32-(index&31)));

  510. //if(n>24) printf("%d %d\n", n, value);

  511.     index+= n;

  512.     s->index= index;

  513. #        endif

  514. #    else //ALIGNED_BITSTREAM_WRITER

  515. #        if defined(ARCH_X86) || defined(ARCH_X86_64)

  516.     asm volatile(

  517. 	"movl $7, %%ecx			\n\t"

  518. 	"andl %0, %%ecx			\n\t"

  519. 	"addl %3, %%ecx			\n\t"

  520. 	"negl %%ecx			\n\t"

  521. 	"shll %%cl, %1			\n\t"

  522. 	"bswapl %1			\n\t"

  523. 	"movl %0, %%ecx			\n\t"

  524. 	"shrl $3, %%ecx			\n\t"

  525. 	"orl %1, (%%ecx, %2)		\n\t"

  526. 	"addl %3, %0			\n\t"

  527. 	"movl $0, 4(%%ecx, %2)		\n\t"

  528. 	: "=&r" (s->index), "=&r" (value)

  529. 	: "r" (s->buf), "r" (n), "0" (s->index), "1" (value)

  530. 	: "%ecx"

  531.     );

  532. #        else

  533.     int index= s->index;

  534.     uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));

  535.     

  536.     ptr[0] |= be2me_32(value<<(32-n-(index&7) ));

  537.     ptr[1] = 0;

  538. //if(n>24) printf("%d %d\n", n, value);

  539.     index+= n;

  540.     s->index= index;

  541. #        endif

  542. #    endif //!ALIGNED_BITSTREAM_WRITER

  543. }

  544. #endif

  545. 

  546. 

  547. static inline uint8_t* pbBufPtr(PutBitContext *s)

  548. {

  549. #ifdef ALT_BITSTREAM_WRITER

  550. 	return s->buf + (s->index>>3);

  551. #else

  552. 	return s->buf_ptr;

  553. #endif

  554. }

  555. 

  556. /**

  557.  *

  558.  * PutBitContext must be flushed & aligned to a byte boundary before calling this.

  559.  */

  560. static inline void skip_put_bytes(PutBitContext *s, int n){

  561.         assert((put_bits_count(s)&7)==0);

  562. #ifdef ALT_BITSTREAM_WRITER

  563.         FIXME may need some cleaning of the buffer

  564. 	s->index += n<<3;

  565. #else

  566.         assert(s->bit_left==32);

  567. 	s->buf_ptr += n;

  568. #endif    

  569. }

  570. 

  571. /**

  572.  * Changes the end of the buffer.

  573.  */

  574. static inline void set_put_bits_buffer_size(PutBitContext *s, int size){

  575.     s->buf_end= s->buf + size;

  576. }

  577. 

  578. /* Bitstream reader API docs:

  579. name

  580.     abritary name which is used as prefix for the internal variables

  581. 

  582. gb

  583.     getbitcontext

  584. 

  585. OPEN_READER(name, gb)

  586.     loads gb into local variables

  587. 

  588. CLOSE_READER(name, gb)

  589.     stores local vars in gb

  590. 

  591. UPDATE_CACHE(name, gb)

  592.     refills the internal cache from the bitstream

  593.     after this call at least MIN_CACHE_BITS will be available,

  594. 

  595. GET_CACHE(name, gb)

  596.     will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit)

  597. 

  598. SHOW_UBITS(name, gb, num)

  599.     will return the nest num bits

  600. 

  601. SHOW_SBITS(name, gb, num)

  602.     will return the nest num bits and do sign extension

  603. 

  604. SKIP_BITS(name, gb, num)

  605.     will skip over the next num bits

  606.     note, this is equinvalent to SKIP_CACHE; SKIP_COUNTER

  607. 

  608. SKIP_CACHE(name, gb, num)

  609.     will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER)

  610. 

  611. SKIP_COUNTER(name, gb, num)

  612.     will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS)

  613. 

  614. LAST_SKIP_CACHE(name, gb, num)

  615.     will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing

  616. 

  617. LAST_SKIP_BITS(name, gb, num)

  618.     is equinvalent to SKIP_LAST_CACHE; SKIP_COUNTER

  619. 

  620. for examples see get_bits, show_bits, skip_bits, get_vlc

  621. */

  622. 

  623. static inline int unaligned32_be(const void *v)

  624. {

  625. #ifdef CONFIG_ALIGN

  626. 	const uint8_t *p=v;

  627. 	return (((p[0]<<8) | p[1])<<16) | (p[2]<<8) | (p[3]);

  628. #else

  629. 	return be2me_32( unaligned32(v)); //original

  630. #endif

  631. }

  632. 

  633. #ifdef ALT_BITSTREAM_READER

  634. #   define MIN_CACHE_BITS 25

  635. 

  636. #   define OPEN_READER(name, gb)\

  637.         int name##_index= (gb)->index;\

  638.         int name##_cache= 0;\

  639. 

  640. #   define CLOSE_READER(name, gb)\

  641.         (gb)->index= name##_index;\

  642. 

  643. #   define UPDATE_CACHE(name, gb)\

  644.         name##_cache= unaligned32_be( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\

  645. 

  646. #   define SKIP_CACHE(name, gb, num)\

  647.         name##_cache <<= (num);\

  648. 

  649. // FIXME name?

  650. #   define SKIP_COUNTER(name, gb, num)\

  651.         name##_index += (num);\

  652. 

  653. #   define SKIP_BITS(name, gb, num)\

  654.         {\

  655.             SKIP_CACHE(name, gb, num)\

  656.             SKIP_COUNTER(name, gb, num)\

  657.         }\

  658. 

  659. #   define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)

  660. #   define LAST_SKIP_CACHE(name, gb, num) ;

  661. 

  662. #   define SHOW_UBITS(name, gb, num)\

  663.         NEG_USR32(name##_cache, num)

  664. 

  665. #   define SHOW_SBITS(name, gb, num)\

  666.         NEG_SSR32(name##_cache, num)

  667. 

  668. #   define GET_CACHE(name, gb)\

  669.         ((uint32_t)name##_cache)

  670. 

  671. static inline int get_bits_count(GetBitContext *s){

  672.     return s->index;

  673. }

  674. #elif defined LIBMPEG2_BITSTREAM_READER

  675. //libmpeg2 like reader

  676. 

  677. #   define MIN_CACHE_BITS 17

  678. 

  679. #   define OPEN_READER(name, gb)\

  680.         int name##_bit_count=(gb)->bit_count;\

  681.         int name##_cache= (gb)->cache;\

  682.         uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\

  683. 

  684. #   define CLOSE_READER(name, gb)\

  685.         (gb)->bit_count= name##_bit_count;\

  686.         (gb)->cache= name##_cache;\

  687.         (gb)->buffer_ptr= name##_buffer_ptr;\

  688. 

  689. #ifdef LIBMPEG2_BITSTREAM_READER_HACK

  690. 

  691. #   define UPDATE_CACHE(name, gb)\

  692.     if(name##_bit_count >= 0){\

  693.         name##_cache+= (int)be2me_16(*(uint16_t*)name##_buffer_ptr) << name##_bit_count;\

  694.         ((uint16_t*)name##_buffer_ptr)++;\

  695.         name##_bit_count-= 16;\

  696.     }\

  697. 

  698. #else

  699. 

  700. #   define UPDATE_CACHE(name, gb)\

  701.     if(name##_bit_count >= 0){\

  702.         name##_cache+= ((name##_buffer_ptr[0]<<8) + name##_buffer_ptr[1]) << name##_bit_count;\

  703.         name##_buffer_ptr+=2;\

  704.         name##_bit_count-= 16;\

  705.     }\

  706. 

  707. #endif

  708. 

  709. #   define SKIP_CACHE(name, gb, num)\

  710.         name##_cache <<= (num);\

  711. 

  712. #   define SKIP_COUNTER(name, gb, num)\

  713.         name##_bit_count += (num);\

  714. 

  715. #   define SKIP_BITS(name, gb, num)\

  716.         {\

  717.             SKIP_CACHE(name, gb, num)\

  718.             SKIP_COUNTER(name, gb, num)\

  719.         }\

  720. 

  721. #   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)

  722. #   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)

  723. 

  724. #   define SHOW_UBITS(name, gb, num)\

  725.         NEG_USR32(name##_cache, num)

  726. 

  727. #   define SHOW_SBITS(name, gb, num)\

  728.         NEG_SSR32(name##_cache, num)

  729. 

  730. #   define GET_CACHE(name, gb)\

  731.         ((uint32_t)name##_cache)

  732. 

  733. static inline int get_bits_count(GetBitContext *s){

  734.     return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count;

  735. }

  736. 

  737. #elif defined A32_BITSTREAM_READER

  738. 

  739. #   define MIN_CACHE_BITS 32

  740. 

  741. #   define OPEN_READER(name, gb)\

  742.         int name##_bit_count=(gb)->bit_count;\

  743.         uint32_t name##_cache0= (gb)->cache0;\

  744.         uint32_t name##_cache1= (gb)->cache1;\

  745.         uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\

  746. 

  747. #   define CLOSE_READER(name, gb)\

  748.         (gb)->bit_count= name##_bit_count;\

  749.         (gb)->cache0= name##_cache0;\

  750.         (gb)->cache1= name##_cache1;\

  751.         (gb)->buffer_ptr= name##_buffer_ptr;\

  752. 

  753. #   define UPDATE_CACHE(name, gb)\

  754.     if(name##_bit_count > 0){\

  755.         const uint32_t next= be2me_32( *name##_buffer_ptr );\

  756.         name##_cache0 |= NEG_USR32(next,name##_bit_count);\

  757.         name##_cache1 |= next<<name##_bit_count;\

  758.         name##_buffer_ptr++;\

  759.         name##_bit_count-= 32;\

  760.     }\

  761. 

  762. #if defined(ARCH_X86) || defined(ARCH_X86_64)

  763. #   define SKIP_CACHE(name, gb, num)\

  764.         asm(\

  765.             "shldl %2, %1, %0		\n\t"\

  766.             "shll %2, %1		\n\t"\

  767.             : "+r" (name##_cache0), "+r" (name##_cache1)\

  768.             : "Ic" ((uint8_t)num)\

  769.            );

  770. #else

  771. #   define SKIP_CACHE(name, gb, num)\

  772.         name##_cache0 <<= (num);\

  773.         name##_cache0 |= NEG_USR32(name##_cache1,num);\

  774.         name##_cache1 <<= (num);

  775. #endif

  776. 

  777. #   define SKIP_COUNTER(name, gb, num)\

  778.         name##_bit_count += (num);\

  779. 

  780. #   define SKIP_BITS(name, gb, num)\

  781.         {\

  782.             SKIP_CACHE(name, gb, num)\

  783.             SKIP_COUNTER(name, gb, num)\

  784.         }\

  785. 

  786. #   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)

  787. #   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)

  788. 

  789. #   define SHOW_UBITS(name, gb, num)\

  790.         NEG_USR32(name##_cache0, num)

  791. 

  792. #   define SHOW_SBITS(name, gb, num)\

  793.         NEG_SSR32(name##_cache0, num)

  794. 

  795. #   define GET_CACHE(name, gb)\

  796.         (name##_cache0)

  797. 

  798. static inline int get_bits_count(GetBitContext *s){

  799.     return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count;

  800. }

  801. 

  802. #endif

  803. 

  804. /**

  805.  * read mpeg1 dc style vlc (sign bit + mantisse with no MSB).

  806.  * if MSB not set it is negative 

  807.  * @param n length in bits

  808.  * @author BERO  

  809.  */

  810. static inline int get_xbits(GetBitContext *s, int n){

  811.     register int tmp;

  812.     register int32_t cache;

  813.     OPEN_READER(re, s)

  814.     UPDATE_CACHE(re, s)

  815.     cache = GET_CACHE(re,s);

  816.     if ((int32_t)cache<0) { //MSB=1

  817.         tmp = NEG_USR32(cache,n);

  818.     } else {

  819.     //   tmp = (-1<<n) | NEG_USR32(cache,n) + 1; mpeg12.c algo

  820.     //   tmp = - (NEG_USR32(cache,n) ^ ((1 << n) - 1)); h263.c algo

  821.         tmp = - NEG_USR32(~cache,n);

  822.     }

  823.     LAST_SKIP_BITS(re, s, n)

  824.     CLOSE_READER(re, s)

  825.     return tmp;

  826. }

  827. 

  828. static inline int get_sbits(GetBitContext *s, int n){

  829.     register int tmp;

  830.     OPEN_READER(re, s)

  831.     UPDATE_CACHE(re, s)

  832.     tmp= SHOW_SBITS(re, s, n);

  833.     LAST_SKIP_BITS(re, s, n)

  834.     CLOSE_READER(re, s)

  835.     return tmp;

  836. }

  837. 

  838. /**

  839.  * reads 0-17 bits.

  840.  * Note, the alt bitstream reader can read upto 25 bits, but the libmpeg2 reader cant

  841.  */

  842. static inline unsigned int get_bits(GetBitContext *s, int n){

  843.     register int tmp;

  844.     OPEN_READER(re, s)

  845.     UPDATE_CACHE(re, s)

  846.     tmp= SHOW_UBITS(re, s, n);

  847.     LAST_SKIP_BITS(re, s, n)

  848.     CLOSE_READER(re, s)

  849.     return tmp;

  850. }

  851. 

  852. unsigned int get_bits_long(GetBitContext *s, int n);

  853. 

  854. /**

  855.  * shows 0-17 bits.

  856.  * Note, the alt bitstream reader can read upto 25 bits, but the libmpeg2 reader cant

  857.  */

  858. static inline unsigned int show_bits(GetBitContext *s, int n){

  859.     register int tmp;

  860.     OPEN_READER(re, s)

  861.     UPDATE_CACHE(re, s)

  862.     tmp= SHOW_UBITS(re, s, n);

  863. //    CLOSE_READER(re, s)

  864.     return tmp;

  865. }

  866. 

  867. unsigned int show_bits_long(GetBitContext *s, int n);

  868. 

  869. static inline void skip_bits(GetBitContext *s, int n){

  870.  //Note gcc seems to optimize this to s->index+=n for the ALT_READER :))

  871.     OPEN_READER(re, s)

  872.     UPDATE_CACHE(re, s)

  873.     LAST_SKIP_BITS(re, s, n)

  874.     CLOSE_READER(re, s)

  875. }

  876. 

  877. static inline unsigned int get_bits1(GetBitContext *s){

  878. #ifdef ALT_BITSTREAM_READER

  879.     int index= s->index;

  880.     uint8_t result= s->buffer[ index>>3 ];

  881.     result<<= (index&0x07);

  882.     result>>= 8 - 1;

  883.     index++;

  884.     s->index= index;

  885. 

  886.     return result;

  887. #else

  888.     return get_bits(s, 1);

  889. #endif

  890. }

  891. 

  892. static inline unsigned int show_bits1(GetBitContext *s){

  893.     return show_bits(s, 1);

  894. }

  895. 

  896. static inline void skip_bits1(GetBitContext *s){

  897.     skip_bits(s, 1);

  898. }

  899. 

  900. /**

  901.  * init GetBitContext.

  902.  * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes larger then the actual read bits

  903.  * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end

  904.  * @param bit_size the size of the buffer in bits

  905.  */

  906. static inline void init_get_bits(GetBitContext *s,

  907.                    const uint8_t *buffer, int bit_size)

  908. {

  909.     const int buffer_size= (bit_size+7)>>3;

  910. 

  911.     s->buffer= buffer;

  912.     s->size_in_bits= bit_size;

  913.     s->buffer_end= buffer + buffer_size;

  914. #ifdef ALT_BITSTREAM_READER

  915.     s->index=0;

  916. #elif defined LIBMPEG2_BITSTREAM_READER

  917. #ifdef LIBMPEG2_BITSTREAM_READER_HACK

  918.   if ((int)buffer&1) {

  919.      /* word alignment */

  920.     s->cache = (*buffer++)<<24;

  921.     s->buffer_ptr = buffer;

  922.     s->bit_count = 16-8;

  923.   } else

  924. #endif

  925.   {

  926.     s->buffer_ptr = buffer;

  927.     s->bit_count = 16;

  928.     s->cache = 0;

  929.   }

  930. #elif defined A32_BITSTREAM_READER

  931.     s->buffer_ptr = (uint32_t*)buffer;

  932.     s->bit_count = 32;

  933.     s->cache0 = 0;

  934.     s->cache1 = 0;

  935. #endif

  936.     {

  937.         OPEN_READER(re, s)

  938.         UPDATE_CACHE(re, s)

  939.         UPDATE_CACHE(re, s)

  940.         CLOSE_READER(re, s)

  941.     }

  942. #ifdef A32_BITSTREAM_READER

  943.     s->cache1 = 0;

  944. #endif

  945. }

  946. 

  947. int check_marker(GetBitContext *s, const char *msg);

  948. void align_get_bits(GetBitContext *s);

  949. int init_vlc(VLC *vlc, int nb_bits, int nb_codes,

  950.              const void *bits, int bits_wrap, int bits_size,

  951.              const void *codes, int codes_wrap, int codes_size,

  952.              int use_static);

  953. void free_vlc(VLC *vlc);

  954. 

  955. /**

  956.  *

  957.  * if the vlc code is invalid and max_depth=1 than no bits will be removed

  958.  * if the vlc code is invalid and max_depth>1 than the number of bits removed

  959.  * is undefined

  960.  */

  961. #define GET_VLC(code, name, gb, table, bits, max_depth)\

  962. {\

  963.     int n, index, nb_bits;\

  964. \

  965.     index= SHOW_UBITS(name, gb, bits);\

  966.     code = table[index][0];\

  967.     n    = table[index][1];\

  968. \

  969.     if(max_depth > 1 && n < 0){\

  970.         LAST_SKIP_BITS(name, gb, bits)\

  971.         UPDATE_CACHE(name, gb)\

  972. \

  973.         nb_bits = -n;\

  974. \

  975.         index= SHOW_UBITS(name, gb, nb_bits) + code;\

  976.         code = table[index][0];\

  977.         n    = table[index][1];\

  978.         if(max_depth > 2 && n < 0){\

  979.             LAST_SKIP_BITS(name, gb, nb_bits)\

  980.             UPDATE_CACHE(name, gb)\

  981. \

  982.             nb_bits = -n;\

  983. \

  984.             index= SHOW_UBITS(name, gb, nb_bits) + code;\

  985.             code = table[index][0];\

  986.             n    = table[index][1];\

  987.         }\

  988.     }\

  989.     SKIP_BITS(name, gb, n)\

  990. }

  991. 

  992. #define GET_RL_VLC(level, run, name, gb, table, bits, max_depth)\

  993. {\

  994.     int n, index, nb_bits;\

  995. \

  996.     index= SHOW_UBITS(name, gb, bits);\

  997.     level = table[index].level;\

  998.     n     = table[index].len;\

  999. \

  1000.     if(max_depth > 1 && n < 0){\

  1001.         LAST_SKIP_BITS(name, gb, bits)\

  1002.         UPDATE_CACHE(name, gb)\

  1003. \

  1004.         nb_bits = -n;\

  1005. \

  1006.         index= SHOW_UBITS(name, gb, nb_bits) + level;\

  1007.         level = table[index].level;\

  1008.         n     = table[index].len;\

  1009.     }\

  1010.     run= table[index].run;\

  1011.     SKIP_BITS(name, gb, n)\

  1012. }

  1013. 

  1014. // deprecated, dont use get_vlc for new code, use get_vlc2 instead or use GET_VLC directly

  1015. static inline int get_vlc(GetBitContext *s, VLC *vlc)

  1016. {

  1017.     int code;

  1018.     VLC_TYPE (*table)[2]= vlc->table;

  1019.     

  1020.     OPEN_READER(re, s)

  1021.     UPDATE_CACHE(re, s)

  1022. 

  1023.     GET_VLC(code, re, s, table, vlc->bits, 3)    

  1024. 

  1025.     CLOSE_READER(re, s)

  1026.     return code;

  1027. }

  1028. 

  1029. /**

  1030.  * parses a vlc code, faster then get_vlc()

  1031.  * @param bits is the number of bits which will be read at once, must be 

  1032.  *             identical to nb_bits in init_vlc()

  1033.  * @param max_depth is the number of times bits bits must be readed to completly

  1034.  *                  read the longest vlc code 

  1035.  *                  = (max_vlc_length + bits - 1) / bits

  1036.  */

  1037. static always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],

  1038.                                   int bits, int max_depth)

  1039. {

  1040.     int code;

  1041.     

  1042.     OPEN_READER(re, s)

  1043.     UPDATE_CACHE(re, s)

  1044. 

  1045.     GET_VLC(code, re, s, table, bits, max_depth)

  1046. 

  1047.     CLOSE_READER(re, s)

  1048.     return code;

  1049. }

  1050. 

  1051. //#define TRACE

  1052. 

  1053. #ifdef TRACE

  1054. 

  1055. static inline void print_bin(int bits, int n){

  1056.     int i;

  1057.     

  1058.     for(i=n-1; i>=0; i--){

  1059.         printf("%d", (bits>>i)&1);

  1060.     }

  1061.     for(i=n; i<24; i++)

  1062.         printf(" ");

  1063. }

  1064. 

  1065. static inline int get_bits_trace(GetBitContext *s, int n, char *file, char *func, int line){

  1066.     int r= get_bits(s, n);

  1067.     

  1068.     print_bin(r, n);

  1069.     printf("%5d %2d %3d bit @%5d in %s %s:%d\n", r, n, r, get_bits_count(s)-n, file, func, line);

  1070.     return r;

  1071. }

  1072. static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, char *func, int line){

  1073.     int show= show_bits(s, 24);

  1074.     int pos= get_bits_count(s);

  1075.     int r= get_vlc2(s, table, bits, max_depth);

  1076.     int len= get_bits_count(s) - pos;

  1077.     int bits2= show>>(24-len);

  1078.     

  1079.     print_bin(bits2, len);

  1080.     

  1081.     printf("%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line);

  1082.     return r;

  1083. }

  1084. static inline int get_xbits_trace(GetBitContext *s, int n, char *file, char *func, int line){

  1085.     int show= show_bits(s, n);

  1086.     int r= get_xbits(s, n);

  1087.     

  1088.     print_bin(show, n);

  1089.     printf("%5d %2d %3d xbt @%5d in %s %s:%d\n", show, n, r, get_bits_count(s)-n, file, func, line);

  1090.     return r;

  1091. }

  1092. 

  1093. #define get_bits(s, n)  get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  1094. #define get_bits1(s)    get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  1095. #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  1096. #define get_vlc(s, vlc)            get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  1097. #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  1098. 

  1099. #define tprintf(...) av_log(NULL, AV_LOG_DEBUG, __VA_ARGS__)

  1100. 

  1101. #else //TRACE

  1102. #define tprintf(...) {}

  1103. #endif

  1104. 

  1105. /* define it to include statistics code (useful only for optimizing

  1106.    codec efficiency */

  1107. //#define STATS

  1108. 

  1109. #ifdef STATS

  1110. 

  1111. enum {

  1112.     ST_UNKNOWN,

  1113.     ST_DC,

  1114.     ST_INTRA_AC,

  1115.     ST_INTER_AC,

  1116.     ST_INTRA_MB,

  1117.     ST_INTER_MB,

  1118.     ST_MV,

  1119.     ST_NB,

  1120. };

  1121. 

  1122. extern int st_current_index;

  1123. extern unsigned int st_bit_counts[ST_NB];

  1124. extern unsigned int st_out_bit_counts[ST_NB];

  1125. 

  1126. void print_stats(void);

  1127. #endif

  1128. 

  1129. /* misc math functions */

  1130. extern const uint8_t ff_log2_tab[256];

  1131. 

  1132. static inline int av_log2(unsigned int v)

  1133. {

  1134.     int n;

  1135. 

  1136.     n = 0;

  1137.     if (v & 0xffff0000) {

  1138.         v >>= 16;

  1139.         n += 16;

  1140.     }

  1141.     if (v & 0xff00) {

  1142.         v >>= 8;

  1143.         n += 8;

  1144.     }

  1145.     n += ff_log2_tab[v];

  1146. 

  1147.     return n;

  1148. }

  1149. 

  1150. static inline int av_log2_16bit(unsigned int v)

  1151. {

  1152.     int n;

  1153. 

  1154.     n = 0;

  1155.     if (v & 0xff00) {

  1156.         v >>= 8;

  1157.         n += 8;

  1158.     }

  1159.     n += ff_log2_tab[v];

  1160. 

  1161.     return n;

  1162. }

  1163. 

  1164. /* median of 3 */

  1165. static inline int mid_pred(int a, int b, int c)

  1166. {

  1167. #if 0

  1168.     int t= (a-b)&((a-b)>>31);

  1169.     a-=t;

  1170.     b+=t;

  1171.     b-= (b-c)&((b-c)>>31);

  1172.     b+= (a-b)&((a-b)>>31);

  1173. 

  1174.     return b;

  1175. #else

  1176.     if(a>b){

  1177.         if(c>b){

  1178.             if(c>a) b=a;

  1179.             else    b=c;

  1180.         }

  1181.     }else{

  1182.         if(b>c){

  1183.             if(c>a) b=c;

  1184.             else    b=a;

  1185.         }

  1186.     }

  1187.     return b;

  1188. #endif

  1189. }

  1190. 

  1191. static inline int clip(int a, int amin, int amax)

  1192. {

  1193.     if (a < amin)

  1194.         return amin;

  1195.     else if (a > amax)

  1196.         return amax;

  1197.     else

  1198.         return a;

  1199. }

  1200. 

  1201. static inline int clip_uint8(int a)

  1202. {

  1203.     if (a&(~255)) return (-a)>>31;

  1204.     else          return a;

  1205. }

  1206. 

  1207. /* math */

  1208. extern const uint8_t ff_sqrt_tab[128];

  1209. 

  1210. int64_t ff_gcd(int64_t a, int64_t b);

  1211. 

  1212. static inline int ff_sqrt(int a)

  1213. {

  1214.     int ret=0;

  1215.     int s;

  1216.     int ret_sq=0;

  1217.     

  1218.     if(a<128) return ff_sqrt_tab[a];

  1219.     

  1220.     for(s=15; s>=0; s--){

  1221.         int b= ret_sq + (1<<(s*2)) + (ret<<s)*2;

  1222.         if(b<=a){

  1223.             ret_sq=b;

  1224.             ret+= 1<<s;

  1225.         }

  1226.     }

  1227.     return ret;

  1228. }

  1229. 

  1230. /**

  1231.  * converts fourcc string to int

  1232.  */

  1233. static inline int ff_get_fourcc(const char *s){

  1234.     assert( strlen(s)==4 );

  1235. 

  1236.     return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);

  1237. }

  1238. 

  1239. #define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))

  1240. #define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))

  1241. 

  1242. 

  1243. #if defined(ARCH_X86) || defined(ARCH_X86_64)

  1244. #define MASK_ABS(mask, level)\

  1245.             asm volatile(\

  1246. 		"cdq			\n\t"\

  1247. 		"xorl %1, %0		\n\t"\

  1248. 		"subl %1, %0		\n\t"\

  1249. 		: "+a" (level), "=&d" (mask)\

  1250. 	    );

  1251. #else

  1252. #define MASK_ABS(mask, level)\

  1253.             mask= level>>31;\

  1254.             level= (level^mask)-mask;

  1255. #endif

  1256. 

  1257. 

  1258. #if __CPU__ >= 686 && !defined(RUNTIME_CPUDETECT)

  1259. #define COPY3_IF_LT(x,y,a,b,c,d)\

  1260. asm volatile (\

  1261.     "cmpl %0, %3	\n\t"\

  1262.     "cmovl %3, %0	\n\t"\

  1263.     "cmovl %4, %1	\n\t"\

  1264.     "cmovl %5, %2	\n\t"\

  1265.     : "+r" (x), "+r" (a), "+r" (c)\

  1266.     : "r" (y), "r" (b), "r" (d)\

  1267. );

  1268. #else

  1269. #define COPY3_IF_LT(x,y,a,b,c,d)\

  1270. if((y)<(x)){\

  1271.      (x)=(y);\

  1272.      (a)=(b);\

  1273.      (c)=(d);\

  1274. }

  1275. #endif

  1276. 

  1277. #if defined(ARCH_X86) || defined(ARCH_X86_64)

  1278. static inline long long rdtsc(void)

  1279. {

  1280. 	long long l;

  1281. 	asm volatile(	"rdtsc\n\t"

  1282. 		: "=A" (l)

  1283. 	);

  1284. 	return l;

  1285. }

  1286. 

  1287. #define START_TIMER \

  1288. uint64_t tend;\

  1289. uint64_t tstart= rdtsc();\

  1290. 

  1291. #define STOP_TIMER(id) \

  1292. tend= rdtsc();\

  1293. {\

  1294.   static uint64_t tsum=0;\

  1295.   static int tcount=0;\

  1296.   static int tskip_count=0;\

  1297.   if(tcount<2 || tend - tstart < 8*tsum/tcount){\

  1298.       tsum+= tend - tstart;\

  1299.       tcount++;\

  1300.   }else\

  1301.       tskip_count++;\

  1302.   if(256*256*256*64%(tcount+tskip_count)==0){\

  1303.       av_log(NULL, AV_LOG_DEBUG, "%Ld dezicycles in %s, %d runs, %d skips\n", tsum*10/tcount, id, tcount, tskip_count);\

  1304.   }\

  1305. }

  1306. #else

  1307. #define START_TIMER 

  1308. #define STOP_TIMER(id) {}

  1309. #endif

  1310. 

  1311. #define CLAMP_TO_8BIT(d) ((d > 0xff) ? 0xff : (d < 0) ? 0 : d)

  1312. 

  1313. /* avoid usage of various functions */

  1314. #define malloc please_use_av_malloc

  1315. #define free please_use_av_free

  1316. #define realloc please_use_av_realloc

  1317. #define time time_is_forbidden_due_to_security_issues

  1318. #define rand rand_is_forbidden_due_to_state_trashing

  1319. #define srand srand_is_forbidden_due_to_state_trashing

  1320. #if !(defined(LIBAVFORMAT_BUILD) || defined(_FRAMEHOOK_H))

  1321. #define printf please_use_av_log

  1322. #define fprintf please_use_av_log

  1323. #endif

  1324. 

  1325. #define CHECKED_ALLOCZ(p, size)\

  1326. {\

  1327.     p= av_mallocz(size);\

  1328.     if(p==NULL && (size)!=0){\

  1329.         perror("malloc");\

  1330.         goto fail;\

  1331.     }\

  1332. }

  1333. 

  1334. #endif /* HAVE_AV_CONFIG_H */

  1335. 

  1336. #endif /* COMMON_H */