rectangle.h
上传用户:chinavct
上传日期:2022-06-20
资源大小:330k
文件大小:4k
源码类别:

流媒体/Mpeg4/MP4

开发平台:

Visual C++

  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.  * @file rectangle.h
  23.  * useful rectangle filling function
  24.  * @author Michael Niedermayer <michaelni@gmx.at>
  25.  */
  26. #ifndef AVCODEC_RECTANGLE_H
  27. #define AVCODEC_RECTANGLE_H
  28. #include "common.h"
  29. /**
  30.  * fill a rectangle.
  31.  * @param h height of the rectangle, should be a constant
  32.  * @param w width of the rectangle, should be a constant
  33.  * @param size the size of val (1 or 4), should be a constant
  34.  */
  35. static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){
  36.     uint8_t *p= (uint8_t*)vp;
  37.     assert(size==1 || size==4);
  38.     assert(w<=4);
  39.     w      *= size;
  40.     stride *= size;
  41.     assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0);
  42.     assert((stride&(w-1))==0);
  43.     if(w==2)
  44. {
  45.         const uint16_t v= size==4 ? val : val*0x0101;
  46.         *(uint16_t*)(p + 0*stride)= v;
  47.         if(h==1) return;
  48.         *(uint16_t*)(p + 1*stride)= v;
  49.         if(h==2) return;
  50.         *(uint16_t*)(p + 2*stride)= v;
  51.         *(uint16_t*)(p + 3*stride)= v;
  52.     }
  53. else if(w==4)
  54. {
  55.         const uint32_t v= size==4 ? val : val*0x01010101;
  56.         *(uint32_t*)(p + 0*stride)= v;
  57.         if(h==1) return;
  58.         *(uint32_t*)(p + 1*stride)= v;
  59.         if(h==2) return;
  60.         *(uint32_t*)(p + 2*stride)= v;
  61.         *(uint32_t*)(p + 3*stride)= v;
  62.     }
  63. else if(w==8)
  64. {
  65.     //gcc can't optimize 64bit math on x86_32
  66. #ifdef HAVE_FAST_64BIT
  67.         const uint64_t v= val*0x0100000001ULL;
  68.         *(uint64_t*)(p + 0*stride)= v;
  69.         if(h==1) return;
  70.         *(uint64_t*)(p + 1*stride)= v;
  71.         if(h==2) return;
  72.         *(uint64_t*)(p + 2*stride)= v;
  73.         *(uint64_t*)(p + 3*stride)= v;
  74.     }
  75. else if(w==16)
  76. {
  77.         const uint64_t v= val*0x0100000001ULL;
  78.         *(uint64_t*)(p + 0+0*stride)= v;
  79.         *(uint64_t*)(p + 8+0*stride)= v;
  80.         *(uint64_t*)(p + 0+1*stride)= v;
  81.         *(uint64_t*)(p + 8+1*stride)= v;
  82.         if(h==2) 
  83. return;
  84.         *(uint64_t*)(p + 0+2*stride)= v;
  85.         *(uint64_t*)(p + 8+2*stride)= v;
  86.         *(uint64_t*)(p + 0+3*stride)= v;
  87.         *(uint64_t*)(p + 8+3*stride)= v;
  88. #else
  89.         *(uint32_t*)(p + 0+0*stride)= val;
  90.         *(uint32_t*)(p + 4+0*stride)= val;
  91.         if(h==1) 
  92. return;
  93.         *(uint32_t*)(p + 0+1*stride)= val;
  94.         *(uint32_t*)(p + 4+1*stride)= val;
  95.         if(h==2) 
  96. return;
  97.         *(uint32_t*)(p + 0+2*stride)= val;
  98.         *(uint32_t*)(p + 4+2*stride)= val;
  99.         *(uint32_t*)(p + 0+3*stride)= val;
  100.         *(uint32_t*)(p + 4+3*stride)= val;
  101.     }
  102. else if(w==16)
  103. {
  104.         *(uint32_t*)(p + 0+0*stride)= val;
  105.         *(uint32_t*)(p + 4+0*stride)= val;
  106.         *(uint32_t*)(p + 8+0*stride)= val;
  107.         *(uint32_t*)(p +12+0*stride)= val;
  108.         *(uint32_t*)(p + 0+1*stride)= val;
  109.         *(uint32_t*)(p + 4+1*stride)= val;
  110.         *(uint32_t*)(p + 8+1*stride)= val;
  111.         *(uint32_t*)(p +12+1*stride)= val;
  112.         if(h==2) 
  113. return;
  114.         *(uint32_t*)(p + 0+2*stride)= val;
  115.         *(uint32_t*)(p + 4+2*stride)= val;
  116.         *(uint32_t*)(p + 8+2*stride)= val;
  117.         *(uint32_t*)(p +12+2*stride)= val;
  118.         *(uint32_t*)(p + 0+3*stride)= val;
  119.         *(uint32_t*)(p + 4+3*stride)= val;
  120.         *(uint32_t*)(p + 8+3*stride)= val;
  121.         *(uint32_t*)(p +12+3*stride)= val;
  122. #endif
  123.     }
  124. else
  125.         assert(0);
  126.     assert(h==4);
  127. }
  128. #endif /* AVCODEC_RECTANGLE_H */