rectangle.h
上传用户:lctgjx
上传日期:2022-06-04
资源大小:8887k
文件大小: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 FFMPEG_RECTANGLE_H
  27. #define FFMPEG_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.         const uint16_t v= size==4 ? val : val*0x0101;
  45.         *(uint16_t*)(p + 0*stride)= v;
  46.         if(h==1) return;
  47.         *(uint16_t*)(p + 1*stride)= v;
  48.         if(h==2) return;
  49.         *(uint16_t*)(p + 2*stride)= v;
  50.         *(uint16_t*)(p + 3*stride)= v;
  51.     }else if(w==4){
  52.         const uint32_t v= size==4 ? val : val*0x01010101;
  53.         *(uint32_t*)(p + 0*stride)= v;
  54.         if(h==1) return;
  55.         *(uint32_t*)(p + 1*stride)= v;
  56.         if(h==2) return;
  57.         *(uint32_t*)(p + 2*stride)= v;
  58.         *(uint32_t*)(p + 3*stride)= v;
  59.     }else if(w==8){
  60.     //gcc can't optimize 64bit math on x86_32
  61. #ifdef HAVE_FAST_64BIT
  62.         const uint64_t v= val*0x0100000001ULL;
  63.         *(uint64_t*)(p + 0*stride)= v;
  64.         if(h==1) return;
  65.         *(uint64_t*)(p + 1*stride)= v;
  66.         if(h==2) return;
  67.         *(uint64_t*)(p + 2*stride)= v;
  68.         *(uint64_t*)(p + 3*stride)= v;
  69.     }else if(w==16){
  70.         const uint64_t v= val*0x0100000001ULL;
  71.         *(uint64_t*)(p + 0+0*stride)= v;
  72.         *(uint64_t*)(p + 8+0*stride)= v;
  73.         *(uint64_t*)(p + 0+1*stride)= v;
  74.         *(uint64_t*)(p + 8+1*stride)= v;
  75.         if(h==2) return;
  76.         *(uint64_t*)(p + 0+2*stride)= v;
  77.         *(uint64_t*)(p + 8+2*stride)= v;
  78.         *(uint64_t*)(p + 0+3*stride)= v;
  79.         *(uint64_t*)(p + 8+3*stride)= v;
  80. #else
  81.         *(uint32_t*)(p + 0+0*stride)= val;
  82.         *(uint32_t*)(p + 4+0*stride)= val;
  83.         if(h==1) return;
  84.         *(uint32_t*)(p + 0+1*stride)= val;
  85.         *(uint32_t*)(p + 4+1*stride)= val;
  86.         if(h==2) return;
  87.         *(uint32_t*)(p + 0+2*stride)= val;
  88.         *(uint32_t*)(p + 4+2*stride)= val;
  89.         *(uint32_t*)(p + 0+3*stride)= val;
  90.         *(uint32_t*)(p + 4+3*stride)= val;
  91.     }else if(w==16){
  92.         *(uint32_t*)(p + 0+0*stride)= val;
  93.         *(uint32_t*)(p + 4+0*stride)= val;
  94.         *(uint32_t*)(p + 8+0*stride)= val;
  95.         *(uint32_t*)(p +12+0*stride)= val;
  96.         *(uint32_t*)(p + 0+1*stride)= val;
  97.         *(uint32_t*)(p + 4+1*stride)= val;
  98.         *(uint32_t*)(p + 8+1*stride)= val;
  99.         *(uint32_t*)(p +12+1*stride)= val;
  100.         if(h==2) return;
  101.         *(uint32_t*)(p + 0+2*stride)= val;
  102.         *(uint32_t*)(p + 4+2*stride)= val;
  103.         *(uint32_t*)(p + 8+2*stride)= val;
  104.         *(uint32_t*)(p +12+2*stride)= val;
  105.         *(uint32_t*)(p + 0+3*stride)= val;
  106.         *(uint32_t*)(p + 4+3*stride)= val;
  107.         *(uint32_t*)(p + 8+3*stride)= val;
  108.         *(uint32_t*)(p +12+3*stride)= val;
  109. #endif
  110.     }else
  111.         assert(0);
  112.     assert(h==4);
  113. }
  114. #endif /* FFMPEG_RECTANGLE_H */