FFmpeg
libavcodec
rectangle.h
Go to the documentation of this file.
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
static
av_always_inline
void
fill_rectangle
(
void
*vp,
int
w
,
int
h
,
int
stride
, uint32_t
val
,
int
size
){
42
uint8_t *p= (uint8_t*)vp;
43
av_assert2
(
size
==1 ||
size
==2 ||
size
==4);
44
av_assert2
(
w
<=4);
45
46
w
*=
size
;
47
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
if
(
w
==2){
52
const
uint16_t v=
size
==4 ?
val
:
val
*0x0101;
53
*(uint16_t*)(p + 0*
stride
)= v;
54
if
(
h
==1)
return
;
55
*(uint16_t*)(p + 1*
stride
)= v;
56
if
(
h
==2)
return
;
57
*(uint16_t*)(p + 2*
stride
)= v;
58
*(uint16_t*)(p + 3*
stride
)= v;
59
}
else
if
(
w
==4){
60
const
uint32_t v=
size
==4 ?
val
:
size
==2 ?
val
*0x00010001 :
val
*0x01010101;
61
*(uint32_t*)(p + 0*
stride
)= v;
62
if
(
h
==1)
return
;
63
*(uint32_t*)(p + 1*
stride
)= v;
64
if
(
h
==2)
return
;
65
*(uint32_t*)(p + 2*
stride
)= v;
66
*(uint32_t*)(p + 3*
stride
)= v;
67
}
else
if
(
w
==8){
68
// gcc cannot optimize 64-bit math on x86_32
69
#if HAVE_FAST_64BIT
70
const
uint64_t v=
size
==2 ?
val
*0x0001000100010001ULL :
val
*0x0100000001ULL;
71
*(uint64_t*)(p + 0*
stride
)= v;
72
if
(
h
==1)
return
;
73
*(uint64_t*)(p + 1*
stride
)= v;
74
if
(
h
==2)
return
;
75
*(uint64_t*)(p + 2*
stride
)= v;
76
*(uint64_t*)(p + 3*
stride
)= v;
77
}
else
if
(
w
==16){
78
const
uint64_t v=
val
*0x0100000001ULL;
79
*(uint64_t*)(p + 0+0*
stride
)= v;
80
*(uint64_t*)(p + 8+0*
stride
)= v;
81
*(uint64_t*)(p + 0+1*
stride
)= v;
82
*(uint64_t*)(p + 8+1*
stride
)= v;
83
if
(
h
==2)
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
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 */
w
uint8_t w
Definition:
llviddspenc.c:38
val
static double val(void *priv, double ch)
Definition:
aeval.c:77
avassert.h
fill_rectangle
static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size)
fill a rectangle.
Definition:
rectangle.h:41
size
int size
Definition:
twinvq_data.h:10344
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition:
avassert.h:64
common.h
av_always_inline
#define av_always_inline
Definition:
attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition:
macros.h:49
stride
#define stride
Definition:
h264pred_template.c:537
h
h
Definition:
vp9dsp_template.c:2038
Generated on Wed Aug 24 2022 21:41:46 for FFmpeg by
1.8.17