FFmpeg: libavcodec/mpegvideoencdsp.c Source File

FFmpeg

[フレーム]

libavcodec

mpegvideoencdsp.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

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

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

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

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

8 *

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

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

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

12 * Lesser General Public License for more details.

13 *

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

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

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

17 */

19 #include <assert.h>

20 #include <stdint.h>

21 #include <string.h>

23 #include "config.h"

24 #include "libavutil/avassert.h"

25 #include "libavutil/attributes.h"

26 #include "libavutil/imgutils.h"

27 #include "avcodec.h"

28 #include "me_cmp.h"

29 #include "mpegvideoencdsp.h"

31 static int try_8x8basis_c(const int16_t rem[64], const int16_t weight[64],

32 const int16_t basis[64], int scale)

33 {

34 int i;

35 unsigned int sum = 0;

37 for (i = 0; i < 8 * 8; i++) {

38 int b = rem[i] + ((basis[i] * scale +

39 (1 << (BASIS_SHIFT - RECON_SHIFT - 1))) >>

40 (BASIS_SHIFT - RECON_SHIFT));

41 int w = weight[i];

42 b >>= RECON_SHIFT;

43 av_assert2(-512 < b && b < 512);

45 sum += (w * b) * (w * b) >> 4;

46 }

47 return sum >> 2;

48 }

50 static void add_8x8basis_c(int16_t rem[64], const int16_t basis[64], int scale)

51 {

52 int i;

54 for (i = 0; i < 8 * 8; i++)

55 rem[i] += (basis[i] * scale +

56 (1 << (BASIS_SHIFT - RECON_SHIFT - 1))) >>

57 (BASIS_SHIFT - RECON_SHIFT);

58 }

60 static int pix_sum_c(const uint8_t *pix, int line_size)

61 {

62 int s = 0, i, j;

64 for (i = 0; i < 16; i++) {

65 for (j = 0; j < 16; j += 8) {

66 s += pix[0];

67 s += pix[1];

68 s += pix[2];

69 s += pix[3];

70 s += pix[4];

71 s += pix[5];

72 s += pix[6];

73 s += pix[7];

74 pix += 8;

75 }

76 pix += line_size - 16;

77 }

78 return s;

79 }

81 static int pix_norm1_c(const uint8_t *pix, int line_size)

82 {

83 int s = 0, i, j;

84 const uint32_t *sq = ff_square_tab + 256;

86 for (i = 0; i < 16; i++) {

87 for (j = 0; j < 16; j += 8) {

88 #if HAVE_FAST_64BIT

89 register uint64_t x = *(uint64_t *) pix;

90 s += sq[x & 0xff];

91 s += sq[(x >> 8) & 0xff];

92 s += sq[(x >> 16) & 0xff];

93 s += sq[(x >> 24) & 0xff];

94 s += sq[(x >> 32) & 0xff];

95 s += sq[(x >> 40) & 0xff];

96 s += sq[(x >> 48) & 0xff];

97 s += sq[(x >> 56) & 0xff];

98 #else

99 register uint32_t x = *(uint32_t *) pix;

100 s += sq[x & 0xff];

101 s += sq[(x >> 8) & 0xff];

102 s += sq[(x >> 16) & 0xff];

103 s += sq[(x >> 24) & 0xff];

104 x = *(uint32_t *) (pix + 4);

105 s += sq[x & 0xff];

106 s += sq[(x >> 8) & 0xff];

107 s += sq[(x >> 16) & 0xff];

108 s += sq[(x >> 24) & 0xff];

109 #endif

110 pix += 8;

111 }

112 pix += line_size - 16;

113 }

114 return s;

115 }

116

117 /* draw the edges of width 'w' of an image of size width, height */

118 // FIXME: Check that this is OK for MPEG-4 interlaced.

119 static void draw_edges_8_c(uint8_t *buf, int wrap, int width, int height,

120 int w, int h, int sides)

121 {

122 uint8_t *ptr = buf, *last_line;

123 int i;

124

125 /* left and right */

126 for (i = 0; i < height; i++) {

127 memset(ptr - w, ptr[0], w);

128 memset(ptr + width, ptr[width - 1], w);

129 ptr += wrap;

130 }

131

132 /* top and bottom + corners */

133 buf -= w;

134 last_line = buf + (height - 1) * wrap;

135 if (sides & EDGE_TOP)

136 for (i = 0; i < h; i++)

137 // top

138 memcpy(buf - (i + 1) * wrap, buf, width + w + w);

139 if (sides & EDGE_BOTTOM)

140 for (i = 0; i < h; i++)

141 // bottom

142 memcpy(last_line + (i + 1) * wrap, last_line, width + w + w);

143 }

144

145 /* 2x2 -> 1x1 */

146 static void shrink22(uint8_t *dst, int dst_wrap,

147 const uint8_t *src, int src_wrap,

148 int width, int height)

149 {

150 int w;

151 const uint8_t *s1, *s2;

152 uint8_t *d;

153

154 for (; height > 0; height--) {

155 s1 = src;

156 s2 = s1 + src_wrap;

157 d = dst;

158 for (w = width; w >= 4; w -= 4) {

159 d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;

160 d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 2;

161 d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 2;

162 d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 2;

163 s1 += 8;

164 s2 += 8;

165 d += 4;

166 }

167 for (; w > 0; w--) {

168 d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;

169 s1 += 2;

170 s2 += 2;

171 d++;

172 }

173 src += 2 * src_wrap;

174 dst += dst_wrap;

175 }

176 }

