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 |
|
79764198 |
static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ |
42 |
|
79764198 |
uint8_t *p= (uint8_t*)vp; |
43 |
|
|
av_assert2(size==1 || size==2 || size==4); |
44 |
|
|
av_assert2(w<=4); |
45 |
|
|
|
46 |
|
79764198 |
w *= size; |
47 |
|
79764198 |
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 |
✓✓ |
79764198 |
if(w==2){ |
52 |
✓✗ |
23018839 |
const uint16_t v= size==4 ? val : val*0x0101; |
53 |
|
23018839 |
*(uint16_t*)(p + 0*stride)= v; |
54 |
✗✓ |
23018839 |
if(h==1) return; |
55 |
|
23018839 |
*(uint16_t*)(p + 1*stride)= v; |
56 |
✓✓ |
23018839 |
if(h==2) return; |
57 |
|
1580304 |
*(uint16_t*)(p + 2*stride)= v; |
58 |
|
1580304 |
*(uint16_t*)(p + 3*stride)= v; |
59 |
✓✓ |
56745359 |
}else if(w==4){ |
60 |
✓✓✓✓
|
34192776 |
const uint32_t v= size==4 ? val : size==2 ? val*0x00010001 : val*0x01010101; |
61 |
|
34192776 |
*(uint32_t*)(p + 0*stride)= v; |
62 |
✓✓ |
34192776 |
if(h==1) return; |
63 |
|
34192728 |
*(uint32_t*)(p + 1*stride)= v; |
64 |
✓✓ |
34192728 |
if(h==2) return; |
65 |
|
30763606 |
*(uint32_t*)(p + 2*stride)= v; |
66 |
|
30763606 |
*(uint32_t*)(p + 3*stride)= v; |
67 |
✓✓ |
22552583 |
}else if(w==8){ |
68 |
|
|
// gcc cannot optimize 64-bit math on x86_32 |
69 |
|
|
#if HAVE_FAST_64BIT |
70 |
✓✓ |
9213504 |
const uint64_t v= size==2 ? val*0x0001000100010001ULL : val*0x0100000001ULL; |
71 |
|
9213504 |
*(uint64_t*)(p + 0*stride)= v; |
72 |
✓✓ |
9213504 |
if(h==1) return; |
73 |
|
9213440 |
*(uint64_t*)(p + 1*stride)= v; |
74 |
✓✓ |
9213440 |
if(h==2) return; |
75 |
|
4932979 |
*(uint64_t*)(p + 2*stride)= v; |
76 |
|
4932979 |
*(uint64_t*)(p + 3*stride)= v; |
77 |
✓✗ |
13339079 |
}else if(w==16){ |
78 |
|
13339079 |
const uint64_t v= val*0x0100000001ULL; |
79 |
|
13339079 |
*(uint64_t*)(p + 0+0*stride)= v; |
80 |
|
13339079 |
*(uint64_t*)(p + 8+0*stride)= v; |
81 |
|
13339079 |
*(uint64_t*)(p + 0+1*stride)= v; |
82 |
|
13339079 |
*(uint64_t*)(p + 8+1*stride)= v; |
83 |
✓✓ |
13339079 |
if(h==2) return; |
84 |
|
11533681 |
*(uint64_t*)(p + 0+2*stride)= v; |
85 |
|
11533681 |
*(uint64_t*)(p + 8+2*stride)= v; |
86 |
|
11533681 |
*(uint64_t*)(p + 0+3*stride)= v; |
87 |
|
11533681 |
*(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 */ |