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.
574 Commits
32 Branches
325MB
Tree: d7e9533aa0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd7e9533aa0'
${ noResults }
FFmpeg/libavcodec/common.h

904 lines
20KB
Raw Blame History 

  1. #ifndef COMMON_H

  2. #define COMMON_H

  3. 

  4. #define FFMPEG_VERSION_INT 0x000406

  5. #define FFMPEG_VERSION     "0.4.6"

  6. 

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

  8. #define CONFIG_WIN32

  9. #endif

  10. 

  11. //#define ALT_BITSTREAM_WRITER

  12. //#define ALIGNED_BITSTREAM_WRITER

  13. //#define ALT_BITSTREAM_READER

  14. //#define ALIGNED_BITSTREAM

  15. #define FAST_GET_FIRST_VLC

  16. //#define DUMP_STREAM // only works with the ALT_BITSTREAM_READER

  17. 

  18. #ifdef HAVE_AV_CONFIG_H

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

  20. #include "../config.h"

  21. 

  22. #include <stdlib.h>

  23. #include <stdio.h>

  24. #include <string.h>

  25. #include <errno.h>

  26. 

  27. #ifndef ENODATA

  28. #define ENODATA  61

  29. #endif

  30. 

  31. #endif

  32. 

  33. #ifdef CONFIG_WIN32

  34. 

  35. /* windows */

  36. 

  37. typedef unsigned short UINT16;

  38. typedef signed short INT16;

  39. typedef unsigned char UINT8;

  40. typedef unsigned int UINT32;

  41. typedef unsigned __int64 UINT64;

  42. typedef signed char INT8;

  43. typedef signed int INT32;

  44. typedef signed __int64 INT64;

  45. 

  46. typedef UINT8 uint8_t;

  47. typedef INT8 int8_t;

  48. typedef UINT16 uint16_t;

  49. typedef INT16 int16_t;

  50. typedef UINT32 uint32_t;

  51. typedef INT32 int32_t;

  52. 

  53. #ifndef __MINGW32__

  54. #define INT64_C(c)     (c ## i64)

  55. #define UINT64_C(c)    (c ## i64)

  56. 

  57. #define inline __inline

  58. 

  59. /*

  60.   Disable warning messages:

  61.     warning C4244: '=' : conversion from 'double' to 'float', possible loss of data

  62.     warning C4305: 'argument' : truncation from 'const double' to 'float'

  63. */

  64. #pragma warning( disable : 4244 )

  65. #pragma warning( disable : 4305 )

  66. 

  67. #else

  68. #define INT64_C(c)     (c ## LL)

  69. #define UINT64_C(c)    (c ## ULL)

  70. #endif /* __MINGW32__ */

  71. 

  72. #define M_PI    3.14159265358979323846

  73. #define M_SQRT2 1.41421356237309504880  /* sqrt(2) */

  74. 

  75. #ifdef _DEBUG

  76. #define DEBUG

  77. #endif

  78. 

  79. // code from bits/byteswap.h (C) 1997, 1998 Free Software Foundation, Inc.

  80. #define bswap_32(x) \

  81.      ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) | \

  82.       (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))

  83. #define be2me_32(x) bswap_32(x)

  84. 

  85. #define snprintf _snprintf

  86. 

  87. #ifndef __MINGW32__

  88. /* no config.h with VC */

  89. #define CONFIG_ENCODERS 1

  90. #define CONFIG_DECODERS 1

  91. #define CONFIG_AC3      1

  92. #endif

  93. 

  94. #else

  95. 

  96. /* unix */

  97. 

  98. #include <inttypes.h>

  99. 

  100. #ifndef __WINE_WINDEF16_H

  101. /* workaround for typedef conflict in MPlayer (wine typedefs) */

  102. typedef unsigned short UINT16;

  103. typedef signed short INT16;

  104. #endif

  105. 

  106. typedef unsigned char UINT8;

  107. typedef unsigned int UINT32;

  108. typedef unsigned long long UINT64;

  109. typedef signed char INT8;

  110. typedef signed int INT32;

  111. typedef signed long long INT64;

  112. 

  113. #ifdef HAVE_AV_CONFIG_H

  114. 

  115. #ifdef __FreeBSD__

  116. #include <sys/param.h>

  117. #endif

  118. 

  119. #ifndef INT64_C

  120. #define INT64_C(c)     (c ## LL)

  121. #define UINT64_C(c)    (c ## ULL)

  122. #endif

  123. 

  124. #include "../bswap.h"

  125. 

  126. #ifdef USE_FASTMEMCPY

  127. #include "fastmemcpy.h"

  128. #endif

  129. 

  130. #endif /* HAVE_AV_CONFIG_H */

  131. 

  132. #endif /* !CONFIG_WIN32 */

  133. 

  134. 

  135. /* debug stuff */

  136. #ifdef HAVE_AV_CONFIG_H

  137. 

  138. #ifndef DEBUG

  139. #define NDEBUG

  140. #endif

  141. #include <assert.h>

  142. 

  143. /* dprintf macros */

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

  145. 

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

  147. 

  148. #else

  149. 

  150. #ifdef DEBUG

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

  152. #else

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

  154. #endif

  155. 

  156. #endif /* !CONFIG_WIN32 */

  157. 

  158. #endif /* HAVE_AV_CONFIG_H */

  159. 

  160. /* assume b>0 */

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

  162. 

  163. /* bit output */

  164. 

  165. struct PutBitContext;

  166. 

  167. typedef void (*WriteDataFunc)(void *, UINT8 *, int);

  168. 

  169. typedef struct PutBitContext {

  170. #ifdef ALT_BITSTREAM_WRITER

  171.     UINT8 *buf, *buf_end;

  172.     int index;

  173. #else

  174.     UINT32 bit_buf;

  175.     int bit_left;

  176.     UINT8 *buf, *buf_ptr, *buf_end;

  177. #endif

  178.     INT64 data_out_size; /* in bytes */

  179. } PutBitContext;

  180. 

  181. void init_put_bits(PutBitContext *s, 

  182.                    UINT8 *buffer, int buffer_size,

  183.                    void *opaque,

  184.                    void (*write_data)(void *, UINT8 *, int));

  185. 

  186. INT64 get_bit_count(PutBitContext *s); /* XXX: change function name */

  187. void align_put_bits(PutBitContext *s);

  188. void flush_put_bits(PutBitContext *s);

  189. 

  190. /* jpeg specific put_bits */

  191. void jflush_put_bits(PutBitContext *s);

  192. 

  193. /* bit input */

  194. 

  195. typedef struct GetBitContext {

  196. #ifdef ALT_BITSTREAM_READER

  197.     int index;

  198.     UINT8 *buffer;

  199. #else

  200.     UINT32 bit_buf;

  201.     int bit_cnt;

  202.     UINT8 *buf, *buf_ptr, *buf_end;

  203. #endif

  204.     int size;

  205. } GetBitContext;

  206. 

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

  208. 

  209. typedef struct VLC {

  210.     int bits;

  211.     INT16 *table_codes;

  212.     INT8 *table_bits;

  213.     int table_size, table_allocated;

  214. } VLC;

  215. 

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

  217. #ifdef ARCH_X86

  218. #define unaligned32(a) (*(UINT32*)(a))

  219. #else

  220. #ifdef __GNUC__

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

  222.     struct Unaligned {

  223. 	uint32_t i;

  224.     } __attribute__((packed));

  225. 

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

  227. }

  228. #elif defined(__DECC)

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

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

  231. }

  232. #else

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

  234.     return *(const uint32_t *) v;

  235. }

  236. #endif

  237. #endif //!ARCH_X86

  238. 

  239. #ifndef ALT_BITSTREAM_WRITER

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

  241. {

  242.     unsigned int bit_buf;

  243.     int bit_left;

  244. 

  245. #ifdef STATS

  246.     st_out_bit_counts[st_current_index] += n;

  247. #endif

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

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

  250.     

  251.     bit_buf = s->bit_buf;

  252.     bit_left = s->bit_left;

  253. 

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

  255.     /* XXX: optimize */

  256.     if (n < bit_left) {

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

  258.         bit_left-=n;

  259.     } else {

  260. 	bit_buf<<=bit_left;

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

  262.         *(UINT32 *)s->buf_ptr = be2me_32(bit_buf);

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

  264.         s->buf_ptr+=4;

  265. 	bit_left+=32 - n;

  266.         bit_buf = value;

  267.     }

  268. 

  269.     s->bit_buf = bit_buf;

  270.     s->bit_left = bit_left;

  271. }

  272. #endif

  273. 

  274. 

  275. #ifdef ALT_BITSTREAM_WRITER

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

  277. {

  278. #ifdef ALIGNED_BITSTREAM_WRITER

  279. #ifdef ARCH_X86

  280.     asm volatile(

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

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

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

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

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

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

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

  288. 	"bswapl %1			\n\t"

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

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

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

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

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

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

  295. 	: "%eax", "%ecx"

  296.     );

  297. #else

  298.     int index= s->index;

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

  300.     

  301.     value<<= 32-n; 

  302.     

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

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

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

  306.     index+= n;

  307.     s->index= index;

  308. #endif

  309. #else //ALIGNED_BITSTREAM_WRITER

  310. #ifdef ARCH_X86

  311.     asm volatile(

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

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

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

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

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

  317. 	"bswapl %1			\n\t"

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

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

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

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

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

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

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

  325. 	: "%ecx"

  326.     );

  327. #else

  328.     int index= s->index;

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

  330.     

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

  332.     ptr[1] = 0;

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

  334.     index+= n;

  335.     s->index= index;

  336. #endif

  337. #endif //!ALIGNED_BITSTREAM_WRITER

  338. }

  339. #endif

  340. 

  341. #ifndef ALT_BITSTREAM_WRITER

  342. /* for jpeg : escape 0xff with 0x00 after it */

  343. static inline void jput_bits(PutBitContext *s, int n, unsigned int value)

  344. {

  345.     unsigned int bit_buf, b;

  346.     int bit_left, i;

  347.     

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

  349. 

  350.     bit_buf = s->bit_buf;

  351.     bit_left = s->bit_left;

  352. 

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

  354.     /* XXX: optimize */

  355.     if (n < bit_left) {

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

  357.         bit_left-=n;

  358.     } else {

  359. 	bit_buf<<=bit_left;

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

  361.         /* handle escape */

  362.         for(i=0;i<4;i++) {

  363.             b = (bit_buf >> 24);

  364.             *(s->buf_ptr++) = b;

  365.             if (b == 0xff)

  366.                 *(s->buf_ptr++) = 0;

  367.             bit_buf <<= 8;

  368.         }

  369. 

  370. 	bit_left+= 32 - n;

  371.         bit_buf = value;

  372.     }

  373.     

  374.     s->bit_buf = bit_buf;

  375.     s->bit_left = bit_left;

  376. }

  377. #endif

  378. 

  379. 

  380. #ifdef ALT_BITSTREAM_WRITER

  381. static inline void jput_bits(PutBitContext *s, int n, int value)

  382. {

  383.     int index= s->index;

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

  385.     int v= ptr[0];

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

  387.     

  388.     v |= be2me_32(value<<(32-n-(index&7) ));

  389.     if(((v+0x01010101)^0xFFFFFFFF)&v&0x80808080)

  390.     {

  391. 	/* handle idiotic (m)jpeg escapes */

  392. 	uint8_t *bPtr= (uint8_t*)ptr;

  393. 	int numChecked= ((index+n)>>3) - (index>>3);

  394. 	

  395. 	v= be2me_32(v);

  396. 

  397. 	*(bPtr++)= v>>24;

  398. 	if((v&0xFF000000)==0xFF000000 && numChecked>0){

  399. 		*(bPtr++)= 0x00;

  400. 		index+=8;

  401. 	}

  402. 	*(bPtr++)= (v>>16)&0xFF;

  403. 	if((v&0x00FF0000)==0x00FF0000 && numChecked>1){

  404. 		*(bPtr++)= 0x00;

  405. 		index+=8;

  406. 	}

  407. 	*(bPtr++)= (v>>8)&0xFF;

  408. 	if((v&0x0000FF00)==0x0000FF00 && numChecked>2){

  409. 		*(bPtr++)= 0x00;

  410. 		index+=8;

  411. 	}

  412. 	*(bPtr++)= v&0xFF;

  413. 	if((v&0x000000FF)==0x000000FF && numChecked>3){

  414. 		*(bPtr++)= 0x00;

  415. 		index+=8;

  416. 	}

  417. 	*((uint32_t*)bPtr)= 0;

  418.     }

  419.     else

  420.     {

  421. 	ptr[0] = v;

  422. 	ptr[1] = 0;

  423.     }

  424. 

  425.     index+= n;

  426.     s->index= index;

  427.  }

  428. #endif

  429. 

  430. 

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

  432. {

  433. #ifdef ALT_BITSTREAM_WRITER

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

  435. #else

  436. 	return s->buf_ptr;

  437. #endif

  438. }

  439. 

  440. void init_get_bits(GetBitContext *s, 

  441.                    UINT8 *buffer, int buffer_size);

  442. 

  443. #ifndef ALT_BITSTREAM_READER

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

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

  446. #endif

  447. 

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

  449. #ifdef ALT_BITSTREAM_READER

  450. #ifdef ALIGNED_BITSTREAM

  451.     int index= s->index;

  452.     uint32_t result1= be2me_32( ((uint32_t *)s->buffer)[index>>5] );

  453.     uint32_t result2= be2me_32( ((uint32_t *)s->buffer)[(index>>5) + 1] );

  454. #ifdef ARCH_X86

  455.     asm ("shldl %%cl, %2, %0\n\t"

  456.          : "=r" (result1)

  457. 	 : "0" (result1), "r" (result2), "c" (index));

  458. #else

  459.     result1<<= (index&0x1F);

  460.     result2= (result2>>1) >> (31-(index&0x1F));

  461.     result1|= result2;

  462. #endif

  463.     result1>>= 32 - n;

  464.     index+= n;

  465.     s->index= index;

  466.     

  467.     return result1;

  468. #else //ALIGNED_BITSTREAM

  469.     int index= s->index;

  470.     uint32_t result= be2me_32( unaligned32( ((uint8_t *)s->buffer)+(index>>3) ) );

  471. 

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

  473.     result>>= 32 - n;

  474.     index+= n;

  475.     s->index= index;

  476. #ifdef DUMP_STREAM

  477.     while(n){

  478.         printf("%d", (result>>(n-1))&1);

  479.         n--;

  480.     }

  481.     printf(" ");

  482. #endif

  483.     return result;

  484. #endif //!ALIGNED_BITSTREAM

  485. #else //ALT_BITSTREAM_READER

  486.     if(s->bit_cnt>=n){

  487.         /* most common case here */

  488.         unsigned int val = s->bit_buf >> (32 - n);

  489.         s->bit_buf <<= n;

  490. 	s->bit_cnt -= n;

  491. #ifdef STATS

  492. 	st_bit_counts[st_current_index] += n;

  493. #endif

  494. 	return val;

  495.     }

  496.     return get_bits_long(s,n);

  497. #endif //!ALT_BITSTREAM_READER

  498. }

  499. 

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

  501. #ifdef ALT_BITSTREAM_READER

  502.     int index= s->index;

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

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

  505.     result>>= 8 - 1;

  506.     index++;

  507.     s->index= index;

  508.     

  509. #ifdef DUMP_STREAM

  510.     printf("%d ", result);

  511. #endif

  512.     return result;

  513. #else

  514.     if(s->bit_cnt>0){

  515.         /* most common case here */

  516.         unsigned int val = s->bit_buf >> 31;

  517.         s->bit_buf <<= 1;

  518. 	s->bit_cnt--;

  519. #ifdef STATS

  520. 	st_bit_counts[st_current_index]++;

  521. #endif

  522. 	return val;

  523.     }

  524.     return get_bits_long(s,1);

  525. #endif

  526. }

  527. 

  528. /* This function is identical to get_bits(), the only */

  529. /* diference is that it doesn't touch the buffer      */

  530. /* it is usefull to see the buffer.                   */

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

  532. {

  533. #ifdef ALT_BITSTREAM_READER

  534. #ifdef ALIGNED_BITSTREAM

  535.     int index= s->index;

  536.     uint32_t result1= be2me_32( ((uint32_t *)s->buffer)[index>>5] );

  537.     uint32_t result2= be2me_32( ((uint32_t *)s->buffer)[(index>>5) + 1] );

  538. #ifdef ARCH_X86

  539.     asm ("shldl %%cl, %2, %0\n\t"

  540.          : "=r" (result1)

  541. 	 : "0" (result1), "r" (result2), "c" (index));

  542. #else

  543.     result1<<= (index&0x1F);

  544.     result2= (result2>>1) >> (31-(index&0x1F));

  545.     result1|= result2;

  546. #endif

  547.     result1>>= 32 - n;

  548.     

  549.     return result1;

  550. #else //ALIGNED_BITSTREAM

  551.     int index= s->index;

  552.     uint32_t result= be2me_32( unaligned32( ((uint8_t *)s->buffer)+(index>>3) ) );

  553. 

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

  555.     result>>= 32 - n;

  556.     

  557.     return result;

  558. #endif //!ALIGNED_BITSTREAM

  559. #else //ALT_BITSTREAM_READER

  560.     if(s->bit_cnt>=n) {

  561.         /* most common case here */

  562.         unsigned int val = s->bit_buf >> (32 - n);

  563.         return val;

  564.     }

  565.     return show_bits_long(s,n);

  566. #endif //!ALT_BITSTREAM_READER

  567. }

  568. 

  569. static inline int show_aligned_bits(GetBitContext *s, int offset, int n)

  570. {

  571. #ifdef ALT_BITSTREAM_READER

  572. #ifdef ALIGNED_BITSTREAM

  573.     int index= (s->index + offset + 7)&(~7);

  574.     uint32_t result1= be2me_32( ((uint32_t *)s->buffer)[index>>5] );

  575.     uint32_t result2= be2me_32( ((uint32_t *)s->buffer)[(index>>5) + 1] );

  576. #ifdef ARCH_X86

  577.     asm ("shldl %%cl, %2, %0\n\t"

  578.          : "=r" (result1)

  579. 	 : "0" (result1), "r" (result2), "c" (index));

  580. #else

  581.     result1<<= (index&0x1F);

  582.     result2= (result2>>1) >> (31-(index&0x1F));

  583.     result1|= result2;

  584. #endif

  585.     result1>>= 32 - n;

  586.     

  587.     return result1;

  588. #else //ALIGNED_BITSTREAM

  589.     int index= (s->index + offset + 7)>>3;

  590.     uint32_t result= be2me_32( unaligned32( ((uint8_t *)s->buffer)+index ) );

  591. 

  592.     result>>= 32 - n;

  593.     

  594.     return result;

  595. #endif //!ALIGNED_BITSTREAM

  596. #else //ALT_BITSTREAM_READER

  597.     int index= (get_bits_count(s) + offset + 7)>>3;

  598.     uint32_t result= be2me_32( unaligned32( ((uint8_t *)s->buf)+index ) );

  599. 

  600.     result>>= 32 - n;

  601. //printf(" %X %X %d \n", (int)(((uint8_t *)s->buf)+index ), (int)s->buf_ptr, s->bit_cnt);    

  602.     return result;

  603. #endif //!ALT_BITSTREAM_READER

  604. }

  605. 

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

  607. #ifdef ALT_BITSTREAM_READER

  608.     s->index+= n;

  609. #ifdef DUMP_STREAM

  610.     {

  611.         int result;

  612.         s->index-= n;

  613.         result= get_bits(s, n);

  614.     }

  615. #endif

  616. 

  617. #else

  618.     if(s->bit_cnt>=n){

  619.         /* most common case here */

  620.         s->bit_buf <<= n;

  621. 	s->bit_cnt -= n;

  622. #ifdef STATS

  623. 	st_bit_counts[st_current_index] += n;

  624. #endif

  625.     } else {

  626. 	get_bits_long(s,n);

  627.     }

  628. #endif

  629. }

  630. 

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

  632. #ifdef ALT_BITSTREAM_READER

  633.     s->index++;

  634. #ifdef DUMP_STREAM

  635.     s->index--;

  636.     printf("%d ", get_bits1(s));

  637. #endif

  638. #else

  639.     if(s->bit_cnt>0){

  640.         /* most common case here */

  641.         s->bit_buf <<= 1;

  642. 	s->bit_cnt--;

  643. #ifdef STATS

  644. 	st_bit_counts[st_current_index]++;

  645. #endif

  646.     } else {

  647. 	get_bits_long(s,1);

  648.     }

  649. #endif

  650. }

  651. 

  652. static inline int get_bits_count(GetBitContext *s)

  653. {

  654. #ifdef ALT_BITSTREAM_READER

  655.     return s->index;

  656. #else

  657.     return (s->buf_ptr - s->buf) * 8 - s->bit_cnt;

  658. #endif

  659. }

  660. 

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

  662. void align_get_bits(GetBitContext *s);

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

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

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

  666. void free_vlc(VLC *vlc);

  667. 

  668. #ifdef ALT_BITSTREAM_READER

  669. #ifdef ALIGNED_BITSTREAM

  670. #ifdef ARCH_X86

  671. #define SHOW_BITS(s, val, n) \

  672.     val= be2me_32( ((uint32_t *)(s)->buffer)[bit_cnt>>5] );\

  673.     {uint32_t result2= be2me_32( ((uint32_t *)(s)->buffer)[(bit_cnt>>5) + 1] );\

  674.     asm ("shldl %%cl, %2, %0\n\t"\

  675.          : "=r" (val)\

  676.          : "0" (val), "r" (result2), "c" (bit_cnt));\

  677.     ((uint32_t)val)>>= 32 - n;}

  678. #else //ARCH_X86

  679. #define SHOW_BITS(s, val, n) \

  680.     val= be2me_32( ((uint32_t *)(s)->buffer)[bit_cnt>>5] );\

  681.     {uint32_t result2= be2me_32( ((uint32_t *)(s)->buffer)[(bit_cnt>>5) + 1] );\

  682.     val<<= (bit_cnt&0x1F);\

  683.     result2= (result2>>1) >> (31-(bit_cnt&0x1F));\

  684.     val|= result2;\

  685.     ((uint32_t)val)>>= 32 - n;}

  686. #endif //!ARCH_X86

  687. #else //ALIGNED_BITSTREAM

  688. #define SHOW_BITS(s, val, n) \

  689.     val= be2me_32( unaligned32( ((uint8_t *)(s)->buffer)+(bit_cnt>>3) ) );\

  690.     val<<= (bit_cnt&0x07);\

  691.     ((uint32_t)val)>>= 32 - n;

  692. #endif // !ALIGNED_BITSTREAM

  693. #define FLUSH_BITS(n) bit_cnt+=n; 

  694. #define SAVE_BITS(s) bit_cnt= (s)->index;

  695. #define RESTORE_BITS(s) (s)->index= bit_cnt;

  696. #else

  697. 

  698. /* macro to go faster */

  699. /* n must be <= 24 */

  700. /* XXX: optimize buffer end test */

  701. #define SHOW_BITS(s, val, n)\

  702. {\

  703.     if (bit_cnt < n && buf_ptr < (s)->buf_end) {\

  704.         bit_buf |= *buf_ptr++ << (24 - bit_cnt);\

  705.         bit_cnt += 8;\

  706.         if (bit_cnt < n && buf_ptr < (s)->buf_end) {\

  707.             bit_buf |= *buf_ptr++ << (24 - bit_cnt);\

  708.             bit_cnt += 8;\

  709.             if (bit_cnt < n && buf_ptr < (s)->buf_end) {\

  710.                 bit_buf |= *buf_ptr++ << (24 - bit_cnt);\

  711.                 bit_cnt += 8;\

  712.             }\

  713.         }\

  714.     }\

  715.     val = bit_buf >> (32 - n);\

  716. }

  717. 

  718. /* SHOW_BITS with n1 >= n must be been done before */

  719. #define FLUSH_BITS(n)\

  720. {\

  721.     bit_buf <<= n;\

  722.     bit_cnt -= n;\

  723. }

  724. 

  725. #define SAVE_BITS(s) \

  726. {\

  727.     bit_cnt = (s)->bit_cnt;\

  728.     bit_buf = (s)->bit_buf;\

  729.     buf_ptr = (s)->buf_ptr;\

  730. }

  731. 

  732. #define RESTORE_BITS(s) \

  733. {\

  734.     (s)->buf_ptr = buf_ptr;\

  735.     (s)->bit_buf = bit_buf;\

  736.     (s)->bit_cnt = bit_cnt;\

  737. }

  738. #endif // !ALT_BITSTREAM_READER

  739. 

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

  741. {

  742.     int code, n, nb_bits, index;

  743.     INT16 *table_codes;

  744.     INT8 *table_bits;

  745.     int bit_cnt;

  746. #ifndef ALT_BITSTREAM_READER

  747.     UINT32 bit_buf;

  748.     UINT8 *buf_ptr;

  749. #endif

  750. 

  751.     SAVE_BITS(s);

  752.     nb_bits = vlc->bits;

  753.     table_codes = vlc->table_codes;

  754.     table_bits = vlc->table_bits;

  755. 

  756. #ifdef FAST_GET_FIRST_VLC

  757.     SHOW_BITS(s, index, nb_bits);

  758.     code = table_codes[index];

  759.     n = table_bits[index];

  760.     if (n > 0) {

  761.         /* most common case (90%)*/

  762.         FLUSH_BITS(n);

  763. #ifdef DUMP_STREAM

  764.         {

  765.             int n= bit_cnt - s->index;

  766.             skip_bits(s, n);

  767.             RESTORE_BITS(s);

  768.         }

  769. #endif

  770.         RESTORE_BITS(s);

  771.         return code;

  772.     } else if (n == 0) {

  773.         return -1;

  774.     } else {

  775.         FLUSH_BITS(nb_bits);

  776.         nb_bits = -n;

  777.         table_codes = vlc->table_codes + code;

  778.         table_bits = vlc->table_bits + code;

  779.     }

  780. #endif

  781.     for(;;) {

  782.         SHOW_BITS(s, index, nb_bits);

  783.         code = table_codes[index];

  784.         n = table_bits[index];

  785.         if (n > 0) {

  786.             /* most common case */

  787.             FLUSH_BITS(n);

  788. #ifdef STATS

  789.             st_bit_counts[st_current_index] += n;

  790. #endif

  791.             break;

  792.         } else if (n == 0) {

  793.             return -1;

  794.         } else {

  795.             FLUSH_BITS(nb_bits);

  796. #ifdef STATS

  797.             st_bit_counts[st_current_index] += nb_bits;

  798. #endif

  799.             nb_bits = -n;

  800.             table_codes = vlc->table_codes + code;

  801.             table_bits = vlc->table_bits + code;

  802.         }

  803.     }

  804. #ifdef DUMP_STREAM

  805.     {

  806.         int n= bit_cnt - s->index;

  807.         skip_bits(s, n);

  808.         RESTORE_BITS(s);

  809.     }

  810. #endif

  811.     RESTORE_BITS(s);

  812.     return code;

  813. }

  814. 

  815. 

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

  817.    codec efficiency */

  818. //#define STATS

  819. 

  820. #ifdef STATS

  821. 

  822. enum {

  823.     ST_UNKNOWN,

  824.     ST_DC,

  825.     ST_INTRA_AC,

  826.     ST_INTER_AC,

  827.     ST_INTRA_MB,

  828.     ST_INTER_MB,

  829.     ST_MV,

  830.     ST_NB,

  831. };

  832. 

  833. extern int st_current_index;

  834. extern unsigned int st_bit_counts[ST_NB];

  835. extern unsigned int st_out_bit_counts[ST_NB];

  836. 

  837. void print_stats(void);

  838. #endif

  839. 

  840. /* misc math functions */

  841. 

  842. static inline int av_log2(unsigned int v)

  843. {

  844.     int n;

  845. 

  846.     n = 0;

  847.     if (v & 0xffff0000) {

  848.         v >>= 16;

  849.         n += 16;

  850.     }

  851.     if (v & 0xff00) {

  852.         v >>= 8;

  853.         n += 8;

  854.     }

  855.     if (v & 0xf0) {

  856.         v >>= 4;

  857.         n += 4;

  858.     }

  859.     if (v & 0xc) {

  860.         v >>= 2;

  861.         n += 2;

  862.     }

  863.     if (v & 0x2) {

  864.         n++;

  865.     }

  866.     return n;

  867. }

  868. 

  869. /* median of 3 */

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

  871. {

  872.     int vmin, vmax;

  873.     vmax = vmin = a;

  874.     if (b < vmin)

  875.         vmin = b;

  876.     else

  877. 	vmax = b;

  878. 

  879.     if (c < vmin)

  880.         vmin = c;

  881.     else if (c > vmax)

  882.         vmax = c;

  883. 

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

  885. }

  886. 

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

  888. {

  889.     if (a < amin)

  890.         return amin;

  891.     else if (a > amax)

  892.         return amax;

  893.     else

  894.         return a;

  895. }

  896. 

  897. /* memory */

  898. void *av_mallocz(int size);

  899. 

  900. /* math */

  901. int ff_gcd(int a, int b);

  902. 

  903. #endif