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

529 lines
12KB
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. struct AVOption;

  58. #ifdef HAVE_MMX

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

  60. #else

  61. extern const struct AVOption avoptions_common[3];

  62. #endif

  63. extern const struct AVOption avoptions_workaround_bug[11];

  64. 

  65. #endif /* HAVE_AV_CONFIG_H */

  66. 

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

  68. #ifndef restrict

  69. #    define restrict

  70. #endif

  71. 

  72. #ifndef always_inline

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

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

  75. #else

  76. #    define always_inline inline

  77. #endif

  78. #endif

  79. 

  80. #ifndef attribute_used

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

  82. #    define attribute_used __attribute__((used))

  83. #else

  84. #    define attribute_used

  85. #endif

  86. #endif

  87. 

  88. #ifndef attribute_unused

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

  90. #    define attribute_unused __attribute__((unused))

  91. #else

  92. #    define attribute_unused

  93. #endif

  94. #endif

  95. 

  96. #ifndef EMULATE_INTTYPES

  97. #   include <inttypes.h>

  98. #else

  99.     typedef signed char  int8_t;

  100.     typedef signed short int16_t;

  101.     typedef signed int   int32_t;

  102.     typedef unsigned char  uint8_t;

  103.     typedef unsigned short uint16_t;

  104.     typedef unsigned int   uint32_t;

  105. 

  106. #   ifdef CONFIG_WIN32

  107.         typedef signed __int64   int64_t;

  108.         typedef unsigned __int64 uint64_t;

  109. #   else /* other OS */

  110.         typedef signed long long   int64_t;

  111.         typedef unsigned long long uint64_t;

  112. #   endif /* other OS */

  113. #endif /* HAVE_INTTYPES_H */

  114. 

  115. #ifndef INT16_MIN

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

  117. #endif

  118. 

  119. #ifndef INT16_MAX

  120. #define INT16_MAX       0x7fff

  121. #endif

  122. 

  123. #ifndef INT64_MIN

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

  125. #endif

  126. 

  127. #ifndef INT64_MAX

  128. #define INT64_MAX int64_t_C(9223372036854775807)

  129. #endif

  130. 

  131. #ifndef UINT64_MAX

  132. #define UINT64_MAX uint64_t_C(0xFFFFFFFFFFFFFFFF)

  133. #endif

  134. 

  135. #ifdef EMULATE_FAST_INT

  136. /* note that we don't emulate 64bit ints */

  137. typedef signed char int_fast8_t;

  138. typedef signed int  int_fast16_t;

  139. typedef signed int  int_fast32_t;

  140. typedef unsigned char uint_fast8_t;

  141. typedef unsigned int  uint_fast16_t;

  142. typedef unsigned int  uint_fast32_t;

  143. #endif

  144. 

  145. #ifndef INT_BIT

  146. #    if INT_MAX != 2147483647

  147. #        define INT_BIT 64

  148. #    else

  149. #        define INT_BIT 32

  150. #    endif

  151. #endif

  152. 

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

  154. static inline float floorf(float f) { 

  155.     return floor(f); 

  156. }

  157. #endif

  158. 

  159. #ifdef CONFIG_WIN32

  160. 

  161. /* windows */

  162. 

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

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

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

  166. 

  167. #    ifdef HAVE_AV_CONFIG_H

  168. #            define inline __inline

  169. #    endif

  170. 

  171. #    else

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

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

  174. #    endif /* __MINGW32__ */

  175. 

  176. #    ifdef HAVE_AV_CONFIG_H

  177. #        ifdef _DEBUG

  178. #            define DEBUG

  179. #        endif

  180. 

  181. #        define snprintf _snprintf

  182. #        define vsnprintf _vsnprintf

  183. #    endif

  184. 

  185. /* CONFIG_WIN32 end */

  186. #elif defined (CONFIG_OS2)

  187. /* OS/2 EMX */

  188. 

  189. #ifndef int64_t_C

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

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

  192. #endif

  193. 

  194. #ifdef HAVE_AV_CONFIG_H

  195. 

  196. #ifdef USE_FASTMEMCPY

  197. #include "fastmemcpy.h"

  198. #endif

  199. 

  200. #include <float.h>

  201. 

  202. #endif /* HAVE_AV_CONFIG_H */

  203. 

  204. /* CONFIG_OS2 end */

  205. #else

  206. 

  207. /* unix */

  208. 

  209. #ifndef int64_t_C

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

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

  212. #endif

  213. 

  214. #ifdef HAVE_AV_CONFIG_H

  215. 

  216. #        ifdef USE_FASTMEMCPY

  217. #            include "fastmemcpy.h"

  218. #        endif

  219. #    endif /* HAVE_AV_CONFIG_H */

  220. 

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

  222. 

  223. #ifdef HAVE_AV_CONFIG_H

  224. 

  225. #    include "bswap.h"

  226. 

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

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

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

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

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

  232. #        else

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

  234. #        endif

  235. #    else

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

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

  238. #        else

  239. #            define MANGLE(a) #a

  240. #        endif

  241. #    endif

  242. 

  243. /* debug stuff */

  244. 

  245. #    ifndef DEBUG

  246. #        define NDEBUG

  247. #    endif

  248. #    include <assert.h>

  249. 

  250. /* dprintf macros */

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

  252. 

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

  254. 

  255. #    else

  256. 

  257. #        ifdef DEBUG

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

  259. #        else

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

  261. #        endif

  262. 

  263. #    endif /* !CONFIG_WIN32 */

  264. 

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

  266. 

  267. //rounded divison & shift

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

  269. /* assume b>0 */

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

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

  272. 

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

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

  275. 

  276. extern const uint32_t inverse[256];

  277. 

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

  279. #    define FASTDIV(a,b) \

  280.     ({\

  281.         int ret,dmy;\

  282.         asm volatile(\

  283.             "mull %3"\

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

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

  286.             );\

  287.         ret;\

  288.     })

  289. #elif defined(CONFIG_FASTDIV)

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

  291. #else

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

  293. #endif

  294.  

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

  296.    codec efficiency */

  297. //#define STATS

  298. 

  299. #ifdef STATS

  300. 

  301. enum {

  302.     ST_UNKNOWN,

  303.     ST_DC,

  304.     ST_INTRA_AC,

  305.     ST_INTER_AC,

  306.     ST_INTRA_MB,

  307.     ST_INTER_MB,

  308.     ST_MV,

  309.     ST_NB,

  310. };

  311. 

  312. extern int st_current_index;

  313. extern unsigned int st_bit_counts[ST_NB];

  314. extern unsigned int st_out_bit_counts[ST_NB];

  315. 

  316. void print_stats(void);

  317. #endif

  318. 

  319. /* misc math functions */

  320. extern const uint8_t ff_log2_tab[256];

  321. 

  322. static inline int av_log2(unsigned int v)

  323. {

  324.     int n;

  325. 

  326.     n = 0;

  327.     if (v & 0xffff0000) {

  328.         v >>= 16;

  329.         n += 16;

  330.     }

  331.     if (v & 0xff00) {

  332.         v >>= 8;

  333.         n += 8;

  334.     }

  335.     n += ff_log2_tab[v];

  336. 

  337.     return n;

  338. }

  339. 

  340. static inline int av_log2_16bit(unsigned int v)

  341. {

  342.     int n;

  343. 

  344.     n = 0;

  345.     if (v & 0xff00) {

  346.         v >>= 8;

  347.         n += 8;

  348.     }

  349.     n += ff_log2_tab[v];

  350. 

  351.     return n;

  352. }

  353. 

  354. /* median of 3 */

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

  356. {

  357. #if 0

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

  359.     a-=t;

  360.     b+=t;

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

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

  363. 

  364.     return b;

  365. #else

  366.     if(a>b){

  367.         if(c>b){

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

  369.             else    b=c;

  370.         }

  371.     }else{

  372.         if(b>c){

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

  374.             else    b=a;

  375.         }

  376.     }

  377.     return b;

  378. #endif

  379. }

  380. 

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

  382. {

  383.     if (a < amin)

  384.         return amin;

  385.     else if (a > amax)

  386.         return amax;

  387.     else

  388.         return a;

  389. }

  390. 

  391. static inline int clip_uint8(int a)

  392. {

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

  394.     else          return a;

  395. }

  396. 

  397. /* math */

  398. extern const uint8_t ff_sqrt_tab[128];

  399. 

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

  401. 

  402. static inline int ff_sqrt(int a)

  403. {

  404.     int ret=0;

  405.     int s;

  406.     int ret_sq=0;

  407.     

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

  409.     

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

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

  412.         if(b<=a){

  413.             ret_sq=b;

  414.             ret+= 1<<s;

  415.         }

  416.     }

  417.     return ret;

  418. }

  419. 

  420. /**

  421.  * converts fourcc string to int

  422.  */

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

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

  425. 

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

  427. }

  428. 

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

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

  431. 

  432. 

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

  434. #define MASK_ABS(mask, level)\

  435.             asm volatile(\

  436. 		"cdq			\n\t"\

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

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

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

  440. 	    );

  441. #else

  442. #define MASK_ABS(mask, level)\

  443.             mask= level>>31;\

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

  445. #endif

  446. 

  447. 

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

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

  450. asm volatile (\

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

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

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

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

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

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

  457. );

  458. #else

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

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

  461.      (x)=(y);\

  462.      (a)=(b);\

  463.      (c)=(d);\

  464. }

  465. #endif

  466. 

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

  468. static inline long long rdtsc(void)

  469. {

  470. 	long long l;

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

  472. 		: "=A" (l)

  473. 	);

  474. 	return l;

  475. }

  476. 

  477. #define START_TIMER \

  478. uint64_t tend;\

  479. uint64_t tstart= rdtsc();\

  480. 

  481. #define STOP_TIMER(id) \

  482. tend= rdtsc();\

  483. {\

  484.   static uint64_t tsum=0;\

  485.   static int tcount=0;\

  486.   static int tskip_count=0;\

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

  488.       tsum+= tend - tstart;\

  489.       tcount++;\

  490.   }else\

  491.       tskip_count++;\

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

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

  494.   }\

  495. }

  496. #else

  497. #define START_TIMER 

  498. #define STOP_TIMER(id) {}

  499. #endif

  500. 

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

  502. 

  503. /* avoid usage of various functions */

  504. #define malloc please_use_av_malloc

  505. #define free please_use_av_free

  506. #define realloc please_use_av_realloc

  507. #define time time_is_forbidden_due_to_security_issues

  508. #define rand rand_is_forbidden_due_to_state_trashing

  509. #define srand srand_is_forbidden_due_to_state_trashing

  510. #define sprintf sprintf_is_forbidden_due_to_security_issues_use_snprintf

  511. #define strcat strcat_is_forbidden_due_to_security_issues_use_pstrcat

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

  513. #define printf please_use_av_log

  514. #define fprintf please_use_av_log

  515. #endif

  516. 

  517. #define CHECKED_ALLOCZ(p, size)\

  518. {\

  519.     p= av_mallocz(size);\

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

  521.         perror("malloc");\

  522.         goto fail;\

  523.     }\

  524. }

  525. 

  526. #endif /* HAVE_AV_CONFIG_H */

  527. 

  528. #endif /* COMMON_H */