LCOV - code coverage report
Current view: top level - libavcodec - mathops.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 36 36 100.0 %
Date: 2017-12-14 01:15:32 Functions: 9 9 100.0 %

          Line data    Source code
       1             : /*
       2             :  * simple math operations
       3             :  * Copyright (c) 2001, 2002 Fabrice Bellard
       4             :  * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> et al
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : #ifndef AVCODEC_MATHOPS_H
      23             : #define AVCODEC_MATHOPS_H
      24             : 
      25             : #include <stdint.h>
      26             : 
      27             : #include "libavutil/common.h"
      28             : #include "libavutil/reverse.h"
      29             : #include "config.h"
      30             : 
      31             : #define MAX_NEG_CROP 1024
      32             : 
      33             : extern const uint32_t ff_inverse[257];
      34             : extern const uint8_t ff_sqrt_tab[256];
      35             : extern const uint8_t ff_crop_tab[256 + 2 * MAX_NEG_CROP];
      36             : extern const uint8_t ff_zigzag_direct[64];
      37             : extern const uint8_t ff_zigzag_scan[16+1];
      38             : 
      39             : #if   ARCH_ARM
      40             : #   include "arm/mathops.h"
      41             : #elif ARCH_AVR32
      42             : #   include "avr32/mathops.h"
      43             : #elif ARCH_MIPS
      44             : #   include "mips/mathops.h"
      45             : #elif ARCH_PPC
      46             : #   include "ppc/mathops.h"
      47             : #elif ARCH_X86
      48             : #   include "x86/mathops.h"
      49             : #endif
      50             : 
      51             : /* generic implementation */
      52             : 
      53             : #ifndef MUL64
      54             : #   define MUL64(a,b) ((int64_t)(a) * (int64_t)(b))
      55             : #endif
      56             : 
      57             : #ifndef MULL
      58             : #   define MULL(a,b,s) (MUL64(a, b) >> (s))
      59             : #endif
      60             : 
      61             : #ifndef MULH
      62    33106172 : static av_always_inline int MULH(int a, int b){
      63    33106172 :     return MUL64(a, b) >> 32;
      64             : }
      65             : #endif
      66             : 
      67             : #ifndef UMULH
      68         499 : static av_always_inline unsigned UMULH(unsigned a, unsigned b){
      69         499 :     return ((uint64_t)(a) * (uint64_t)(b))>>32;
      70             : }
      71             : #endif
      72             : 
      73             : #ifndef MAC64
      74             : #   define MAC64(d, a, b) ((d) += MUL64(a, b))
      75             : #endif
      76             : 
      77             : #ifndef MLS64
      78             : #   define MLS64(d, a, b) ((d) -= MUL64(a, b))
      79             : #endif
      80             : 
      81             : /* signed 16x16 -> 32 multiply add accumulate */
      82             : #ifndef MAC16
      83             : #   define MAC16(rt, ra, rb) rt += (ra) * (rb)
      84             : #endif
      85             : 
      86             : /* signed 16x16 -> 32 multiply */
      87             : #ifndef MUL16
      88             : #   define MUL16(ra, rb) ((ra) * (rb))
      89             : #endif
      90             : 
      91             : #ifndef MLS16
      92             : #   define MLS16(rt, ra, rb) ((rt) -= (ra) * (rb))
      93             : #endif
      94             : 
      95             : /* median of 3 */
      96             : #ifndef mid_pred
      97             : #define mid_pred mid_pred
      98             : static inline av_const int mid_pred(int a, int b, int c)
      99             : {
     100             :     if(a>b){
     101             :         if(c>b){
     102             :             if(c>a) b=a;
     103             :             else    b=c;
     104             :         }
     105             :     }else{
     106             :         if(b>c){
     107             :             if(c>a) b=c;
     108             :             else    b=a;
     109             :         }
     110             :     }
     111             :     return b;
     112             : }
     113             : #endif
     114             : 
     115             : #ifndef median4
     116             : #define median4 median4
     117       65958 : static inline av_const int median4(int a, int b, int c, int d)
     118             : {
     119       65958 :     if (a < b) {
     120        7910 :         if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
     121        5996 :         else       return (FFMIN(b, c) + FFMAX(a, d)) / 2;
     122             :     } else {
     123       58048 :         if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
     124       53882 :         else       return (FFMIN(a, c) + FFMAX(b, d)) / 2;
     125             :     }
     126             : }
     127             : #endif
     128             : 
     129             : #ifndef sign_extend
     130    58320568 : static inline av_const int sign_extend(int val, unsigned bits)
     131             : {
     132    58320568 :     unsigned shift = 8 * sizeof(int) - bits;
     133    58320568 :     union { unsigned u; int s; } v = { (unsigned) val << shift };
     134    58320568 :     return v.s >> shift;
     135             : }
     136             : #endif
     137             : 
     138             : #ifndef zero_extend
     139    57660462 : static inline av_const unsigned zero_extend(unsigned val, unsigned bits)
     140             : {
     141    57660462 :     return (val << ((8 * sizeof(int)) - bits)) >> ((8 * sizeof(int)) - bits);
     142             : }
     143             : #endif
     144             : 
     145             : #ifndef COPY3_IF_LT
     146             : #define COPY3_IF_LT(x, y, a, b, c, d)\
     147             : if ((y) < (x)) {\
     148             :     (x) = (y);\
     149             :     (a) = (b);\
     150             :     (c) = (d);\
     151             : }
     152             : #endif
     153             : 
     154             : #ifndef MASK_ABS
     155             : #define MASK_ABS(mask, level) do {              \
     156             :         mask  = level >> 31;                    \
     157             :         level = (level ^ mask) - mask;          \
     158             :     } while (0)
     159             : #endif
     160             : 
     161             : #ifndef NEG_SSR32
     162             : #   define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
     163             : #endif
     164             : 
     165             : #ifndef NEG_USR32
     166             : #   define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
     167             : #endif
     168             : 
     169             : #if HAVE_BIGENDIAN
     170             : # ifndef PACK_2U8
     171             : #   define PACK_2U8(a,b)     (((a) <<  8) | (b))
     172             : # endif
     173             : # ifndef PACK_4U8
     174             : #   define PACK_4U8(a,b,c,d) (((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
     175             : # endif
     176             : # ifndef PACK_2U16
     177             : #   define PACK_2U16(a,b)    (((a) << 16) | (b))
     178             : # endif
     179             : #else
     180             : # ifndef PACK_2U8
     181             : #   define PACK_2U8(a,b)     (((b) <<  8) | (a))
     182             : # endif
     183             : # ifndef PACK_4U2
     184             : #   define PACK_4U8(a,b,c,d) (((d) << 24) | ((c) << 16) | ((b) << 8) | (a))
     185             : # endif
     186             : # ifndef PACK_2U16
     187             : #   define PACK_2U16(a,b)    (((b) << 16) | (a))
     188             : # endif
     189             : #endif
     190             : 
     191             : #ifndef PACK_2S8
     192             : #   define PACK_2S8(a,b)     PACK_2U8((a)&255, (b)&255)
     193             : #endif
     194             : #ifndef PACK_4S8
     195             : #   define PACK_4S8(a,b,c,d) PACK_4U8((a)&255, (b)&255, (c)&255, (d)&255)
     196             : #endif
     197             : #ifndef PACK_2S16
     198             : #   define PACK_2S16(a,b)    PACK_2U16((a)&0xffff, (b)&0xffff)
     199             : #endif
     200             : 
     201             : #ifndef FASTDIV
     202             : #   define FASTDIV(a,b) ((uint32_t)((((uint64_t)a) * ff_inverse[b]) >> 32))
     203             : #endif /* FASTDIV */
     204             : 
     205             : #ifndef ff_sqrt
     206             : #define ff_sqrt ff_sqrt
     207     4645320 : static inline av_const unsigned int ff_sqrt(unsigned int a)
     208             : {
     209             :     unsigned int b;
     210             : 
     211     4645320 :     if (a < 255) return (ff_sqrt_tab[a + 1] - 1) >> 4;
     212     4265241 :     else if (a < (1 << 12)) b = ff_sqrt_tab[a >> 4] >> 2;
     213             : #if !CONFIG_SMALL
     214     3721346 :     else if (a < (1 << 14)) b = ff_sqrt_tab[a >> 6] >> 1;
     215     2901865 :     else if (a < (1 << 16)) b = ff_sqrt_tab[a >> 8]   ;
     216             : #endif
     217             :     else {
     218     2062986 :         int s = av_log2_16bit(a >> 16) >> 1;
     219     2062986 :         unsigned int c = a >> (s + 2);
     220     2062986 :         b = ff_sqrt_tab[c >> (s + 8)];
     221     2062986 :         b = FASTDIV(c,b) + (b << s);
     222             :     }
     223             : 
     224     4265241 :     return b - (a < b * b);
     225             : }
     226             : #endif
     227             : 
     228      558260 : static inline av_const float ff_sqrf(float a)
     229             : {
     230      558260 :     return a*a;
     231             : }
     232             : 
     233      393216 : static inline int8_t ff_u8_to_s8(uint8_t a)
     234             : {
     235             :     union {
     236             :         uint8_t u8;
     237             :         int8_t  s8;
     238             :     } b;
     239      393216 :     b.u8 = a;
     240      393216 :     return b.s8;
     241             : }
     242             : 
     243     2373393 : static av_always_inline uint32_t bitswap_32(uint32_t x)
     244             : {
     245     4746786 :     return (uint32_t)ff_reverse[ x        & 0xFF] << 24 |
     246     4746786 :            (uint32_t)ff_reverse[(x >> 8)  & 0xFF] << 16 |
     247     4746786 :            (uint32_t)ff_reverse[(x >> 16) & 0xFF] << 8  |
     248     2373393 :            (uint32_t)ff_reverse[ x >> 24];
     249             : }
     250             : 
     251             : #endif /* AVCODEC_MATHOPS_H */

Generated by: LCOV version 1.13