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

905 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. #include <math.h>

  27. 

  28. #ifndef ENODATA

  29. #define ENODATA  61

  30. #endif

  31. 

  32. #endif /* HAVE_AV_CONFIG_H */

  33. 

  34. #ifdef CONFIG_WIN32

  35. 

  36. /* windows */

  37. 

  38. typedef unsigned short UINT16;

  39. typedef signed short INT16;

  40. typedef unsigned char UINT8;

  41. typedef unsigned int UINT32;

  42. typedef unsigned __int64 UINT64;

  43. typedef signed char INT8;

  44. typedef signed int INT32;

  45. typedef signed __int64 INT64;

  46. 

  47. typedef UINT8 uint8_t;

  48. typedef INT8 int8_t;

  49. typedef UINT16 uint16_t;

  50. typedef INT16 int16_t;

  51. typedef UINT32 uint32_t;

  52. typedef INT32 int32_t;

  53. 

  54. #ifndef __MINGW32__

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

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

  57. 

  58. #define inline __inline

  59. 

  60. #else

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

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

  63. #endif /* __MINGW32__ */

  64. 

  65. #define M_PI    3.14159265358979323846

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

  67. 

  68. #ifdef _DEBUG

  69. #define DEBUG

  70. #endif

  71. 

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

  73. #define bswap_32(x) \

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

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

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

  77. 

  78. #define snprintf _snprintf

  79. 

  80. #ifndef __MINGW32__

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

  82. #define CONFIG_ENCODERS 1

  83. #define CONFIG_DECODERS 1

  84. #define CONFIG_AC3      1

  85. #endif

  86. 

  87. #else

  88. 

  89. /* unix */

  90. 

  91. #include <inttypes.h>

  92. 

  93. #ifndef __WINE_WINDEF16_H

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

  95. typedef unsigned short UINT16;

  96. typedef signed short INT16;

  97. #endif

  98. 

  99. typedef unsigned char UINT8;

  100. typedef unsigned int UINT32;

  101. typedef unsigned long long UINT64;

  102. typedef signed char INT8;

  103. typedef signed int INT32;

  104. typedef signed long long INT64;

  105. 

  106. #ifdef HAVE_AV_CONFIG_H

  107. 

  108. #ifdef __FreeBSD__

  109. #include <sys/param.h>

  110. #endif

  111. 

  112. #ifndef INT64_C

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

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

  115. #endif

  116. 

  117. #include "../bswap.h"

  118. 

  119. #ifdef USE_FASTMEMCPY

  120. #include "fastmemcpy.h"

  121. #endif

  122. 

  123. #endif /* HAVE_AV_CONFIG_H */

  124. 

  125. #endif /* !CONFIG_WIN32 */

  126. 

  127. 

  128. /* debug stuff */

  129. #ifdef HAVE_AV_CONFIG_H

  130. 

  131. #ifndef DEBUG

  132. #define NDEBUG

  133. #endif

  134. #include <assert.h>

  135. 

  136. /* dprintf macros */

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

  138. 

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

  140. 

  141. #else

  142. 

  143. #ifdef DEBUG

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

  145. #else

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

  147. #endif

  148. 

  149. #endif /* !CONFIG_WIN32 */

  150. 

  151. #endif /* HAVE_AV_CONFIG_H */

  152. 

  153. /* assume b>0 */

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

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

  156. 

  157. /* bit output */

  158. 

  159. struct PutBitContext;

  160. 

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

  162. 

  163. typedef struct PutBitContext {

  164. #ifdef ALT_BITSTREAM_WRITER

  165.     UINT8 *buf, *buf_end;

  166.     int index;

  167. #else

  168.     UINT32 bit_buf;

  169.     int bit_left;

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

  171. #endif

  172.     INT64 data_out_size; /* in bytes */

  173. } PutBitContext;

  174. 

  175. void init_put_bits(PutBitContext *s, 

  176.                    UINT8 *buffer, int buffer_size,

  177.                    void *opaque,

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

  179. 

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

  181. void align_put_bits(PutBitContext *s);

  182. void flush_put_bits(PutBitContext *s);

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

  184. 

  185. /* jpeg specific put_bits */

  186. void jflush_put_bits(PutBitContext *s);

  187. 

  188. /* bit input */

  189. 

  190. typedef struct GetBitContext {

  191. #ifdef ALT_BITSTREAM_READER

  192.     int index;

  193.     UINT8 *buffer;

  194. #else

  195.     UINT32 bit_buf;

  196.     int bit_cnt;

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

  198. #endif

  199.     int size;

  200. } GetBitContext;

  201. 

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

  203. 

  204. typedef struct VLC {

  205.     int bits;

  206.     INT16 *table_codes;

  207.     INT8 *table_bits;

  208.     int table_size, table_allocated;

  209. } VLC;

  210. 

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

  212. #ifdef ARCH_X86

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

  214. #else

  215. #ifdef __GNUC__

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

  217.     struct Unaligned {

  218. 	uint32_t i;

  219.     } __attribute__((packed));

  220. 

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

  222. }

  223. #elif defined(__DECC)

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

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

  226. }

  227. #else

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

  229.     return *(const uint32_t *) v;

  230. }

  231. #endif

  232. #endif //!ARCH_X86

  233. 

  234. #ifndef ALT_BITSTREAM_WRITER

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

  236. {

  237.     unsigned int bit_buf;

  238.     int bit_left;

  239. 

  240. #ifdef STATS

  241.     st_out_bit_counts[st_current_index] += n;

  242. #endif

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

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

  245.     

  246.     bit_buf = s->bit_buf;

  247.     bit_left = s->bit_left;

  248. 

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

  250.     /* XXX: optimize */

  251.     if (n < bit_left) {

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

  253.         bit_left-=n;

  254.     } else {

  255. 	bit_buf<<=bit_left;

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

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

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

  259.         s->buf_ptr+=4;

  260. 	bit_left+=32 - n;

  261.         bit_buf = value;

  262.     }

  263. 

  264.     s->bit_buf = bit_buf;

  265.     s->bit_left = bit_left;

  266. }

  267. #endif

  268. 

  269. 

  270. #ifdef ALT_BITSTREAM_WRITER

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

  272. {

  273. #ifdef ALIGNED_BITSTREAM_WRITER

  274. #ifdef ARCH_X86

  275.     asm volatile(

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

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

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

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

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

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

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

  283. 	"bswapl %1			\n\t"

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

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

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

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

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

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

  290. 	: "%eax", "%ecx"

  291.     );

  292. #else

  293.     int index= s->index;

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

  295.     

  296.     value<<= 32-n; 

  297.     

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

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

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

  301.     index+= n;

  302.     s->index= index;

  303. #endif

  304. #else //ALIGNED_BITSTREAM_WRITER

  305. #ifdef ARCH_X86

  306.     asm volatile(

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

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

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

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

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

  312. 	"bswapl %1			\n\t"

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

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

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

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

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

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

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

  320. 	: "%ecx"

  321.     );

  322. #else

  323.     int index= s->index;

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

  325.     

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

  327.     ptr[1] = 0;

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

  329.     index+= n;

  330.     s->index= index;

  331. #endif

  332. #endif //!ALIGNED_BITSTREAM_WRITER

  333. }

  334. #endif

  335. 

  336. #ifndef ALT_BITSTREAM_WRITER

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

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

  339. {

  340.     unsigned int bit_buf, b;

  341.     int bit_left, i;

  342.     

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

  344. 

  345.     bit_buf = s->bit_buf;

  346.     bit_left = s->bit_left;

  347. 

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

  349.     /* XXX: optimize */

  350.     if (n < bit_left) {

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

  352.         bit_left-=n;

  353.     } else {

  354. 	bit_buf<<=bit_left;

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

  356.         /* handle escape */

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

  358.             b = (bit_buf >> 24);

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

  360.             if (b == 0xff)

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

  362.             bit_buf <<= 8;

  363.         }

  364. 

  365. 	bit_left+= 32 - n;

  366.         bit_buf = value;

  367.     }

  368.     

  369.     s->bit_buf = bit_buf;

  370.     s->bit_left = bit_left;

  371. }

  372. #endif

  373. 

  374. 

  375. #ifdef ALT_BITSTREAM_WRITER

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

  377. {

  378.     int index= s->index;

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

  380.     int v= ptr[0];

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

  382.     

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

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

  385.     {

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

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

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

  389. 	

  390. 	v= be2me_32(v);

  391. 

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

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

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

  395. 		index+=8;

  396. 	}

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

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

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

  400. 		index+=8;

  401. 	}

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

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

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

  405. 		index+=8;

  406. 	}

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

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

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

  410. 		index+=8;

  411. 	}

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

  413.     }

  414.     else

  415.     {

  416. 	ptr[0] = v;

  417. 	ptr[1] = 0;

  418.     }

  419. 

  420.     index+= n;

  421.     s->index= index;

  422.  }

  423. #endif

  424. 

  425. 

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

  427. {

  428. #ifdef ALT_BITSTREAM_WRITER

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

  430. #else

  431. 	return s->buf_ptr;

  432. #endif

  433. }

  434. 

  435. void init_get_bits(GetBitContext *s, 

  436.                    UINT8 *buffer, int buffer_size);

  437. 

  438. #ifndef ALT_BITSTREAM_READER

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

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

  441. #endif

  442. 

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

  444. #ifdef ALT_BITSTREAM_READER

  445. #ifdef ALIGNED_BITSTREAM

  446.     int index= s->index;

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

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

  449. #ifdef ARCH_X86

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

  451.          : "=r" (result1)

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

  453. #else

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

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

  456.     result1|= result2;

  457. #endif

  458.     result1>>= 32 - n;

  459.     index+= n;

  460.     s->index= index;

  461.     

  462.     return result1;

  463. #else //ALIGNED_BITSTREAM

  464.     int index= s->index;

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

  466. 

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

  468.     result>>= 32 - n;

  469.     index+= n;

  470.     s->index= index;

  471. #ifdef DUMP_STREAM

  472.     while(n){

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

  474.         n--;

  475.     }

  476.     printf(" ");

  477. #endif

  478.     return result;

  479. #endif //!ALIGNED_BITSTREAM

  480. #else //ALT_BITSTREAM_READER

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

  482.         /* most common case here */

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

  484.         s->bit_buf <<= n;

  485. 	s->bit_cnt -= n;

  486. #ifdef STATS

  487. 	st_bit_counts[st_current_index] += n;

  488. #endif

  489. 	return val;

  490.     }

  491.     return get_bits_long(s,n);

  492. #endif //!ALT_BITSTREAM_READER

  493. }

  494. 

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

  496. #ifdef ALT_BITSTREAM_READER

  497.     int index= s->index;

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

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

  500.     result>>= 8 - 1;

  501.     index++;

  502.     s->index= index;

  503.     

  504. #ifdef DUMP_STREAM

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

  506. #endif

  507.     return result;

  508. #else

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

  510.         /* most common case here */

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

  512.         s->bit_buf <<= 1;

  513. 	s->bit_cnt--;

  514. #ifdef STATS

  515. 	st_bit_counts[st_current_index]++;

  516. #endif

  517. 	return val;

  518.     }

  519.     return get_bits_long(s,1);

  520. #endif

  521. }

  522. 

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

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

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

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

  527. {

  528. #ifdef ALT_BITSTREAM_READER

  529. #ifdef ALIGNED_BITSTREAM

  530.     int index= s->index;

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

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

  533. #ifdef ARCH_X86

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

  535.          : "=r" (result1)

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

  537. #else

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

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

  540.     result1|= result2;

  541. #endif

  542.     result1>>= 32 - n;

  543.     

  544.     return result1;

  545. #else //ALIGNED_BITSTREAM

  546.     int index= s->index;

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

  548. 

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

  550.     result>>= 32 - n;

  551.     

  552.     return result;

  553. #endif //!ALIGNED_BITSTREAM

  554. #else //ALT_BITSTREAM_READER

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

  556.         /* most common case here */

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

  558.         return val;

  559.     }

  560.     return show_bits_long(s,n);

  561. #endif //!ALT_BITSTREAM_READER

  562. }

  563. 

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

  565. {

  566. #ifdef ALT_BITSTREAM_READER

  567. #ifdef ALIGNED_BITSTREAM

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

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

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

  571. #ifdef ARCH_X86

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

  573.          : "=r" (result1)

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

  575. #else

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

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

  578.     result1|= result2;

  579. #endif

  580.     result1>>= 32 - n;

  581.     

  582.     return result1;

  583. #else //ALIGNED_BITSTREAM

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

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

  586. 

  587.     result>>= 32 - n;

  588.     

  589.     return result;

  590. #endif //!ALIGNED_BITSTREAM

  591. #else //ALT_BITSTREAM_READER

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

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

  594. 

  595.     result>>= 32 - n;

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

  597.     return result;

  598. #endif //!ALT_BITSTREAM_READER

  599. }

  600. 

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

  602. #ifdef ALT_BITSTREAM_READER

  603.     s->index+= n;

  604. #ifdef DUMP_STREAM

  605.     {

  606.         int result;

  607.         s->index-= n;

  608.         result= get_bits(s, n);

  609.     }

  610. #endif

  611. 

  612. #else

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

  614.         /* most common case here */

  615.         s->bit_buf <<= n;

  616. 	s->bit_cnt -= n;

  617. #ifdef STATS

  618. 	st_bit_counts[st_current_index] += n;

  619. #endif

  620.     } else {

  621. 	get_bits_long(s,n);

  622.     }

  623. #endif

  624. }

  625. 

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

  627. #ifdef ALT_BITSTREAM_READER

  628.     s->index++;

  629. #ifdef DUMP_STREAM

  630.     s->index--;

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

  632. #endif

  633. #else

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

  635.         /* most common case here */

  636.         s->bit_buf <<= 1;

  637. 	s->bit_cnt--;

  638. #ifdef STATS

  639. 	st_bit_counts[st_current_index]++;

  640. #endif

  641.     } else {

  642. 	get_bits_long(s,1);

  643.     }

  644. #endif

  645. }

  646. 

  647. static inline int get_bits_count(GetBitContext *s)

  648. {

  649. #ifdef ALT_BITSTREAM_READER

  650.     return s->index;

  651. #else

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

  653. #endif

  654. }

  655. 

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

  657. void align_get_bits(GetBitContext *s);

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

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

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

  661. void free_vlc(VLC *vlc);

  662. 

  663. #ifdef ALT_BITSTREAM_READER

  664. #ifdef ALIGNED_BITSTREAM

  665. #ifdef ARCH_X86

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

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

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

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

  670.          : "=r" (val)\

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

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

  673. #else //ARCH_X86

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

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

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

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

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

  679.     val|= result2;\

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

  681. #endif //!ARCH_X86

  682. #else //ALIGNED_BITSTREAM

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

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

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

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

  687. #endif // !ALIGNED_BITSTREAM

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

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

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

  691. #else

  692. 

  693. /* macro to go faster */

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

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

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

  697. {\

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

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

  700.         bit_cnt += 8;\

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

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

  703.             bit_cnt += 8;\

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

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

  706.                 bit_cnt += 8;\

  707.             }\

  708.         }\

  709.     }\

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

  711. }

  712. 

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

  714. #define FLUSH_BITS(n)\

  715. {\

  716.     bit_buf <<= n;\

  717.     bit_cnt -= n;\

  718. }

  719. 

  720. #define SAVE_BITS(s) \

  721. {\

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

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

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

  725. }

  726. 

  727. #define RESTORE_BITS(s) \

  728. {\

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

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

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

  732. }

  733. #endif // !ALT_BITSTREAM_READER

  734. 

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

  736. {

  737.     int code, n, nb_bits, index;

  738.     INT16 *table_codes;

  739.     INT8 *table_bits;

  740.     int bit_cnt;

  741. #ifndef ALT_BITSTREAM_READER

  742.     UINT32 bit_buf;

  743.     UINT8 *buf_ptr;

  744. #endif

  745. 

  746.     SAVE_BITS(s);

  747.     nb_bits = vlc->bits;

  748.     table_codes = vlc->table_codes;

  749.     table_bits = vlc->table_bits;

  750. 

  751. #ifdef FAST_GET_FIRST_VLC

  752.     SHOW_BITS(s, index, nb_bits);

  753.     code = table_codes[index];

  754.     n = table_bits[index];

  755.     if (n > 0) {

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

  757.         FLUSH_BITS(n);

  758. #ifdef DUMP_STREAM

  759.         {

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

  761.             skip_bits(s, n);

  762.             RESTORE_BITS(s);

  763.         }

  764. #endif

  765.         RESTORE_BITS(s);

  766.         return code;

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

  768.         return -1;

  769.     } else {

  770.         FLUSH_BITS(nb_bits);

  771.         nb_bits = -n;

  772.         table_codes = vlc->table_codes + code;

  773.         table_bits = vlc->table_bits + code;

  774.     }

  775. #endif

  776.     for(;;) {

  777.         SHOW_BITS(s, index, nb_bits);

  778.         code = table_codes[index];

  779.         n = table_bits[index];

  780.         if (n > 0) {

  781.             /* most common case */

  782.             FLUSH_BITS(n);

  783. #ifdef STATS

  784.             st_bit_counts[st_current_index] += n;

  785. #endif

  786.             break;

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

  788.             return -1;

  789.         } else {

  790.             FLUSH_BITS(nb_bits);

  791. #ifdef STATS

  792.             st_bit_counts[st_current_index] += nb_bits;

  793. #endif

  794.             nb_bits = -n;

  795.             table_codes = vlc->table_codes + code;

  796.             table_bits = vlc->table_bits + code;

  797.         }

  798.     }

  799. #ifdef DUMP_STREAM

  800.     {

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

  802.         skip_bits(s, n);

  803.         RESTORE_BITS(s);

  804.     }

  805. #endif

  806.     RESTORE_BITS(s);

  807.     return code;

  808. }

  809. 

  810. 

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

  812.    codec efficiency */

  813. //#define STATS

  814. 

  815. #ifdef STATS

  816. 

  817. enum {

  818.     ST_UNKNOWN,

  819.     ST_DC,

  820.     ST_INTRA_AC,

  821.     ST_INTER_AC,

  822.     ST_INTRA_MB,

  823.     ST_INTER_MB,

  824.     ST_MV,

  825.     ST_NB,

  826. };

  827. 

  828. extern int st_current_index;

  829. extern unsigned int st_bit_counts[ST_NB];

  830. extern unsigned int st_out_bit_counts[ST_NB];

  831. 

  832. void print_stats(void);

  833. #endif

  834. 

  835. /* misc math functions */

  836. 

  837. static inline int av_log2(unsigned int v)

  838. {

  839.     int n;

  840. 

  841.     n = 0;

  842.     if (v & 0xffff0000) {

  843.         v >>= 16;

  844.         n += 16;

  845.     }

  846.     if (v & 0xff00) {

  847.         v >>= 8;

  848.         n += 8;

  849.     }

  850.     if (v & 0xf0) {

  851.         v >>= 4;

  852.         n += 4;

  853.     }

  854.     if (v & 0xc) {

  855.         v >>= 2;

  856.         n += 2;

  857.     }

  858.     if (v & 0x2) {

  859.         n++;

  860.     }

  861.     return n;

  862. }

  863. 

  864. /* median of 3 */

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

  866. {

  867.     int vmin, vmax;

  868.     vmax = vmin = a;

  869.     if (b < vmin)

  870.         vmin = b;

  871.     else

  872. 	vmax = b;

  873. 

  874.     if (c < vmin)

  875.         vmin = c;

  876.     else if (c > vmax)

  877.         vmax = c;

  878. 

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

  880. }

  881. 

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

  883. {

  884.     if (a < amin)

  885.         return amin;

  886.     else if (a > amax)

  887.         return amax;

  888.     else

  889.         return a;

  890. }

  891. 

  892. /* memory */

  893. void *av_malloc(int size);

  894. void *av_mallocz(int size);

  895. void av_free(void *ptr);

  896. void __av_freep(void **ptr);

  897. #define av_freep(p) __av_freep((void **)(p))

  898. 

  899. /* math */

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

  901. 

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

  903. 

  904. #endif