FFmpeg: libswscale/ops_tmpl_float.c Source File

FFmpeg

[フレーム]

libswscale

ops_tmpl_float.c

Go to the documentation of this file.

1 /**

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 #include "libavutil/avassert.h"

23 #include "ops_backend.h"

25 #ifndef BIT_DEPTH

26 # define BIT_DEPTH 32

27 #endif

29 #if BIT_DEPTH == 32

30 # define PIXEL_TYPE SWS_PIXEL_F32

31 # define PIXEL_MAX FLT_MAX

32 # define PIXEL_MIN FLT_MIN

33 # define pixel_t float

34 # define block_t f32block_t

35 # define px f32

36 #else

37 # error Invalid BIT_DEPTH

38 #endif

40 #define IS_FLOAT 1

41 #define FMT_CHAR f

42 #include "ops_tmpl_common.c"

44 DECL_SETUP(setup_dither)

45 {

46 const int size = 1 << op->dither.size_log2;

47 if (!size) {

48 /* We special case this value */

49 av_assert1(!av_cmp_q(op->dither.matrix[0], av_make_q(1, 2)));

50 out->ptr = NULL;

51 return 0;

52 }

54 const int width = FFMAX(size, SWS_BLOCK_SIZE);

55 pixel_t *matrix = out->ptr = av_malloc(sizeof(pixel_t) * size * width);

56 if (!matrix)

57 return AVERROR(ENOMEM);

59 for (int y = 0; y < size; y++) {

60 for (int x = 0; x < size; x++)

61 matrix[y * width + x] = av_q2pixel(op->dither.matrix[y * size + x]);

62 for (int x = size; x < width; x++) /* pad to block size */

63 matrix[y * width + x] = matrix[y * width + (x % size)];

64 }

66 return 0;

67 }

69 DECL_FUNC(dither, const int size_log2)

70 {

71 const pixel_t *restrict matrix = impl->priv.ptr;

72 const int mask = (1 << size_log2) - 1;

73 const int y_line = iter->y;

74 const int row0 = (y_line + 0) & mask;

75 const int row1 = (y_line + 3) & mask;

76 const int row2 = (y_line + 2) & mask;

77 const int row3 = (y_line + 5) & mask;

78 const int size = 1 << size_log2;

79 const int width = FFMAX(size, SWS_BLOCK_SIZE);

80 const int base = iter->x & ~(SWS_BLOCK_SIZE - 1) & (size - 1);

82 SWS_LOOP

83 for (int i = 0; i < SWS_BLOCK_SIZE; i++) {

84 x[i] += size_log2 ? matrix[row0 * width + base + i] : (pixel_t) 0.5;

85 y[i] += size_log2 ? matrix[row1 * width + base + i] : (pixel_t) 0.5;

86 z[i] += size_log2 ? matrix[row2 * width + base + i] : (pixel_t) 0.5;

87 w[i] += size_log2 ? matrix[row3 * width + base + i] : (pixel_t) 0.5;

88 }

90 CONTINUE(block_t, x, y, z, w);

91 }

93 #define WRAP_DITHER(N) \