177

178 /* 4x4 -> 1x1 */

179 static void shrink44(uint8_t *dst, int dst_wrap,

180 const uint8_t *src, int src_wrap,

181 int width, int height)

182 {

183 int w;

184 const uint8_t *s1, *s2, *s3, *s4;

185 uint8_t *d;

186

187 for (; height > 0; height--) {

188 s1 = src;

189 s2 = s1 + src_wrap;

190 s3 = s2 + src_wrap;

191 s4 = s3 + src_wrap;

192 d = dst;

193 for (w = width; w > 0; w--) {

194 d[0] = (s1[0] + s1[1] + s1[2] + s1[3] +

195 s2[0] + s2[1] + s2[2] + s2[3] +

196 s3[0] + s3[1] + s3[2] + s3[3] +

197 s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4;

198 s1 += 4;

199 s2 += 4;

200 s3 += 4;

201 s4 += 4;

202 d++;

203 }

204 src += 4 * src_wrap;

205 dst += dst_wrap;

206 }

207 }

208

209 /* 8x8 -> 1x1 */

210 static void shrink88(uint8_t *dst, int dst_wrap,

211 const uint8_t *src, int src_wrap,

212 int width, int height)

213 {

214 int w, i;

215

216 for (; height > 0; height--) {

217 for(w = width;w > 0; w--) {

218 int tmp = 0;

219 for (i = 0; i < 8; i++) {

220 tmp += src[0] + src[1] + src[2] + src[3] +

221 src[4] + src[5] + src[6] + src[7];

222 src += src_wrap;

223 }

224 *(dst++) = (tmp + 32) >> 6;

225 src += 8 - 8 * src_wrap;

226 }

227 src += 8 * src_wrap - 8 * width;

228 dst += dst_wrap - width;

229 }

230 }

231

232 av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c,

233 AVCodecContext *avctx)

234 {

235 c->try_8x8basis = try_8x8basis_c;

236 c->add_8x8basis = add_8x8basis_c;

237

238 c->shrink[0] = av_image_copy_plane;

239 c->shrink[1] = shrink22;

240 c->shrink[2] = shrink44;

241 c->shrink[3] = shrink88;

242

243 c->pix_sum = pix_sum_c;

244 c->pix_norm1 = pix_norm1_c;

245

246 c->draw_edges = draw_edges_8_c;

247

248 #if ARCH_ARM

249 ff_mpegvideoencdsp_init_arm(c, avctx);

250 #elif ARCH_PPC

251 ff_mpegvideoencdsp_init_ppc(c, avctx);

252 #elif ARCH_X86

253 ff_mpegvideoencdsp_init_x86(c, avctx);

254 #elif ARCH_MIPS

255 ff_mpegvideoencdsp_init_mips(c, avctx);

256 #endif

257 }

draw_edges_8_c

static void draw_edges_8_c(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)

Definition: mpegvideoencdsp.c:119

pix_norm1_c

static int pix_norm1_c(const uint8_t *pix, int line_size)

Definition: mpegvideoencdsp.c:81

EDGE_BOTTOM

#define EDGE_BOTTOM

Definition: mpegvideoencdsp.h:30

try_8x8basis_c

static int try_8x8basis_c(const int16_t rem[64], const int16_t weight[64], const int16_t basis[64], int scale)

Definition: mpegvideoencdsp.c:31

basis

static int16_t basis[64][64]

Definition: mpegvideo_enc.c:4198

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

uint8_t w

Definition: llviddspenc.c:38

#define b

Definition: input.c:41

shrink22

static void shrink22(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height)

Definition: mpegvideoencdsp.c:146

ff_mpegvideoencdsp_init_ppc

av_cold void ff_mpegvideoencdsp_init_ppc(MpegvideoEncDSPContext *c, AVCodecContext *avctx)

Definition: mpegvideoencdsp.c:151

ff_mpegvideoencdsp_init_x86

void ff_mpegvideoencdsp_init_x86(MpegvideoEncDSPContext *c, AVCodecContext *avctx)

Definition: mpegvideoencdsp_init.c:214

add_8x8basis_c

static void add_8x8basis_c(int16_t rem[64], const int16_t basis[64], int scale)

Definition: mpegvideoencdsp.c:50

av_image_copy_plane

void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)

Copy image plane from src to dst.

Definition: imgutils.c:374

ff_mpegvideoencdsp_init

av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)

Definition: mpegvideoencdsp.c:232

#define s3

Definition: regdef.h:40

ff_mpegvideoencdsp_init_mips

av_cold void ff_mpegvideoencdsp_init_mips(MpegvideoEncDSPContext *c, AVCodecContext *avctx)

Definition: mpegvideoencdsp_init_mips.c:26

wrap

#define wrap(func)

Definition: neontest.h:65

avassert.h

av_cold

#define av_cold

Definition: attributes.h:90

width

#define width

#define s(width, name)

Definition: cbs_vp9.c:198

BASIS_SHIFT

#define BASIS_SHIFT

Definition: mpegvideoencdsp.h:26

#define s1

Definition: regdef.h:38

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

weight

static int weight(int i, int blen, int offset)

Definition: diracdec.c:1562

#define s2

Definition: regdef.h:39

scale

static void scale(int *out, const int *in, const int w, const int h, const int shift)

Definition: vvc_intra.c:291

pix_sum_c

static int pix_sum_c(const uint8_t *pix, int line_size)

Definition: mpegvideoencdsp.c:60