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.
2101 Commits
32 Branches
2.4GB
Tree: 05858889b2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '05858889b2'
${ noResults }
FFmpeg/libavcodec/common.h

1069 lines
26KB
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. #ifdef HAVE_AV_CONFIG_H

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

  23. #    include "config.h"

  24. 

  25. #    include <stdlib.h>

  26. #    include <stdio.h>

  27. #    include <string.h>

  28. #    ifndef __BEOS__

  29. #        include <errno.h>

  30. #    else

  31. #        include "berrno.h"

  32. #    endif

  33. #    include <math.h>

  34. 

  35. #    ifndef ENODATA

  36. #        define ENODATA  61

  37. #    endif

  38. 

  39. #ifndef M_PI

  40. #define M_PI    3.14159265358979323846

  41. #endif

  42. 

  43. #include <stddef.h>

  44. #ifndef offsetof

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

  46. #endif

  47. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  61. #define AVOPTION_END() AVOPTION_SUB(NULL)

  62. 

  63. struct AVOption;

  64. #ifdef HAVE_MMX

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

  66. #else

  67. extern const struct AVOption avoptions_common[3];

  68. #endif

  69. extern const struct AVOption avoptions_workaround_bug[11];

  70. 

  71. #endif /* HAVE_AV_CONFIG_H */

  72. 

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

  74. #ifndef restrict

  75. #    define restrict

  76. #endif

  77. 

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

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

  80. #else

  81. #    define always_inline inline

  82. #endif

  83. 

  84. #ifdef CONFIG_WIN32

  85. 

  86. /* windows */

  87. 

  88. typedef unsigned short uint16_t;

  89. typedef signed short int16_t;

  90. typedef unsigned char uint8_t;

  91. typedef unsigned int uint32_t;

  92. typedef unsigned __int64 uint64_t;

  93. typedef signed char int8_t;

  94. typedef signed int int32_t;

  95. typedef signed __int64 int64_t;

  96. 

  97. #    ifndef __MINGW32__

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

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

  100. 

  101. #        define inline __inline

  102. 

  103. #    else

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

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

  106. #    endif /* __MINGW32__ */

  107. 

  108. #    ifdef _DEBUG

  109. #        define DEBUG

  110. #    endif

  111. 

  112. #    define snprintf _snprintf

  113. #    define vsnprintf _vsnprintf

  114. 

  115. /* CONFIG_WIN32 end */

  116. #elif defined (CONFIG_OS2)

  117. /* OS/2 EMX */

  118. 

  119. #include <inttypes.h>

  120. 

  121. #ifdef HAVE_AV_CONFIG_H

  122. 

  123. #ifndef int64_t_C

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

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

  126. #endif

  127. 

  128. #ifdef USE_FASTMEMCPY

  129. #include "fastmemcpy.h"

  130. #endif

  131. 

  132. #include <float.h>

  133. 

  134. #endif /* HAVE_AV_CONFIG_H */

  135. 

  136. /* CONFIG_OS2 end */

  137. #else

  138. 

  139. /* unix */

  140. 

  141. #    include <inttypes.h>

  142. 

  143. #    ifdef HAVE_AV_CONFIG_H

  144. #        ifndef int64_t_C

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

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

  147. #        endif

  148. 

  149. #        ifdef USE_FASTMEMCPY

  150. #            include "fastmemcpy.h"

  151. #        endif

  152. #    endif /* HAVE_AV_CONFIG_H */

  153. 

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

  155. 

  156. #ifdef HAVE_AV_CONFIG_H

  157. 

  158. #    include "bswap.h"

  159. 

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

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

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

  163. #    else

  164. #        define MANGLE(a) #a

  165. #    endif

  166. 

  167. /* debug stuff */

  168. 

  169. #    ifndef DEBUG

  170. #        define NDEBUG

  171. #    endif

  172. #    include <assert.h>

  173. 

  174. /* dprintf macros */

  175. #    if defined(CONFIG_WIN32) && !defined(__MINGW32__)

  176. 

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

  178. 

  179. #    else

  180. 

  181. #        ifdef DEBUG

  182. #            define dprintf(fmt,args...) printf(fmt, ## args)

  183. #        else

  184. #            define dprintf(fmt,args...)

  185. #        endif

  186. 

  187. #    endif /* !CONFIG_WIN32 */

  188. 

  189. #    define av_abort()      do { fprintf(stderr, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0)

  190. 

  191. //rounded divison & shift

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

  193. /* assume b>0 */

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

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

  196. 

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

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

  199. 

  200. #ifdef ARCH_X86

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

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

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

  204.          : "+r" (a)

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

  206.     );

  207.     return a;

  208. }

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

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

  211.          : "+r" (a)

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

  213.     );

  214.     return a;

  215. }

  216. #else

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

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

  219. #endif

  220. 

  221. /* bit output */

  222. 

  223. struct PutBitContext;

  224. 

  225. typedef void (*WriteDataFunc)(void *, uint8_t *, int);

  226. 

  227. typedef struct PutBitContext {

  228. #ifdef ALT_BITSTREAM_WRITER

  229.     uint8_t *buf, *buf_end;

  230.     int index;

  231. #else

  232.     uint32_t bit_buf;

  233.     int bit_left;

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

  235. #endif

  236.     int64_t data_out_size; /* in bytes */

  237. } PutBitContext;

  238. 

  239. void init_put_bits(PutBitContext *s, 

  240.                    uint8_t *buffer, int buffer_size,

  241.                    void *opaque,

  242.                    void (*write_data)(void *, uint8_t *, int));

  243. 

  244. int64_t get_bit_count(PutBitContext *s); /* XXX: change function name */

  245. void align_put_bits(PutBitContext *s);

  246. void flush_put_bits(PutBitContext *s);

  247. void put_string(PutBitContext * pbc, char *s);

  248. 

  249. /* bit input */

  250. 

  251. typedef struct GetBitContext {

  252.     const uint8_t *buffer, *buffer_end;

  253. #ifdef ALT_BITSTREAM_READER

  254.     int index;

  255. #elif defined LIBMPEG2_BITSTREAM_READER

  256.     uint8_t *buffer_ptr;

  257.     uint32_t cache;

  258.     int bit_count;

  259. #elif defined A32_BITSTREAM_READER

  260.     uint32_t *buffer_ptr;

  261.     uint32_t cache0;

  262.     uint32_t cache1;

  263.     int bit_count;

  264. #endif

  265.     int size_in_bits;

  266. } GetBitContext;

  267. 

  268. static inline int get_bits_count(GetBitContext *s);

  269. 

  270. #define VLC_TYPE int16_t

  271. 

  272. typedef struct VLC {

  273.     int bits;

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

  275.     int table_size, table_allocated;

  276. } VLC;

  277. 

  278. typedef struct RL_VLC_ELEM {

  279.     int16_t level;

  280.     int8_t len;

  281.     uint8_t run;

  282. } RL_VLC_ELEM;

  283. 

  284. #ifdef ARCH_SPARC64

  285. #define UNALIGNED_STORES_ARE_BAD

  286. #endif

  287. 

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

  289. #ifdef ARCH_X86

  290. #    define unaligned32(a) (*(uint32_t*)(a))

  291. #else

  292. #    ifdef __GNUC__

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

  294.     struct Unaligned {

  295. 	uint32_t i;

  296.     } __attribute__((packed));

  297. 

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

  299. }

  300. #    elif defined(__DECC)

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

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

  303. }

  304. #    else

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

  306.     return *(const uint32_t *) v;

  307. }

  308. #    endif

  309. #endif //!ARCH_X86

  310. 

  311. #ifndef ALT_BITSTREAM_WRITER

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

  313. {

  314.     unsigned int bit_buf;

  315.     int bit_left;

  316. 

  317. #ifdef STATS

  318.     st_out_bit_counts[st_current_index] += n;

  319. #endif

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

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

  322.     

  323.     bit_buf = s->bit_buf;

  324.     bit_left = s->bit_left;

  325. 

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

  327.     /* XXX: optimize */

  328.     if (n < bit_left) {

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

  330.         bit_left-=n;

  331.     } else {

  332. 	bit_buf<<=bit_left;

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

  334. #ifdef UNALIGNED_STORES_ARE_BAD

  335.         if (3 & (int) s->buf_ptr) {

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

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

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

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

  340.         } else

  341. #endif

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

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

  344.         s->buf_ptr+=4;

  345. 	bit_left+=32 - n;

  346.         bit_buf = value;

  347.     }

  348. 

  349.     s->bit_buf = bit_buf;

  350.     s->bit_left = bit_left;

  351. }

  352. #endif

  353. 

  354. 

  355. #ifdef ALT_BITSTREAM_WRITER

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

  357. {

  358. #    ifdef ALIGNED_BITSTREAM_WRITER

  359. #        ifdef ARCH_X86

  360.     asm volatile(

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

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

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

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

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

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

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

  368. 	"bswapl %1			\n\t"

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

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

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

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

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

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

  375. 	: "%eax", "%ecx"

  376.     );

  377. #        else

  378.     int index= s->index;

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

  380.     

  381.     value<<= 32-n; 

  382.     

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

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

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

  386.     index+= n;

  387.     s->index= index;

  388. #        endif

  389. #    else //ALIGNED_BITSTREAM_WRITER

  390. #        ifdef ARCH_X86

  391.     asm volatile(

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

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

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

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

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

  397. 	"bswapl %1			\n\t"

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

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

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

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

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

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

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

  405. 	: "%ecx"

  406.     );

  407. #        else

  408.     int index= s->index;

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

  410.     

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

  412.     ptr[1] = 0;

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

  414.     index+= n;

  415.     s->index= index;

  416. #        endif

  417. #    endif //!ALIGNED_BITSTREAM_WRITER

  418. }

  419. #endif

  420. 

  421. 

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

  423. {

  424. #ifdef ALT_BITSTREAM_WRITER

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

  426. #else

  427. 	return s->buf_ptr;

  428. #endif

  429. }

  430. 

  431. /* Bitstream reader API docs:

  432. name

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

  434. 

  435. gb

  436.     getbitcontext

  437. 

  438. OPEN_READER(name, gb)

  439.     loads gb into local variables

  440. 

  441. CLOSE_READER(name, gb)

  442.     stores local vars in gb

  443. 

  444. UPDATE_CACHE(name, gb)

  445.     refills the internal cache from the bitstream

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

  447. 

  448. GET_CACHE(name, gb)

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

  450. 

  451. SHOW_UBITS(name, gb, num)

  452.     will return the nest num bits

  453. 

  454. SHOW_SBITS(name, gb, num)

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

  456. 

  457. SKIP_BITS(name, gb, num)

  458.     will skip over the next num bits

  459.     note, this is equinvalent to SKIP_CACHE; SKIP_COUNTER

  460. 

  461. SKIP_CACHE(name, gb, num)

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

  463. 

  464. SKIP_COUNTER(name, gb, num)

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

  466. 

  467. LAST_SKIP_CACHE(name, gb, num)

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

  469. 

  470. LAST_SKIP_BITS(name, gb, num)

  471.     is equinvalent to SKIP_LAST_CACHE; SKIP_COUNTER

  472. 

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

  474. */

  475. 

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

  477. {

  478. #ifdef CONFIG_ALIGN

  479. 	const uint8_t *p=v;

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

  481. #else

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

  483. #endif

  484. }

  485. 

  486. #ifdef ALT_BITSTREAM_READER

  487. #   define MIN_CACHE_BITS 25

  488. 

  489. #   define OPEN_READER(name, gb)\

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

  491.         int name##_cache= 0;\

  492. 

  493. #   define CLOSE_READER(name, gb)\

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

  495. 

  496. #   define UPDATE_CACHE(name, gb)\

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

  498. 

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

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

  501. 

  502. // FIXME name?

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

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

  505. 

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

  507.         {\

  508.             SKIP_CACHE(name, gb, num)\

  509.             SKIP_COUNTER(name, gb, num)\

  510.         }\

  511. 

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

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

  514. 

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

  516.         NEG_USR32(name##_cache, num)

  517. 

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

  519.         NEG_SSR32(name##_cache, num)

  520. 

  521. #   define GET_CACHE(name, gb)\

  522.         ((uint32_t)name##_cache)

  523. 

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

  525.     return s->index;

  526. }

  527. #elif defined LIBMPEG2_BITSTREAM_READER

  528. //libmpeg2 like reader

  529. 

  530. #   define MIN_CACHE_BITS 16

  531. 

  532. #   define OPEN_READER(name, gb)\

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

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

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

  536. 

  537. #   define CLOSE_READER(name, gb)\

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

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

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

  541. 

  542. #ifdef LIBMPEG2_BITSTREAM_READER_HACK

  543. 

  544. #   define UPDATE_CACHE(name, gb)\

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

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

  547.         name##_buffer_ptr+=2;\

  548.         name##_bit_count-= 16;\

  549.     }\

  550. 

  551. #else

  552. 

  553. #   define UPDATE_CACHE(name, gb)\

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

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

  556.         name##_buffer_ptr+=2;\

  557.         name##_bit_count-= 16;\

  558.     }\

  559. 

  560. #endif

  561. 

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

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

  564. 

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

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

  567. 

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

  569.         {\

  570.             SKIP_CACHE(name, gb, num)\

  571.             SKIP_COUNTER(name, gb, num)\

  572.         }\

  573. 

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

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

  576. 

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

  578.         NEG_USR32(name##_cache, num)

  579. 

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

  581.         NEG_SSR32(name##_cache, num)

  582. 

  583. #   define GET_CACHE(name, gb)\

  584.         ((uint32_t)name##_cache)

  585. 

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

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

  588. }

  589. 

  590. #elif defined A32_BITSTREAM_READER

  591. 

  592. #   define MIN_CACHE_BITS 32

  593. 

  594. #   define OPEN_READER(name, gb)\

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

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

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

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

  599. 

  600. #   define CLOSE_READER(name, gb)\

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

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

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

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

  605. 

  606. #   define UPDATE_CACHE(name, gb)\

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

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

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

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

  611.         name##_buffer_ptr++;\

  612.         name##_bit_count-= 32;\

  613.     }\

  614. 

  615. #ifdef ARCH_X86

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

  617.         asm(\

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

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

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

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

  622.            );

  623. #else

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

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

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

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

  628. #endif

  629. 

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

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

  632. 

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

  634.         {\

  635.             SKIP_CACHE(name, gb, num)\

  636.             SKIP_COUNTER(name, gb, num)\

  637.         }\

  638. 

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

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

  641. 

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

  643.         NEG_USR32(name##_cache0, num)

  644. 

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

  646.         NEG_SSR32(name##_cache0, num)

  647. 

  648. #   define GET_CACHE(name, gb)\

  649.         (name##_cache0)

  650. 

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

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

  653. }

  654. 

  655. #endif

  656. 

  657. /* add BERO

  658.    if MSB not set it is negative 

  659. */

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

  661.     register int tmp;

  662.     register int32_t cache;

  663.     OPEN_READER(re, s)

  664.     UPDATE_CACHE(re, s)

  665.     cache = GET_CACHE(re,s);

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

  667.         tmp = NEG_USR32(cache,n);

  668.     } else {

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

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

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

  672.     }

  673.     LAST_SKIP_BITS(re, s, n)

  674.     CLOSE_READER(re, s)

  675.     return tmp;

  676. }

  677. 

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

  679.     register int tmp;

  680.     OPEN_READER(re, s)

  681.     UPDATE_CACHE(re, s)

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

  683.     LAST_SKIP_BITS(re, s, n)

  684.     CLOSE_READER(re, s)

  685.     return tmp;

  686. }

  687. 

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

  689.     register int tmp;

  690.     OPEN_READER(re, s)

  691.     UPDATE_CACHE(re, s)

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

  693.     LAST_SKIP_BITS(re, s, n)

  694.     CLOSE_READER(re, s)

  695.     return tmp;

  696. }

  697. 

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

  699.     register int tmp;

  700.     OPEN_READER(re, s)

  701.     UPDATE_CACHE(re, s)

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

  703. //    CLOSE_READER(re, s)

  704.     return tmp;

  705. }

  706. 

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

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

  709.     OPEN_READER(re, s)

  710.     UPDATE_CACHE(re, s)

  711.     LAST_SKIP_BITS(re, s, n)

  712.     CLOSE_READER(re, s)

  713. }

  714. 

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

  716. #ifdef ALT_BITSTREAM_READER

  717.     int index= s->index;

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

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

  720.     result>>= 8 - 1;

  721.     index++;

  722.     s->index= index;

  723. 

  724.     return result;

  725. #else

  726.     return get_bits(s, 1);

  727. #endif

  728. }

  729. 

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

  731.     return show_bits(s, 1);

  732. }

  733. 

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

  735.     skip_bits(s, 1);

  736. }

  737. 

  738. void init_get_bits(GetBitContext *s,

  739.                    const uint8_t *buffer, int buffer_size);

  740. 

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

  742. void align_get_bits(GetBitContext *s);

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

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

  745.              const void *codes, int codes_wrap, int codes_size);

  746. void free_vlc(VLC *vlc);

  747. 

  748. /**

  749.  *

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

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

  752.  * is undefined

  753.  */

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

  755. {\

  756.     int n, index, nb_bits;\

  757. \

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

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

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

  761. \

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

  763.         LAST_SKIP_BITS(name, gb, bits)\

  764.         UPDATE_CACHE(name, gb)\

  765. \

  766.         nb_bits = -n;\

  767. \

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

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

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

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

  772.             LAST_SKIP_BITS(name, gb, nb_bits)\

  773.             UPDATE_CACHE(name, gb)\

  774. \

  775.             nb_bits = -n;\

  776. \

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

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

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

  780.         }\

  781.     }\

  782.     SKIP_BITS(name, gb, n)\

  783. }

  784. 

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

  786. {\

  787.     int n, index, nb_bits;\

  788. \

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

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

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

  792. \

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

  794.         LAST_SKIP_BITS(name, gb, bits)\

  795.         UPDATE_CACHE(name, gb)\

  796. \

  797.         nb_bits = -n;\

  798. \

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

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

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

  802.     }\

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

  804.     SKIP_BITS(name, gb, n)\

  805. }

  806. 

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

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

  809. {

  810.     int code;

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

  812.     

  813.     OPEN_READER(re, s)

  814.     UPDATE_CACHE(re, s)

  815. 

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

  817. 

  818.     CLOSE_READER(re, s)

  819.     return code;

  820. }

  821. 

  822. /**

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

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

  825.  *             identical to nb_bits in init_vlc()

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

  827.  *                  read the longest vlc code 

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

  829.  */

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

  831.                                   int bits, int max_depth)

  832. {

  833.     int code;

  834.     

  835.     OPEN_READER(re, s)

  836.     UPDATE_CACHE(re, s)

  837. 

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

  839. 

  840.     CLOSE_READER(re, s)

  841.     return code;

  842. }

  843. 

  844. //#define TRACE

  845. 

  846. #ifdef TRACE

  847. 

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

  849.     int i;

  850.     

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

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

  853.     }

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

  855.         printf(" ");

  856. }

  857. 

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

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

  860.     

  861.     print_bin(r, n);

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

  863.     return r;

  864. }

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

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

  867.     int pos= get_bits_count(s);

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

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

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

  871.     

  872.     print_bin(bits2, len);

  873.     

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

  875.     return r;

  876. }

  877. 

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

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

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

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

  882. 

  883. #define tprintf printf

  884. 

  885. #else //TRACE

  886. #define tprintf(_arg...) {}

  887. #endif

  888. 

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

  890.    codec efficiency */

  891. //#define STATS

  892. 

  893. #ifdef STATS

  894. 

  895. enum {

  896.     ST_UNKNOWN,

  897.     ST_DC,

  898.     ST_INTRA_AC,

  899.     ST_INTER_AC,

  900.     ST_INTRA_MB,

  901.     ST_INTER_MB,

  902.     ST_MV,

  903.     ST_NB,

  904. };

  905. 

  906. extern int st_current_index;

  907. extern unsigned int st_bit_counts[ST_NB];

  908. extern unsigned int st_out_bit_counts[ST_NB];

  909. 

  910. void print_stats(void);

  911. #endif

  912. 

  913. /* misc math functions */

  914. extern const uint8_t ff_log2_tab[256];

  915. 

  916. static inline int av_log2(unsigned int v)

  917. {

  918.     int n;

  919. 

  920.     n = 0;

  921.     if (v & 0xffff0000) {

  922.         v >>= 16;

  923.         n += 16;

  924.     }

  925.     if (v & 0xff00) {

  926.         v >>= 8;

  927.         n += 8;

  928.     }

  929.     n += ff_log2_tab[v];

  930. 

  931.     return n;

  932. }

  933. 

  934. static inline int av_log2_16bit(unsigned int v)

  935. {

  936.     int n;

  937. 

  938.     n = 0;

  939.     if (v & 0xff00) {

  940.         v >>= 8;

  941.         n += 8;

  942.     }

  943.     n += ff_log2_tab[v];

  944. 

  945.     return n;

  946. }

  947. 

  948. 

  949. /* median of 3 */

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

  951. {

  952.     int vmin, vmax;

  953.     vmax = vmin = a;

  954.     if (b < vmin)

  955.         vmin = b;

  956.     else

  957. 	vmax = b;

  958. 

  959.     if (c < vmin)

  960.         vmin = c;

  961.     else if (c > vmax)

  962.         vmax = c;

  963. 

  964.     return a + b + c - vmin - vmax;

  965. }

  966. 

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

  968. {

  969.     if (a < amin)

  970.         return amin;

  971.     else if (a > amax)

  972.         return amax;

  973.     else

  974.         return a;

  975. }

  976. 

  977. /* math */

  978. extern const uint8_t ff_sqrt_tab[128];

  979. 

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

  981. 

  982. static inline int ff_sqrt(int a)

  983. {

  984.     int ret=0;

  985.     int s;

  986.     int ret_sq=0;

  987.     

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

  989.     

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

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

  992.         if(b<=a){

  993.             ret_sq=b;

  994.             ret+= 1<<s;

  995.         }

  996.     }

  997.     return ret;

  998. }

  999. 

  1000. /**

  1001.  * converts fourcc string to int

  1002.  */

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

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

  1005.     

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

  1007. }

  1008. 

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

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

  1011. 

  1012. 

  1013. void ff_float2fraction(int *nom_arg, int *denom_arg, double f, int max);

  1014. 

  1015. 

  1016. #ifdef ARCH_X86

  1017. #define MASK_ABS(mask, level)\

  1018.             asm volatile(\

  1019. 		"cdq			\n\t"\

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

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

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

  1023. 	    );

  1024. #else

  1025. #define MASK_ABS(mask, level)\

  1026.             mask= level>>31;\

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

  1028. #endif

  1029. 

  1030. 

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

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

  1033. asm volatile (\

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

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

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

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

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

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

  1040. );

  1041. #else

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

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

  1044.      (x)=(y);\

  1045.      (a)=(b);\

  1046.      (c)=(d);\

  1047. }

  1048. #endif

  1049. 

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

  1051. 

  1052. /* avoid usage of various functions */

  1053. #define malloc please_use_av_malloc

  1054. #define free please_use_av_free

  1055. #define realloc please_use_av_realloc

  1056. 

  1057. #define CHECKED_ALLOCZ(p, size)\

  1058. {\

  1059.     p= av_mallocz(size);\

  1060.     if(p==NULL){\

  1061.         perror("malloc");\

  1062.         goto fail;\

  1063.     }\

  1064. }

  1065. 

  1066. #endif /* HAVE_AV_CONFIG_H */

  1067. 

  1068. #endif /* COMMON_H */