94 DECL_IMPL(dither##N) \

95 { \

96 CALL(dither, N); \

97 } \

98 \

99 DECL_ENTRY(dither##N, \

100 .op = SWS_OP_DITHER, \

101 .dither_size = N, \

102 .setup = fn(setup_dither), \

103 .free = av_free, \

104 );

105

106 WRAP_DITHER(0)

107 WRAP_DITHER(1)

108 WRAP_DITHER(2)

109 WRAP_DITHER(3)

110 WRAP_DITHER(4)

111 WRAP_DITHER(5)

112 WRAP_DITHER(6)

113 WRAP_DITHER(7)

114 WRAP_DITHER(8)

115

116 typedef struct {

117 /* Stored in split form for convenience */

118 pixel_t m[4][4];

119 pixel_t k[4];

120 } fn(LinCoeffs);

121

122 DECL_SETUP(setup_linear)

123 {

124 fn(LinCoeffs) c;

125

126 for (int i = 0; i < 4; i++) {

127 for (int j = 0; j < 4; j++)

128 c.m[i][j] = av_q2pixel(op->lin.m[i][j]);

129 c.k[i] = av_q2pixel(op->lin.m[i][4]);

130 }

131

132 return SETUP_MEMDUP(c);

133 }

134

135 /**

136 * Fully general case for a 5x5 linear affine transformation. Should never be

137 * called without constant `mask`. This function will compile down to the

138 * appropriately optimized version for the required subset of operations when

139 * called with a constant mask.

140 */

141 DECL_FUNC(linear_mask, const uint32_t mask)

142 {

143 const fn(LinCoeffs) c = *(const fn(LinCoeffs) *) impl->priv.ptr;

144

145 SWS_LOOP

146 for (int i = 0; i < SWS_BLOCK_SIZE; i++) {

147 const pixel_t xx = x[i];

148 const pixel_t yy = y[i];

149 const pixel_t zz = z[i];

150 const pixel_t ww = w[i];

151

152 x[i] = (mask & SWS_MASK_OFF(0)) ? c.k[0] : 0;

153 x[i] += (mask & SWS_MASK(0, 0)) ? c.m[0][0] * xx : xx;

154 x[i] += (mask & SWS_MASK(0, 1)) ? c.m[0][1] * yy : 0;

155 x[i] += (mask & SWS_MASK(0, 2)) ? c.m[0][2] * zz : 0;

156 x[i] += (mask & SWS_MASK(0, 3)) ? c.m[0][3] * ww : 0;

157

158 y[i] = (mask & SWS_MASK_OFF(1)) ? c.k[1] : 0;

159 y[i] += (mask & SWS_MASK(1, 0)) ? c.m[1][0] * xx : 0;

160 y[i] += (mask & SWS_MASK(1, 1)) ? c.m[1][1] * yy : yy;

161 y[i] += (mask & SWS_MASK(1, 2)) ? c.m[1][2] * zz : 0;

162 y[i] += (mask & SWS_MASK(1, 3)) ? c.m[1][3] * ww : 0;

163

164 z[i] = (mask & SWS_MASK_OFF(2)) ? c.k[2] : 0;

165 z[i] += (mask & SWS_MASK(2, 0)) ? c.m[2][0] * xx : 0;

166 z[i] += (mask & SWS_MASK(2, 1)) ? c.m[2][1] * yy : 0;

167 z[i] += (mask & SWS_MASK(2, 2)) ? c.m[2][2] * zz : zz;

168 z[i] += (mask & SWS_MASK(2, 3)) ? c.m[2][3] * ww : 0;

169

170 w[i] = (mask & SWS_MASK_OFF(3)) ? c.k[3] : 0;

171 w[i] += (mask & SWS_MASK(3, 0)) ? c.m[3][0] * xx : 0;

172 w[i] += (mask & SWS_MASK(3, 1)) ? c.m[3][1] * yy : 0;

173 w[i] += (mask & SWS_MASK(3, 2)) ? c.m[3][2] * zz : 0;

174 w[i] += (mask & SWS_MASK(3, 3)) ? c.m[3][3] * ww : ww;

175 }

176

177 CONTINUE(block_t, x, y, z, w);

178 }

179

180 #define WRAP_LINEAR(NAME, MASK) \

181 DECL_IMPL(linear_##NAME) \

182 { \

183 CALL(linear_mask, MASK); \

184 } \

185 \

186 DECL_ENTRY(linear_##NAME, \

187 .op = SWS_OP_LINEAR, \

188 .setup = fn(setup_linear), \

189 .free = av_free, \

190 .linear_mask = (MASK), \

191 );

192

193 WRAP_LINEAR(luma, SWS_MASK_LUMA)

194 WRAP_LINEAR(alpha, SWS_MASK_ALPHA)

195 WRAP_LINEAR(lumalpha, SWS_MASK_LUMA | SWS_MASK_ALPHA)

196 WRAP_LINEAR(dot3, 0x7)

197 WRAP_LINEAR(row0, SWS_MASK_ROW(0))

198 WRAP_LINEAR(row0a, SWS_MASK_ROW(0) | SWS_MASK_ALPHA)

199 WRAP_LINEAR(diag3, SWS_MASK_DIAG3)

200 WRAP_LINEAR(diag4, SWS_MASK_DIAG4)

201 WRAP_LINEAR(diagoff3, SWS_MASK_DIAG3 | SWS_MASK_OFF3)

202 WRAP_LINEAR(matrix3, SWS_MASK_MAT3)

203 WRAP_LINEAR(affine3, SWS_MASK_MAT3 | SWS_MASK_OFF3)

204 WRAP_LINEAR(affine3a, SWS_MASK_MAT3 | SWS_MASK_OFF3 | SWS_MASK_ALPHA)

205 WRAP_LINEAR(matrix4, SWS_MASK_MAT4)

206 WRAP_LINEAR(affine4, SWS_MASK_MAT4 | SWS_MASK_OFF4)

207

208 static const SwsOpTable fn(op_table_float) = {

209 .block_size = SWS_BLOCK_SIZE,

210 .entries = {

211 REF_COMMON_PATTERNS(convert_uint8),

212 REF_COMMON_PATTERNS(convert_uint16),

213 REF_COMMON_PATTERNS(convert_uint32),

214

215 &fn(op_clear_1110),

216 REF_COMMON_PATTERNS(min),

217 REF_COMMON_PATTERNS(max),

218 REF_COMMON_PATTERNS(scale),

219

220 &fn(op_dither0),

221 &fn(op_dither1),

222 &fn(op_dither2),

223 &fn(op_dither3),

224 &fn(op_dither4),

225 &fn(op_dither5),

226 &fn(op_dither6),

227 &fn(op_dither7),

228 &fn(op_dither8),

229

230 &fn(op_linear_luma),

231 &fn(op_linear_alpha),

232 &fn(op_linear_lumalpha),

233 &fn(op_linear_dot3),

234 &fn(op_linear_row0),

235 &fn(op_linear_row0a),

236 &fn(op_linear_diag3),

237 &fn(op_linear_diag4),

238 &fn(op_linear_diagoff3),

239 &fn(op_linear_matrix3),

240 &fn(op_linear_affine3),

241 &fn(op_linear_affine3a),

242 &fn(op_linear_matrix4),

243 &fn(op_linear_affine4),

244

245 NULL

246 },

247 };

248

249 #undef PIXEL_TYPE

250 #undef PIXEL_MAX

251 #undef PIXEL_MIN

252 #undef pixel_t

253 #undef block_t

254 #undef px

255

256 #undef FMT_CHAR

257 #undef IS_FLOAT

SwsOpTable

Definition: ops_chain.h:122

SWS_MASK_MAT3

@ SWS_MASK_MAT3

Definition: ops.h:167

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

ops_backend.h

out

FILE * out

Definition: movenc.c:55

setup_linear

static int setup_linear(const SwsOp *op, SwsOpPriv *out)

Definition: ops.c:213

matrix

Definition: vc1dsp.c:43

block_t

#define block_t

Definition: ops_tmpl_float.c:34

mask

int mask

Definition: mediacodecdec_common.c:154

SWS_MASK_ALPHA

@ SWS_MASK_ALPHA

Definition: ops.h:163

uint8_t w

Definition: llviddspenc.c:38

base

uint8_t base

Definition: vp3data.h:128

max

#define max(a, b)

Definition: cuda_runtime.h:33

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

SWS_MASK_DIAG3

@ SWS_MASK_DIAG3

Definition: ops.h:165

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

SWS_MASK_ROW

#define SWS_MASK_ROW(I)

Definition: ops.h:157

av_q2pixel

#define av_q2pixel(q)

Definition: ops_backend.h:70

Definition: ops_tmpl_float.c:116

avassert.h

setup_dither

static int setup_dither(const SwsOp *op, SwsOpPriv *out)

Definition: ops.c:189

DECL_SETUP

DECL_SETUP(setup_dither)

Definition: ops_tmpl_float.c:44

SETUP_MEMDUP

#define SETUP_MEMDUP(c)

Definition: ops_backend.h:129

dither

static const uint16_t dither[8][8]

Definition: vf_gradfun.c:46

CONTINUE

#define CONTINUE(TYPE,...)

Definition: ops_backend.h:120

static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)

Perform decode operation.

Definition: anm.c:76

SWS_LOOP

#define SWS_LOOP

Definition: ops_backend.h:57

SWS_BLOCK_SIZE

#define SWS_BLOCK_SIZE

Definition: ops_backend.c:30

NULL

#define NULL

Definition: coverity.c:32

SWS_MASK_OFF3

@ SWS_MASK_OFF3

Definition: ops.h:166

SWS_MASK

#define SWS_MASK(I, J)

Definition: ops.h:155

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

SWS_MASK_OFF4

@ SWS_MASK_OFF4

Definition: ops.h:172

DECL_FUNC

DECL_FUNC(dither, const int size_log2)

Definition: ops_tmpl_float.c:69

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:424

size

int size