LCOV - code coverage report
Current view: top level - libavcodec - rectangle.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 39 39 100.0 %
Date: 2017-12-14 08:27:08 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             :  * rectangle filling function
       3             :  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * useful rectangle filling function
      25             :  * @author Michael Niedermayer <michaelni@gmx.at>
      26             :  */
      27             : 
      28             : #ifndef AVCODEC_RECTANGLE_H
      29             : #define AVCODEC_RECTANGLE_H
      30             : 
      31             : #include "config.h"
      32             : #include "libavutil/common.h"
      33             : #include "libavutil/avassert.h"
      34             : 
      35             : /**
      36             :  * fill a rectangle.
      37             :  * @param h height of the rectangle, should be a constant
      38             :  * @param w width of the rectangle, should be a constant
      39             :  * @param size the size of val (1, 2 or 4), should be a constant
      40             :  */
      41    72609164 : static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){
      42    72609164 :     uint8_t *p= (uint8_t*)vp;
      43             :     av_assert2(size==1 || size==2 || size==4);
      44             :     av_assert2(w<=4);
      45             : 
      46    72609164 :     w      *= size;
      47    72609164 :     stride *= size;
      48             : 
      49             :     av_assert2((((long)vp)&(FFMIN(w, 8<<(HAVE_NEON|ARCH_PPC|HAVE_MMX))-1)) == 0);
      50             :     av_assert2((stride&(w-1))==0);
      51    72609164 :     if(w==2){
      52    21704603 :         const uint16_t v= size==4 ? val : val*0x0101;
      53    21704603 :         *(uint16_t*)(p + 0*stride)= v;
      54    21704603 :         if(h==1) return;
      55    21704603 :         *(uint16_t*)(p + 1*stride)= v;
      56    21704603 :         if(h==2) return;
      57     1487168 :         *(uint16_t*)(p + 2*stride)= v;
      58     1487168 :         *(uint16_t*)(p + 3*stride)= v;
      59    50904561 :     }else if(w==4){
      60    30989947 :         const uint32_t v= size==4 ? val : size==2 ? val*0x00010001 : val*0x01010101;
      61    30989947 :         *(uint32_t*)(p + 0*stride)= v;
      62    30989947 :         if(h==1) return;
      63    30989899 :         *(uint32_t*)(p + 1*stride)= v;
      64    30989899 :         if(h==2) return;
      65    27656661 :         *(uint32_t*)(p + 2*stride)= v;
      66    27656661 :         *(uint32_t*)(p + 3*stride)= v;
      67    19914614 :     }else if(w==8){
      68             :     // gcc cannot optimize 64-bit math on x86_32
      69             : #if HAVE_FAST_64BIT
      70     8558703 :         const uint64_t v=  size==2 ? val*0x0001000100010001ULL : val*0x0100000001ULL;
      71     8558703 :         *(uint64_t*)(p + 0*stride)= v;
      72     8558703 :         if(h==1) return;
      73     8558639 :         *(uint64_t*)(p + 1*stride)= v;
      74     8558639 :         if(h==2) return;
      75     4485114 :         *(uint64_t*)(p + 2*stride)= v;
      76     4485114 :         *(uint64_t*)(p + 3*stride)= v;
      77    11355911 :     }else if(w==16){
      78    11355911 :         const uint64_t v= val*0x0100000001ULL;
      79    11355911 :         *(uint64_t*)(p + 0+0*stride)= v;
      80    11355911 :         *(uint64_t*)(p + 8+0*stride)= v;
      81    11355911 :         *(uint64_t*)(p + 0+1*stride)= v;
      82    11355911 :         *(uint64_t*)(p + 8+1*stride)= v;
      83    11355911 :         if(h==2) return;
      84     9611323 :         *(uint64_t*)(p + 0+2*stride)= v;
      85     9611323 :         *(uint64_t*)(p + 8+2*stride)= v;
      86     9611323 :         *(uint64_t*)(p + 0+3*stride)= v;
      87     9611323 :         *(uint64_t*)(p + 8+3*stride)= v;
      88             : #else
      89             :         const uint32_t v= size==2 ? val*0x00010001 : val;
      90             :         *(uint32_t*)(p + 0+0*stride)= v;
      91             :         *(uint32_t*)(p + 4+0*stride)= v;
      92             :         if(h==1) return;
      93             :         *(uint32_t*)(p + 0+1*stride)= v;
      94             :         *(uint32_t*)(p + 4+1*stride)= v;
      95             :         if(h==2) return;
      96             :         *(uint32_t*)(p + 0+2*stride)= v;
      97             :         *(uint32_t*)(p + 4+2*stride)= v;
      98             :         *(uint32_t*)(p + 0+3*stride)= v;
      99             :         *(uint32_t*)(p + 4+3*stride)= v;
     100             :     }else if(w==16){
     101             :         *(uint32_t*)(p + 0+0*stride)= val;
     102             :         *(uint32_t*)(p + 4+0*stride)= val;
     103             :         *(uint32_t*)(p + 8+0*stride)= val;
     104             :         *(uint32_t*)(p +12+0*stride)= val;
     105             :         *(uint32_t*)(p + 0+1*stride)= val;
     106             :         *(uint32_t*)(p + 4+1*stride)= val;
     107             :         *(uint32_t*)(p + 8+1*stride)= val;
     108             :         *(uint32_t*)(p +12+1*stride)= val;
     109             :         if(h==2) return;
     110             :         *(uint32_t*)(p + 0+2*stride)= val;
     111             :         *(uint32_t*)(p + 4+2*stride)= val;
     112             :         *(uint32_t*)(p + 8+2*stride)= val;
     113             :         *(uint32_t*)(p +12+2*stride)= val;
     114             :         *(uint32_t*)(p + 0+3*stride)= val;
     115             :         *(uint32_t*)(p + 4+3*stride)= val;
     116             :         *(uint32_t*)(p + 8+3*stride)= val;
     117             :         *(uint32_t*)(p +12+3*stride)= val;
     118             : #endif
     119             :     }else
     120             :         av_assert2(0);
     121             :     av_assert2(h==4);
     122             : }
     123             : 
     124             : #endif /* AVCODEC_RECTANGLE_H */

Generated by: LCOV version 1.13