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

582 lines
13KB
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. #ifndef M_PI

  14. #define M_PI    3.14159265358979323846

  15. #endif

  16. 

  17. #ifdef HAVE_AV_CONFIG_H

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

  19. #    include "config.h"

  20. 

  21. #    include <stdlib.h>

  22. #    include <stdio.h>

  23. #    include <string.h>

  24. #    include <ctype.h>

  25. #    include <limits.h>

  26. #    ifndef __BEOS__

  27. #        include <errno.h>

  28. #    else

  29. #        include "berrno.h"

  30. #    endif

  31. #    include <math.h>

  32. 

  33. #    ifndef ENODATA

  34. #        define ENODATA  61

  35. #    endif

  36. 

  37. #include <stddef.h>

  38. #ifndef offsetof

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

  40. #endif

  41. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  55. #define AVOPTION_END() AVOPTION_SUB(NULL)

  56. 

  57. #endif /* HAVE_AV_CONFIG_H */

  58. 

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

  60. #ifndef restrict

  61. #    define restrict

  62. #endif

  63. 

  64. #ifndef always_inline

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

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

  67. #else

  68. #    define always_inline inline

  69. #endif

  70. #endif

  71. 

  72. #ifndef attribute_used

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

  74. #    define attribute_used __attribute__((used))

  75. #else

  76. #    define attribute_used

  77. #endif

  78. #endif

  79. 

  80. #ifndef attribute_unused

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

  82. #    define attribute_unused __attribute__((unused))

  83. #else

  84. #    define attribute_unused

  85. #endif

  86. #endif

  87. 

  88. #ifndef EMULATE_INTTYPES

  89. #   include <inttypes.h>

  90. #else

  91.     typedef signed char  int8_t;

  92.     typedef signed short int16_t;

  93.     typedef signed int   int32_t;

  94.     typedef unsigned char  uint8_t;

  95.     typedef unsigned short uint16_t;

  96.     typedef unsigned int   uint32_t;

  97. 

  98. #   ifdef CONFIG_WIN32

  99.         typedef signed __int64   int64_t;

  100.         typedef unsigned __int64 uint64_t;

  101. #   else /* other OS */

  102.         typedef signed long long   int64_t;

  103.         typedef unsigned long long uint64_t;

  104. #   endif /* other OS */

  105. #endif /* EMULATE_INTTYPES */

  106. 

  107. #ifndef PRIu64

  108. #define PRIu64 "lld"

  109. #endif

  110. 

  111. #ifndef INT16_MIN

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

  113. #endif

  114. 

  115. #ifndef INT16_MAX

  116. #define INT16_MAX       0x7fff

  117. #endif

  118. 

  119. #ifndef INT64_MIN

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

  121. #endif

  122. 

  123. #ifndef INT64_MAX

  124. #define INT64_MAX int64_t_C(9223372036854775807)

  125. #endif

  126. 

  127. #ifndef UINT64_MAX

  128. #define UINT64_MAX uint64_t_C(0xFFFFFFFFFFFFFFFF)

  129. #endif

  130. 

  131. #ifdef EMULATE_FAST_INT

  132. typedef signed char int_fast8_t;

  133. typedef signed int  int_fast16_t;

  134. typedef signed int  int_fast32_t;

  135. typedef unsigned char uint_fast8_t;

  136. typedef unsigned int  uint_fast16_t;

  137. typedef unsigned int  uint_fast32_t;

  138. typedef uint64_t      uint_fast64_t;

  139. #endif

  140. 

  141. #ifndef INT_BIT

  142. #    if INT_MAX != 2147483647

  143. #        define INT_BIT 64

  144. #    else

  145. #        define INT_BIT 32

  146. #    endif

  147. #endif

  148. 

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

  150. static inline float floorf(float f) { 

  151.     return floor(f); 

  152. }

  153. #endif

  154. 

  155. #ifdef CONFIG_WIN32

  156. 

  157. /* windows */

  158. 

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

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

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

  162. 

  163. #    ifdef HAVE_AV_CONFIG_H

  164. #            define inline __inline

  165. #    endif

  166. 

  167. #    else

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

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

  170. #    endif /* __MINGW32__ */

  171. 

  172. #    ifdef HAVE_AV_CONFIG_H

  173. #        ifdef _DEBUG

  174. #            define DEBUG

  175. #        endif

  176. 

  177. #        define snprintf _snprintf

  178. #        define vsnprintf _vsnprintf

  179. #    endif

  180. 

  181. /* CONFIG_WIN32 end */

  182. #elif defined (CONFIG_OS2)

  183. /* OS/2 EMX */

  184. 

  185. #ifndef int64_t_C

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

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

  188. #endif

  189. 

  190. #ifdef HAVE_AV_CONFIG_H

  191. 

  192. #ifdef USE_FASTMEMCPY

  193. #include "fastmemcpy.h"

  194. #endif

  195. 

  196. #include <float.h>

  197. 

  198. #endif /* HAVE_AV_CONFIG_H */

  199. 

  200. /* CONFIG_OS2 end */

  201. #else

  202. 

  203. /* unix */

  204. 

  205. #ifndef int64_t_C

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

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

  208. #endif

  209. 

  210. #ifdef HAVE_AV_CONFIG_H

  211. 

  212. #        ifdef USE_FASTMEMCPY

  213. #            include "fastmemcpy.h"

  214. #        endif

  215. #    endif /* HAVE_AV_CONFIG_H */

  216. 

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

  218. 

  219. #ifdef HAVE_AV_CONFIG_H

  220. 

  221. #    include "bswap.h"

  222. 

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

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

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

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

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

  228. #        else

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

  230. #        endif

  231. #    else

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

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

  234. #        else

  235. #            define MANGLE(a) #a

  236. #        endif

  237. #    endif

  238. 

  239. /* debug stuff */

  240. 

  241. #    ifndef DEBUG

  242. #        define NDEBUG

  243. #    endif

  244. #    include <assert.h>

  245. 

  246. /* dprintf macros */

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

  248. 

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

  250. 

  251. #    else

  252. 

  253. #        ifdef DEBUG

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

  255. #        else

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

  257. #        endif

  258. 

  259. #    endif /* !CONFIG_WIN32 */

  260. 

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

  262. 

  263. //rounded divison & shift

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

  265. /* assume b>0 */

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

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

  268. 

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

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

  271. 

  272. extern const uint32_t inverse[256];

  273. 

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

  275. #    define FASTDIV(a,b) \

  276.     ({\

  277.         int ret,dmy;\

  278.         asm volatile(\

  279.             "mull %3"\

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

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

  282.             );\

  283.         ret;\

  284.     })

  285. #elif defined(CONFIG_FASTDIV)

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

  287. #else

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

  289. #endif

  290.  

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

  292.    codec efficiency */

  293. //#define STATS

  294. 

  295. #ifdef STATS

  296. 

  297. enum {

  298.     ST_UNKNOWN,

  299.     ST_DC,

  300.     ST_INTRA_AC,

  301.     ST_INTER_AC,

  302.     ST_INTRA_MB,

  303.     ST_INTER_MB,

  304.     ST_MV,

  305.     ST_NB,

  306. };

  307. 

  308. extern int st_current_index;

  309. extern unsigned int st_bit_counts[ST_NB];

  310. extern unsigned int st_out_bit_counts[ST_NB];

  311. 

  312. void print_stats(void);

  313. #endif

  314. 

  315. /* misc math functions */

  316. extern const uint8_t ff_log2_tab[256];

  317. 

  318. static inline int av_log2(unsigned int v)

  319. {

  320.     int n;

  321. 

  322.     n = 0;

  323.     if (v & 0xffff0000) {

  324.         v >>= 16;

  325.         n += 16;

  326.     }

  327.     if (v & 0xff00) {

  328.         v >>= 8;

  329.         n += 8;

  330.     }

  331.     n += ff_log2_tab[v];

  332. 

  333.     return n;

  334. }

  335. 

  336. static inline int av_log2_16bit(unsigned int v)

  337. {

  338.     int n;

  339. 

  340.     n = 0;

  341.     if (v & 0xff00) {

  342.         v >>= 8;

  343.         n += 8;

  344.     }

  345.     n += ff_log2_tab[v];

  346. 

  347.     return n;

  348. }

  349. 

  350. /* median of 3 */

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

  352. {

  353. #if 0

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

  355.     a-=t;

  356.     b+=t;

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

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

  359. 

  360.     return b;

  361. #else

  362.     if(a>b){

  363.         if(c>b){

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

  365.             else    b=c;

  366.         }

  367.     }else{

  368.         if(b>c){

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

  370.             else    b=a;

  371.         }

  372.     }

  373.     return b;

  374. #endif

  375. }

  376. 

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

  378. {

  379.     if (a < amin)

  380.         return amin;

  381.     else if (a > amax)

  382.         return amax;

  383.     else

  384.         return a;

  385. }

  386. 

  387. static inline int clip_uint8(int a)

  388. {

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

  390.     else          return a;

  391. }

  392. 

  393. /* math */

  394. extern const uint8_t ff_sqrt_tab[128];

  395. 

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

  397. 

  398. static inline int ff_sqrt(int a)

  399. {

  400.     int ret=0;

  401.     int s;

  402.     int ret_sq=0;

  403.     

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

  405.     

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

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

  408.         if(b<=a){

  409.             ret_sq=b;

  410.             ret+= 1<<s;

  411.         }

  412.     }

  413.     return ret;

  414. }

  415. 

  416. /**

  417.  * converts fourcc string to int

  418.  */

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

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

  421. 

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

  423. }

  424. 

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

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

  427. 

  428. 

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

  430. #define MASK_ABS(mask, level)\

  431.             asm volatile(\

  432. 		"cdq			\n\t"\

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

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

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

  436. 	    );

  437. #else

  438. #define MASK_ABS(mask, level)\

  439.             mask= level>>31;\

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

  441. #endif

  442. 

  443. 

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

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

  446. asm volatile (\

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

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

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

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

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

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

  453. );

  454. #else

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

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

  457.      (x)=(y);\

  458.      (a)=(b);\

  459.      (c)=(d);\

  460. }

  461. #endif

  462. 

  463. #if defined(ARCH_X86) || defined(ARCH_X86_64) || defined(ARCH_POWERPC)

  464. #if defined(ARCH_X86_64)

  465. static inline uint64_t read_time(void)

  466. {

  467. 	uint64_t a, d;

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

  469. 		: "=a" (a), "=d" (d)

  470. 	);

  471. 	return (d << 32) | (a & 0xffffffff);

  472. }

  473. #elif defined(ARCH_X86)

  474. static inline long long read_time(void)

  475. {

  476. 	long long l;

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

  478. 		: "=A" (l)

  479. 	);

  480. 	return l;

  481. }

  482. #else //FIXME check ppc64

  483. static inline uint64_t read_time(void)

  484. {

  485.     uint32_t tbu, tbl, temp;

  486. 

  487.      /* from section 2.2.1 of the 32-bit PowerPC PEM */

  488.      __asm__ __volatile__(

  489.          "1:\n"

  490.          "mftbu  %2\n"

  491.          "mftb   %0\n"

  492.          "mftbu  %1\n"

  493.          "cmpw   %2,%1\n"

  494.          "bne    1b\n"

  495.      : "=r"(tbl), "=r"(tbu), "=r"(temp)

  496.      :

  497.      : "cc");

  498. 

  499.      return (((uint64_t)tbu)<<32) | (uint64_t)tbl;

  500. }

  501. #endif

  502. 

  503. #define START_TIMER \

  504. uint64_t tend;\

  505. uint64_t tstart= read_time();\

  506. 

  507. #define STOP_TIMER(id) \

  508. tend= read_time();\

  509. {\

  510.   static uint64_t tsum=0;\

  511.   static int tcount=0;\

  512.   static int tskip_count=0;\

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

  514.       tsum+= tend - tstart;\

  515.       tcount++;\

  516.   }else\

  517.       tskip_count++;\

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

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

  520.   }\

  521. }

  522. #else

  523. #define START_TIMER 

  524. #define STOP_TIMER(id) {}

  525. #endif

  526. 

  527. /* avoid usage of various functions */

  528. #define malloc please_use_av_malloc

  529. #define free please_use_av_free

  530. #define realloc please_use_av_realloc

  531. #define time time_is_forbidden_due_to_security_issues

  532. #define rand rand_is_forbidden_due_to_state_trashing

  533. #define srand srand_is_forbidden_due_to_state_trashing

  534. #define sprintf sprintf_is_forbidden_due_to_security_issues_use_snprintf

  535. #define strcat strcat_is_forbidden_due_to_security_issues_use_pstrcat

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

  537. #define printf please_use_av_log

  538. #define fprintf please_use_av_log

  539. #endif

  540. 

  541. #define CHECKED_ALLOCZ(p, size)\

  542. {\

  543.     p= av_mallocz(size);\

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

  545.         perror("malloc");\

  546.         goto fail;\

  547.     }\

  548. }

  549. 

  550. #ifndef HAVE_LRINTF

  551. /* XXX: add ISOC specific test to avoid specific BSD testing. */

  552. /* better than nothing implementation. */

  553. /* btw, rintf() is existing on fbsd too -- alex */

  554. static always_inline long int lrintf(float x)

  555. {

  556. #ifdef CONFIG_WIN32

  557. #  ifdef ARCH_X86

  558.     int32_t i;

  559.     asm volatile(

  560.         "fistpl %0\n\t"

  561.         : "=m" (i) : "t" (x) : "st"

  562.     );

  563.     return i;

  564. #  else

  565.     /* XXX: incorrect, but make it compile */

  566.     return (int)(x + (x < 0 ? -0.5 : 0.5));

  567. #  endif /* ARCH_X86 */

  568. #else

  569.     return (int)(rint(x));

  570. #endif /* CONFIG_WIN32 */

  571. }

  572. #else

  573. #ifndef _ISOC9X_SOURCE

  574. #define _ISOC9X_SOURCE

  575. #endif

  576. #include <math.h>

  577. #endif /* HAVE_LRINTF */

  578. 

  579. #endif /* HAVE_AV_CONFIG_H */

  580. 

  581. #endif /* COMMON_H */