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

1141 lines
27KB
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. extern const uint32_t inverse[256];

  201. 

  202. #ifdef ARCH_X86

  203. #    define FASTDIV(a,b) \

  204.     ({\

  205.         int ret,dmy;\

  206.         asm volatile(\

  207.             "mull %3"\

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

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

  210.             );\

  211.         ret;\

  212.     })

  213. #elif defined(CONFIG_FASTDIV)

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

  215. #else

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

  217. #endif

  218.  

  219. #ifdef ARCH_X86

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

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

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

  223.          : "+r" (a)

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

  225.     );

  226.     return a;

  227. }

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

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

  230.          : "+r" (a)

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

  232.     );

  233.     return a;

  234. }

  235. #else

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

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

  238. #endif

  239. 

  240. /* bit output */

  241. 

  242. struct PutBitContext;

  243. 

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

  245. 

  246. typedef struct PutBitContext {

  247. #ifdef ALT_BITSTREAM_WRITER

  248.     uint8_t *buf, *buf_end;

  249.     int index;

  250. #else

  251.     uint32_t bit_buf;

  252.     int bit_left;

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

  254. #endif

  255.     int64_t data_out_size; /* in bytes */

  256. } PutBitContext;

  257. 

  258. void init_put_bits(PutBitContext *s, 

  259.                    uint8_t *buffer, int buffer_size,

  260.                    void *opaque,

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

  262. 

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

  264. void align_put_bits(PutBitContext *s);

  265. void flush_put_bits(PutBitContext *s);

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

  267. 

  268. /* bit input */

  269. 

  270. typedef struct GetBitContext {

  271.     const uint8_t *buffer, *buffer_end;

  272. #ifdef ALT_BITSTREAM_READER

  273.     int index;

  274. #elif defined LIBMPEG2_BITSTREAM_READER

  275.     uint8_t *buffer_ptr;

  276.     uint32_t cache;

  277.     int bit_count;

  278. #elif defined A32_BITSTREAM_READER

  279.     uint32_t *buffer_ptr;

  280.     uint32_t cache0;

  281.     uint32_t cache1;

  282.     int bit_count;

  283. #endif

  284.     int size_in_bits;

  285. } GetBitContext;

  286. 

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

  288. 

  289. #define VLC_TYPE int16_t

  290. 

  291. typedef struct VLC {

  292.     int bits;

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

  294.     int table_size, table_allocated;

  295. } VLC;

  296. 

  297. typedef struct RL_VLC_ELEM {

  298.     int16_t level;

  299.     int8_t len;

  300.     uint8_t run;

  301. } RL_VLC_ELEM;

  302. 

  303. #ifdef ARCH_SPARC64

  304. #define UNALIGNED_STORES_ARE_BAD

  305. #endif

  306. 

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

  308. #ifdef ARCH_X86

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

  310. #else

  311. #    ifdef __GNUC__

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

  313.     struct Unaligned {

  314. 	uint32_t i;

  315.     } __attribute__((packed));

  316. 

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

  318. }

  319. #    elif defined(__DECC)

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

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

  322. }

  323. #    else

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

  325.     return *(const uint32_t *) v;

  326. }

  327. #    endif

  328. #endif //!ARCH_X86

  329. 

  330. #ifndef ALT_BITSTREAM_WRITER

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

  332. {

  333.     unsigned int bit_buf;

  334.     int bit_left;

  335. 

  336. #ifdef STATS

  337.     st_out_bit_counts[st_current_index] += n;

  338. #endif

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

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

  341.     

  342.     bit_buf = s->bit_buf;

  343.     bit_left = s->bit_left;

  344. 

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

  346.     /* XXX: optimize */

  347.     if (n < bit_left) {

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

  349.         bit_left-=n;

  350.     } else {

  351. 	bit_buf<<=bit_left;

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

  353. #ifdef UNALIGNED_STORES_ARE_BAD

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

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

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

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

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

  359.         } else

  360. #endif

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

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

  363.         s->buf_ptr+=4;

  364. 	bit_left+=32 - n;

  365.         bit_buf = value;

  366.     }

  367. 

  368.     s->bit_buf = bit_buf;

  369.     s->bit_left = bit_left;

  370. }

  371. #endif

  372. 

  373. 

  374. #ifdef ALT_BITSTREAM_WRITER

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

  376. {

  377. #    ifdef ALIGNED_BITSTREAM_WRITER

  378. #        ifdef ARCH_X86

  379.     asm volatile(

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

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

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

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

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

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

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

  387. 	"bswapl %1			\n\t"

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

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

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

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

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

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

  394. 	: "%eax", "%ecx"

  395.     );

  396. #        else

  397.     int index= s->index;

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

  399.     

  400.     value<<= 32-n; 

  401.     

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

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

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

  405.     index+= n;

  406.     s->index= index;

  407. #        endif

  408. #    else //ALIGNED_BITSTREAM_WRITER

  409. #        ifdef ARCH_X86

  410.     asm volatile(

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

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

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

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

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

  416. 	"bswapl %1			\n\t"

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

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

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

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

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

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

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

  424. 	: "%ecx"

  425.     );

  426. #        else

  427.     int index= s->index;

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

  429.     

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

  431.     ptr[1] = 0;

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

  433.     index+= n;

  434.     s->index= index;

  435. #        endif

  436. #    endif //!ALIGNED_BITSTREAM_WRITER

  437. }

  438. #endif

  439. 

  440. 

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

  442. {

  443. #ifdef ALT_BITSTREAM_WRITER

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

  445. #else

  446. 	return s->buf_ptr;

  447. #endif

  448. }

  449. 

  450. /* Bitstream reader API docs:

  451. name

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

  453. 

  454. gb

  455.     getbitcontext

  456. 

  457. OPEN_READER(name, gb)

  458.     loads gb into local variables

  459. 

  460. CLOSE_READER(name, gb)

  461.     stores local vars in gb

  462. 

  463. UPDATE_CACHE(name, gb)

  464.     refills the internal cache from the bitstream

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

  466. 

  467. GET_CACHE(name, gb)

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

  469. 

  470. SHOW_UBITS(name, gb, num)

  471.     will return the nest num bits

  472. 

  473. SHOW_SBITS(name, gb, num)

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

  475. 

  476. SKIP_BITS(name, gb, num)

  477.     will skip over the next num bits

  478.     note, this is equinvalent to SKIP_CACHE; SKIP_COUNTER

  479. 

  480. SKIP_CACHE(name, gb, num)

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

  482. 

  483. SKIP_COUNTER(name, gb, num)

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

  485. 

  486. LAST_SKIP_CACHE(name, gb, num)

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

  488. 

  489. LAST_SKIP_BITS(name, gb, num)

  490.     is equinvalent to SKIP_LAST_CACHE; SKIP_COUNTER

  491. 

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

  493. */

  494. 

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

  496. {

  497. #ifdef CONFIG_ALIGN

  498. 	const uint8_t *p=v;

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

  500. #else

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

  502. #endif

  503. }

  504. 

  505. #ifdef ALT_BITSTREAM_READER

  506. #   define MIN_CACHE_BITS 25

  507. 

  508. #   define OPEN_READER(name, gb)\

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

  510.         int name##_cache= 0;\

  511. 

  512. #   define CLOSE_READER(name, gb)\

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

  514. 

  515. #   define UPDATE_CACHE(name, gb)\

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

  517. 

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

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

  520. 

  521. // FIXME name?

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

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

  524. 

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

  526.         {\

  527.             SKIP_CACHE(name, gb, num)\

  528.             SKIP_COUNTER(name, gb, num)\

  529.         }\

  530. 

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

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

  533. 

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

  535.         NEG_USR32(name##_cache, num)

  536. 

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

  538.         NEG_SSR32(name##_cache, num)

  539. 

  540. #   define GET_CACHE(name, gb)\

  541.         ((uint32_t)name##_cache)

  542. 

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

  544.     return s->index;

  545. }

  546. #elif defined LIBMPEG2_BITSTREAM_READER

  547. //libmpeg2 like reader

  548. 

  549. #   define MIN_CACHE_BITS 17

  550. 

  551. #   define OPEN_READER(name, gb)\

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

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

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

  555. 

  556. #   define CLOSE_READER(name, gb)\

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

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

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

  560. 

  561. #ifdef LIBMPEG2_BITSTREAM_READER_HACK

  562. 

  563. #   define UPDATE_CACHE(name, gb)\

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

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

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

  567.         name##_bit_count-= 16;\

  568.     }\

  569. 

  570. #else

  571. 

  572. #   define UPDATE_CACHE(name, gb)\

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

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

  575.         name##_buffer_ptr+=2;\

  576.         name##_bit_count-= 16;\

  577.     }\

  578. 

  579. #endif

  580. 

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

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

  583. 

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

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

  586. 

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

  588.         {\

  589.             SKIP_CACHE(name, gb, num)\

  590.             SKIP_COUNTER(name, gb, num)\

  591.         }\

  592. 

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

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

  595. 

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

  597.         NEG_USR32(name##_cache, num)

  598. 

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

  600.         NEG_SSR32(name##_cache, num)

  601. 

  602. #   define GET_CACHE(name, gb)\

  603.         ((uint32_t)name##_cache)

  604. 

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

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

  607. }

  608. 

  609. #elif defined A32_BITSTREAM_READER

  610. 

  611. #   define MIN_CACHE_BITS 32

  612. 

  613. #   define OPEN_READER(name, gb)\

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

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

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

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

  618. 

  619. #   define CLOSE_READER(name, gb)\

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

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

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

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

  624. 

  625. #   define UPDATE_CACHE(name, gb)\

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

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

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

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

  630.         name##_buffer_ptr++;\

  631.         name##_bit_count-= 32;\

  632.     }\

  633. 

  634. #ifdef ARCH_X86

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

  636.         asm(\

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

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

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

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

  641.            );

  642. #else

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

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

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

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

  647. #endif

  648. 

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

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

  651. 

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

  653.         {\

  654.             SKIP_CACHE(name, gb, num)\

  655.             SKIP_COUNTER(name, gb, num)\

  656.         }\

  657. 

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

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

  660. 

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

  662.         NEG_USR32(name##_cache0, num)

  663. 

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

  665.         NEG_SSR32(name##_cache0, num)

  666. 

  667. #   define GET_CACHE(name, gb)\

  668.         (name##_cache0)

  669. 

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

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

  672. }

  673. 

  674. #endif

  675. 

  676. /**

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

  678.  * if MSB not set it is negative 

  679.  * @param n length in bits

  680.  * @author BERO  

  681.  */

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

  683.     register int tmp;

  684.     register int32_t cache;

  685.     OPEN_READER(re, s)

  686.     UPDATE_CACHE(re, s)

  687.     cache = GET_CACHE(re,s);

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

  689.         tmp = NEG_USR32(cache,n);

  690.     } else {

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

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

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

  694.     }

  695.     LAST_SKIP_BITS(re, s, n)

  696.     CLOSE_READER(re, s)

  697.     return tmp;

  698. }

  699. 

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

  701.     register int tmp;

  702.     OPEN_READER(re, s)

  703.     UPDATE_CACHE(re, s)

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

  705.     LAST_SKIP_BITS(re, s, n)

  706.     CLOSE_READER(re, s)

  707.     return tmp;

  708. }

  709. 

  710. /**

  711.  * reads 0-17 bits.

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

  713.  */

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

  715.     register int tmp;

  716.     OPEN_READER(re, s)

  717.     UPDATE_CACHE(re, s)

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

  719.     LAST_SKIP_BITS(re, s, n)

  720.     CLOSE_READER(re, s)

  721.     return tmp;

  722. }

  723. 

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

  725. 

  726. /**

  727.  * shows 0-17 bits.

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

  729.  */

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

  731.     register int tmp;

  732.     OPEN_READER(re, s)

  733.     UPDATE_CACHE(re, s)

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

  735. //    CLOSE_READER(re, s)

  736.     return tmp;

  737. }

  738. 

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

  740. 

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

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

  743.     OPEN_READER(re, s)

  744.     UPDATE_CACHE(re, s)

  745.     LAST_SKIP_BITS(re, s, n)

  746.     CLOSE_READER(re, s)

  747. }

  748. 

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

  750. #ifdef ALT_BITSTREAM_READER

  751.     int index= s->index;

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

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

  754.     result>>= 8 - 1;

  755.     index++;

  756.     s->index= index;

  757. 

  758.     return result;

  759. #else

  760.     return get_bits(s, 1);

  761. #endif

  762. }

  763. 

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

  765.     return show_bits(s, 1);

  766. }

  767. 

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

  769.     skip_bits(s, 1);

  770. }

  771. 

  772. void init_get_bits(GetBitContext *s,

  773.                    const uint8_t *buffer, int buffer_size);

  774. 

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

  776. void align_get_bits(GetBitContext *s);

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

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

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

  780. void free_vlc(VLC *vlc);

  781. 

  782. /**

  783.  *

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

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

  786.  * is undefined

  787.  */

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

  789. {\

  790.     int n, index, nb_bits;\

  791. \

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

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

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

  795. \

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

  797.         LAST_SKIP_BITS(name, gb, bits)\

  798.         UPDATE_CACHE(name, gb)\

  799. \

  800.         nb_bits = -n;\

  801. \

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

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

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

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

  806.             LAST_SKIP_BITS(name, gb, nb_bits)\

  807.             UPDATE_CACHE(name, gb)\

  808. \

  809.             nb_bits = -n;\

  810. \

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

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

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

  814.         }\

  815.     }\

  816.     SKIP_BITS(name, gb, n)\

  817. }

  818. 

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

  820. {\

  821.     int n, index, nb_bits;\

  822. \

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

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

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

  826. \

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

  828.         LAST_SKIP_BITS(name, gb, bits)\

  829.         UPDATE_CACHE(name, gb)\

  830. \

  831.         nb_bits = -n;\

  832. \

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

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

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

  836.     }\

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

  838.     SKIP_BITS(name, gb, n)\

  839. }

  840. 

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

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

  843. {

  844.     int code;

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

  846.     

  847.     OPEN_READER(re, s)

  848.     UPDATE_CACHE(re, s)

  849. 

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

  851. 

  852.     CLOSE_READER(re, s)

  853.     return code;

  854. }

  855. 

  856. /**

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

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

  859.  *             identical to nb_bits in init_vlc()

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

  861.  *                  read the longest vlc code 

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

  863.  */

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

  865.                                   int bits, int max_depth)

  866. {

  867.     int code;

  868.     

  869.     OPEN_READER(re, s)

  870.     UPDATE_CACHE(re, s)

  871. 

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

  873. 

  874.     CLOSE_READER(re, s)

  875.     return code;

  876. }

  877. 

  878. //#define TRACE

  879. 

  880. #ifdef TRACE

  881. 

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

  883.     int i;

  884.     

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

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

  887.     }

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

  889.         printf(" ");

  890. }

  891. 

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

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

  894.     

  895.     print_bin(r, n);

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

  897.     return r;

  898. }

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

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

  901.     int pos= get_bits_count(s);

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

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

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

  905.     

  906.     print_bin(bits2, len);

  907.     

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

  909.     return r;

  910. }

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

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

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

  914.     

  915.     print_bin(show, n);

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

  917.     return r;

  918. }

  919. 

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

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

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

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

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

  925. 

  926. #define tprintf printf

  927. 

  928. #else //TRACE

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

  930. #endif

  931. 

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

  933.    codec efficiency */

  934. //#define STATS

  935. 

  936. #ifdef STATS

  937. 

  938. enum {

  939.     ST_UNKNOWN,

  940.     ST_DC,

  941.     ST_INTRA_AC,

  942.     ST_INTER_AC,

  943.     ST_INTRA_MB,

  944.     ST_INTER_MB,

  945.     ST_MV,

  946.     ST_NB,

  947. };

  948. 

  949. extern int st_current_index;

  950. extern unsigned int st_bit_counts[ST_NB];

  951. extern unsigned int st_out_bit_counts[ST_NB];

  952. 

  953. void print_stats(void);

  954. #endif

  955. 

  956. /* misc math functions */

  957. extern const uint8_t ff_log2_tab[256];

  958. 

  959. static inline int av_log2(unsigned int v)

  960. {

  961.     int n;

  962. 

  963.     n = 0;

  964.     if (v & 0xffff0000) {

  965.         v >>= 16;

  966.         n += 16;

  967.     }

  968.     if (v & 0xff00) {

  969.         v >>= 8;

  970.         n += 8;

  971.     }

  972.     n += ff_log2_tab[v];

  973. 

  974.     return n;

  975. }

  976. 

  977. static inline int av_log2_16bit(unsigned int v)

  978. {

  979.     int n;

  980. 

  981.     n = 0;

  982.     if (v & 0xff00) {

  983.         v >>= 8;

  984.         n += 8;

  985.     }

  986.     n += ff_log2_tab[v];

  987. 

  988.     return n;

  989. }

  990. 

  991. 

  992. /* median of 3 */

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

  994. {

  995.     int vmin, vmax;

  996.     vmax = vmin = a;

  997.     if (b < vmin)

  998.         vmin = b;

  999.     else

  1000. 	vmax = b;

  1001. 

  1002.     if (c < vmin)

  1003.         vmin = c;

  1004.     else if (c > vmax)

  1005.         vmax = c;

  1006. 

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

  1008. }

  1009. 

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

  1011. {

  1012.     if (a < amin)

  1013.         return amin;

  1014.     else if (a > amax)

  1015.         return amax;

  1016.     else

  1017.         return a;

  1018. }

  1019. 

  1020. /* math */

  1021. extern const uint8_t ff_sqrt_tab[128];

  1022. 

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

  1024. 

  1025. static inline int ff_sqrt(int a)

  1026. {

  1027.     int ret=0;

  1028.     int s;

  1029.     int ret_sq=0;

  1030.     

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

  1032.     

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

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

  1035.         if(b<=a){

  1036.             ret_sq=b;

  1037.             ret+= 1<<s;

  1038.         }

  1039.     }

  1040.     return ret;

  1041. }

  1042. 

  1043. /**

  1044.  * converts fourcc string to int

  1045.  */

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

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

  1048.     

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

  1050. }

  1051. 

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

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

  1054. 

  1055. 

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

  1057. 

  1058. 

  1059. #ifdef ARCH_X86

  1060. #define MASK_ABS(mask, level)\

  1061.             asm volatile(\

  1062. 		"cdq			\n\t"\

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

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

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

  1066. 	    );

  1067. #else

  1068. #define MASK_ABS(mask, level)\

  1069.             mask= level>>31;\

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

  1071. #endif

  1072. 

  1073. 

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

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

  1076. asm volatile (\

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

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

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

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

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

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

  1083. );

  1084. #else

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

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

  1087.      (x)=(y);\

  1088.      (a)=(b);\

  1089.      (c)=(d);\

  1090. }

  1091. #endif

  1092. 

  1093. #ifdef ARCH_X86

  1094. static inline long long rdtsc()

  1095. {

  1096. 	long long l;

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

  1098. 		: "=A" (l)

  1099. 	);

  1100. 	return l;

  1101. }

  1102. 

  1103. #define START_TIMER \

  1104. static uint64_t tsum=0;\

  1105. static int tcount=0;\

  1106. static int tskip_count=0;\

  1107. uint64_t tend;\

  1108. uint64_t tstart= rdtsc();\

  1109. 

  1110. #define STOP_TIMER(id) \

  1111. tend= rdtsc();\

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

  1113.     tsum+= tend - tstart;\

  1114.     tcount++;\

  1115. }else\

  1116.     tskip_count++;\

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

  1118.     fprintf(stderr, "%Ld dezicycles in %s, %d runs, %d skips\n", tsum*10/tcount, id, tcount, tskip_count);\

  1119. }

  1120. #endif

  1121. 

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

  1123. 

  1124. /* avoid usage of various functions */

  1125. #define malloc please_use_av_malloc

  1126. #define free please_use_av_free

  1127. #define realloc please_use_av_realloc

  1128. 

  1129. #define CHECKED_ALLOCZ(p, size)\

  1130. {\

  1131.     p= av_mallocz(size);\

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

  1133.         perror("malloc");\

  1134.         goto fail;\

  1135.     }\

  1136. }

  1137. 

  1138. #endif /* HAVE_AV_CONFIG_H */

  1139. 

  1140. #endif /* COMMON_H */