FFmpeg: libavcodec/hevcdsp_template.c Source File

FFmpeg

[フレーム]

libavcodec

hevcdsp_template.c

Go to the documentation of this file.

1 /*

2 * HEVC video decoder

3 *

5 *

6 * This file is part of FFmpeg.

7 *

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

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

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

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

12 *

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

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

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

16 * Lesser General Public License for more details.

17 *

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

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

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

21 */

23 #include "get_bits.h"

24 #include "hevc.h"

26 #include "bit_depth_template.c"

27 #include "hevcdsp.h"

30 static void FUNC(put_pcm)(uint8_t *_dst, ptrdiff_t stride, int width, int height,

31 GetBitContext *gb, int pcm_bit_depth)

32 {

33 int x, y;

34 pixel *dst = (pixel *)_dst;

36 stride /= sizeof(pixel);

38 for (y = 0; y < height; y++) {

39 for (x = 0; x < width; x++)

40 dst[x] = get_bits(gb, pcm_bit_depth) << (BIT_DEPTH - pcm_bit_depth);

41 dst += stride;

42 }

43 }

45 static av_always_inline void FUNC(transquant_bypass)(uint8_t *_dst, int16_t *coeffs,

46 ptrdiff_t stride, int size)

47 {

48 int x, y;

49 pixel *dst = (pixel *)_dst;

51 stride /= sizeof(pixel);

53 for (y = 0; y < size; y++) {

54 for (x = 0; x < size; x++) {

55 dst[x] = av_clip_pixel(dst[x] + *coeffs);

56 coeffs++;

57 }

58 dst += stride;

59 }

60 }

62 static void FUNC(transform_add4x4)(uint8_t *_dst, int16_t *coeffs,

63 ptrdiff_t stride)

64 {

65 FUNC(transquant_bypass)(_dst, coeffs, stride, 4);

66 }

68 static void FUNC(transform_add8x8)(uint8_t *_dst, int16_t *coeffs,

69 ptrdiff_t stride)

70 {

71 FUNC(transquant_bypass)(_dst, coeffs, stride, 8);

72 }

74 static void FUNC(transform_add16x16)(uint8_t *_dst, int16_t *coeffs,

75 ptrdiff_t stride)

76 {

77 FUNC(transquant_bypass)(_dst, coeffs, stride, 16);

78 }

80 static void FUNC(transform_add32x32)(uint8_t *_dst, int16_t *coeffs,

81 ptrdiff_t stride)

82 {

83 FUNC(transquant_bypass)(_dst, coeffs, stride, 32);

84 }

87 static void FUNC(transform_rdpcm)(int16_t *_coeffs, int16_t log2_size, int mode)

88 {

89 int16_t *coeffs = (int16_t *) _coeffs;

90 int x, y;

91 int size = 1 << log2_size;

93 if (mode) {

94 coeffs += size;

95 for (y = 0; y < size - 1; y++) {

96 for (x = 0; x < size; x++)

97 coeffs[x] += coeffs[x - size];

98 coeffs += size;

99 }

100 } else {

101 for (y = 0; y < size; y++) {

102 for (x = 1; x < size; x++)

103 coeffs[x] += coeffs[x - 1];

104 coeffs += size;

105 }

106 }

107 }

108

109 static void FUNC(transform_skip)(int16_t *_coeffs, int16_t log2_size)

110 {

111 int shift = 15 - BIT_DEPTH - log2_size;

112 int x, y;

113 int size = 1 << log2_size;

114 int16_t *coeffs = _coeffs;

115

116

117 if (shift > 0) {

118 int offset = 1 << (shift - 1);

119 for (y = 0; y < size; y++) {

120 for (x = 0; x < size; x++) {

121 *coeffs = (*coeffs + offset) >> shift;

122 coeffs++;

123 }

124 }

125 } else {

126 for (y = 0; y < size; y++) {

127 for (x = 0; x < size; x++) {

128 *coeffs = *coeffs << -shift;

129 coeffs++;

130 }

131 }

132 }

133 }

134

135 #define SET(dst, x) (dst) = (x)

136 #define SCALE(dst, x) (dst) = av_clip_int16(((x) + add) >> shift)

137 #define ADD_AND_SCALE(dst, x) \

138 (dst) = av_clip_pixel((dst) + av_clip_int16(((x) + add) >> shift))

139

140 #define TR_4x4_LUMA(dst, src, step, assign) \

141 do { \

142 int c0 = src[0 * step] + src[2 * step]; \

143 int c1 = src[2 * step] + src[3 * step]; \

144 int c2 = src[0 * step] - src[3 * step]; \

145 int c3 = 74 * src[1 * step]; \

146 \

147 assign(dst[2 * step], 74 * (src[0 * step] - \

148 src[2 * step] + \

149 src[3 * step])); \

150 assign(dst[0 * step], 29 * c0 + 55 * c1 + c3); \

151 assign(dst[1 * step], 55 * c2 - 29 * c1 + c3); \

152 assign(dst[3 * step], 55 * c0 + 29 * c2 - c3); \

153 } while (0)

154

155 static void FUNC(transform_4x4_luma)(int16_t *coeffs)

156 {

157 int i;

158 int shift = 7;

159 int add = 1 << (shift - 1);

160 int16_t *src = coeffs;

161

162 for (i = 0; i < 4; i++) {

163 TR_4x4_LUMA(src, src, 4, SCALE);

164 src++;

165 }

166

167 shift = 20 - BIT_DEPTH;

168 add = 1 << (shift - 1);

169 for (i = 0; i < 4; i++) {

170 TR_4x4_LUMA(coeffs, coeffs, 1, SCALE);

171 coeffs += 4;

172 }

173 }

174

175 #undef TR_4x4_LUMA

176

177 #define TR_4(dst, src, dstep, sstep, assign, end) \

178 do { \

179 const int e0 = 64 * src[0 * sstep] + 64 * src[2 * sstep]; \

180 const int e1 = 64 * src[0 * sstep] - 64 * src[2 * sstep]; \

181 const int o0 = 83 * src[1 * sstep] + 36 * src[3 * sstep]; \

182 const int o1 = 36 * src[1 * sstep] - 83 * src[3 * sstep]; \

183 \

184 assign(dst[0 * dstep], e0 + o0); \

185 assign(dst[1 * dstep], e1 + o1); \

186 assign(dst[2 * dstep], e1 - o1); \

187 assign(dst[3 * dstep], e0 - o0); \

188 } while (0)

189

190 #define TR_8(dst, src, dstep, sstep, assign, end) \

191 do { \

192 int i, j; \

193 int e_8[4]; \

194 int o_8[4] = { 0 }; \

195 for (i = 0; i < 4; i++) \

196 for (j = 1; j < end; j += 2) \

197 o_8[i] += transform[4 * j][i] * src[j * sstep]; \

198 TR_4(e_8, src, 1, 2 * sstep, SET, 4); \

199 \

200 for (i = 0; i < 4; i++) { \

201 assign(dst[i * dstep], e_8[i] + o_8[i]); \

202 assign(dst[(7 - i) * dstep], e_8[i] - o_8[i]); \

203 } \

204 } while (0)

205

206 #define TR_16(dst, src, dstep, sstep, assign, end) \

207 do { \

208 int i, j; \

209 int e_16[8]; \

210 int o_16[8] = { 0 }; \

211 for (i = 0; i < 8; i++) \

212 for (j = 1; j < end; j += 2) \

213 o_16[i] += transform[2 * j][i] * src[j * sstep]; \

214 TR_8(e_16, src, 1, 2 * sstep, SET, 8); \

215 \

216 for (i = 0; i < 8; i++) { \

217 assign(dst[i * dstep], e_16[i] + o_16[i]); \

218 assign(dst[(15 - i) * dstep], e_16[i] - o_16[i]); \

219 } \

220 } while (0)

221

222 #define TR_32(dst, src, dstep, sstep, assign, end) \

223 do { \

224 int i, j; \

225 int e_32[16]; \

226 int o_32[16] = { 0 }; \

227 for (i = 0; i < 16; i++) \

228 for (j = 1; j < end; j += 2) \

229 o_32[i] += transform[j][i] * src[j * sstep]; \

230 TR_16(e_32, src, 1, 2 * sstep, SET, end/2); \

231 \

232 for (i = 0; i < 16; i++) { \

233 assign(dst[i * dstep], e_32[i] + o_32[i]); \

234 assign(dst[(31 - i) * dstep], e_32[i] - o_32[i]); \

235 } \

236 } while (0)

237

238 #define IDCT_VAR4(H) \

239 int limit2 = FFMIN(col_limit + 4, H)

240 #define IDCT_VAR8(H) \

241 int limit = FFMIN(col_limit, H); \

242 int limit2 = FFMIN(col_limit + 4, H)

243 #define IDCT_VAR16(H) IDCT_VAR8(H)

244 #define IDCT_VAR32(H) IDCT_VAR8(H)

245

246 #define IDCT(H) \

247 static void FUNC(idct_##H ##x ##H )( \

248 int16_t *coeffs, int col_limit) { \

249 int i; \

250 int shift = 7; \

251 int add = 1 << (shift - 1); \

252 int16_t *src = coeffs; \

253 IDCT_VAR ##H(H); \

254 \

255 for (i = 0; i < H; i++) { \

256 TR_ ## H(src, src, H, H, SCALE, limit2); \

257 if (limit2 < H && i%4 == 0 && !!i) \

258 limit2 -= 4; \

259 src++; \

260 } \

261 \

262 shift = 20 - BIT_DEPTH; \

263 add = 1 << (shift - 1); \

264 for (i = 0; i < H; i++) { \

265 TR_ ## H(coeffs, coeffs, 1, 1, SCALE, limit); \

266 coeffs += H; \

267 } \

268 }

269

270 #define IDCT_DC(H) \

271 static void FUNC(idct_##H ##x ##H ##_dc)( \

272 int16_t *coeffs) { \

273 int i, j; \

274 int shift = 14 - BIT_DEPTH; \

275 int add = 1 << (shift - 1); \

276 int coeff = (((coeffs[0] + 1) >> 1) + add) >> shift; \

277 \

278 for (j = 0; j < H; j++) { \

279 for (i = 0; i < H; i++) { \

280 coeffs[i+j*H] = coeff; \

281 } \

282 } \

283 }

284

285 IDCT( 4)

286 IDCT( 8)

287 IDCT(16)

288 IDCT(32)

289

290 IDCT_DC( 4)

291 IDCT_DC( 8)

292 IDCT_DC(16)

293 IDCT_DC(32)

294

295 #undef TR_4

296 #undef TR_8

297 #undef TR_16

298 #undef TR_32

299

300 #undef SET

301 #undef SCALE

302 #undef ADD_AND_SCALE

303

304 static void FUNC(sao_band_filter_0)(uint8_t *_dst, uint8_t *_src,

305 ptrdiff_t stride_dst, ptrdiff_t stride_src,

306 int16_t *sao_offset_val, int sao_left_class,

307 int width, int height)

308 {

309 pixel *dst = (pixel *)_dst;

310 pixel *src = (pixel *)_src;

311 int offset_table[32] = { 0 };

312 int k, y, x;

313 int shift = BIT_DEPTH - 5;

314

315 stride_dst /= sizeof(pixel);

316 stride_src /= sizeof(pixel);

317

318 for (k = 0; k < 4; k++)

319 offset_table[(k + sao_left_class) & 31] = sao_offset_val[k + 1];

320 for (y = 0; y < height; y++) {

321 for (x = 0; x < width; x++)

322 dst[x] = av_clip_pixel(src[x] + offset_table[src[x] >> shift]);

323 dst += stride_dst;

324 src += stride_src;

325 }

326 }

327

328 #define CMP(a, b) (((a) > (b)) - ((a) < (b)))

329

330 static void FUNC(sao_edge_filter)(uint8_t *_dst, uint8_t *_src, ptrdiff_t stride_dst, int16_t *sao_offset_val,

331 int eo, int width, int height) {

332

333 static const uint8_t edge_idx[] = { 1, 2, 0, 3, 4 };

334 static const int8_t pos[4][2][2] = {

335 { { -1, 0 }, { 1, 0 } }, // horizontal

336 { { 0, -1 }, { 0, 1 } }, // vertical

337 { { -1, -1 }, { 1, 1 } }, // 45 degree

338 { { 1, -1 }, { -1, 1 } }, // 135 degree

339 };

340 pixel *dst = (pixel *)_dst;

341 pixel *src = (pixel *)_src;

342 int a_stride, b_stride;

343 int x, y;

344 ptrdiff_t stride_src = (2*MAX_PB_SIZE + FF_INPUT_BUFFER_PADDING_SIZE) / sizeof(pixel);

345 stride_dst /= sizeof(pixel);

346

347 a_stride = pos[eo][0][0] + pos[eo][0][1] * stride_src;

348 b_stride = pos[eo][1][0] + pos[eo][1][1] * stride_src;

349 for (y = 0; y < height; y++) {

350 for (x = 0; x < width; x++) {

351 int diff0 = CMP(src[x], src[x + a_stride]);

352 int diff1 = CMP(src[x], src[x + b_stride]);

353 int offset_val = edge_idx[2 + diff0 + diff1];

354 dst[x] = av_clip_pixel(src[x] + sao_offset_val[offset_val]);

355 }

356 src += stride_src;

357 dst += stride_dst;

358 }

359 }

360

361 static void FUNC(sao_edge_restore_0)(uint8_t *_dst, uint8_t *_src,

362 ptrdiff_t stride_dst, ptrdiff_t stride_src, SAOParams *sao,

363 int *borders, int _width, int _height,

364 int c_idx, uint8_t *vert_edge,

365 uint8_t *horiz_edge, uint8_t *diag_edge)

366 {

367 int x, y;

368 pixel *dst = (pixel *)_dst;

369 pixel *src = (pixel *)_src;

370 int16_t *sao_offset_val = sao->offset_val[c_idx];

371 int sao_eo_class = sao->eo_class[c_idx];

372 int init_x = 0, width = _width, height = _height;

373

374 stride_dst /= sizeof(pixel);

375 stride_src /= sizeof(pixel);

376

377 if (sao_eo_class != SAO_EO_VERT) {

378 if (borders[0]) {

379 int offset_val = sao_offset_val[0];

380 for (y = 0; y < height; y++) {

381 dst[y * stride_dst] = av_clip_pixel(src[y * stride_src] + offset_val);

382 }

383 init_x = 1;

384 }

385 if (borders[2]) {

386 int offset_val = sao_offset_val[0];

387 int offset = width - 1;

388 for (x = 0; x < height; x++) {

389 dst[x * stride_dst + offset] = av_clip_pixel(src[x * stride_src + offset] + offset_val);

390 }

391 width--;

392 }

393 }

394 if (sao_eo_class != SAO_EO_HORIZ) {

395 if (borders[1]) {

396 int offset_val = sao_offset_val[0];

397 for (x = init_x; x < width; x++)

398 dst[x] = av_clip_pixel(src[x] + offset_val);

399 }

400 if (borders[3]) {

401 int offset_val = sao_offset_val[0];

402 int y_stride_dst = stride_dst * (height - 1);

403 int y_stride_src = stride_src * (height - 1);

404 for (x = init_x; x < width; x++)

405 dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + offset_val);

406 height--;

407 }

408 }

409 }

410

411 static void FUNC(sao_edge_restore_1)(uint8_t *_dst, uint8_t *_src,

412 ptrdiff_t stride_dst, ptrdiff_t stride_src, SAOParams *sao,

413 int *borders, int _width, int _height,

414 int c_idx, uint8_t *vert_edge,

415 uint8_t *horiz_edge, uint8_t *diag_edge)

416 {

417 int x, y;

418 pixel *dst = (pixel *)_dst;

419 pixel *src = (pixel *)_src;

420 int16_t *sao_offset_val = sao->offset_val[c_idx];

421 int sao_eo_class = sao->eo_class[c_idx];

422 int init_x = 0, init_y = 0, width = _width, height = _height;

423

424 stride_dst /= sizeof(pixel);

425 stride_src /= sizeof(pixel);

426

427 if (sao_eo_class != SAO_EO_VERT) {

428 if (borders[0]) {

429 int offset_val = sao_offset_val[0];

430 for (y = 0; y < height; y++) {

431 dst[y * stride_dst] = av_clip_pixel(src[y * stride_src] + offset_val);

432 }

433 init_x = 1;

434 }

435 if (borders[2]) {

436 int offset_val = sao_offset_val[0];

437 int offset = width - 1;

438 for (x = 0; x < height; x++) {

439 dst[x * stride_dst + offset] = av_clip_pixel(src[x * stride_src + offset] + offset_val);

440 }

441 width--;

442 }

443 }

444 if (sao_eo_class != SAO_EO_HORIZ) {

445 if (borders[1]) {

446 int offset_val = sao_offset_val[0];

447 for (x = init_x; x < width; x++)

448 dst[x] = av_clip_pixel(src[x] + offset_val);

449 init_y = 1;

450 }

451 if (borders[3]) {

452 int offset_val = sao_offset_val[0];

453 int y_stride_dst = stride_dst * (height - 1);

454 int y_stride_src = stride_src * (height - 1);

455 for (x = init_x; x < width; x++)

456 dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + offset_val);

457 height--;

458 }

459 }

460

461 {

462 int save_upper_left = !diag_edge[0] && sao_eo_class == SAO_EO_135D && !borders[0] && !borders[1];

463 int save_upper_right = !diag_edge[1] && sao_eo_class == SAO_EO_45D && !borders[1] && !borders[2];

464 int save_lower_right = !diag_edge[2] && sao_eo_class == SAO_EO_135D && !borders[2] && !borders[3];

465 int save_lower_left = !diag_edge[3] && sao_eo_class == SAO_EO_45D && !borders[0] && !borders[3];

466

467 // Restore pixels that can't be modified

468 if(vert_edge[0] && sao_eo_class != SAO_EO_VERT) {

469 for(y = init_y+save_upper_left; y< height-save_lower_left; y++)

470 dst[y*stride_dst] = src[y*stride_src];

471 }

472 if(vert_edge[1] && sao_eo_class != SAO_EO_VERT) {

473 for(y = init_y+save_upper_right; y< height-save_lower_right; y++)

474 dst[y*stride_dst+width-1] = src[y*stride_src+width-1];

475 }

476

477 if(horiz_edge[0] && sao_eo_class != SAO_EO_HORIZ) {

478 for(x = init_x+save_upper_left; x < width-save_upper_right; x++)

479 dst[x] = src[x];

480 }

481 if(horiz_edge[1] && sao_eo_class != SAO_EO_HORIZ) {

482 for(x = init_x+save_lower_left; x < width-save_lower_right; x++)

483 dst[(height-1)*stride_dst+x] = src[(height-1)*stride_src+x];

484 }

485 if(diag_edge[0] && sao_eo_class == SAO_EO_135D)

486 dst[0] = src[0];

487 if(diag_edge[1] && sao_eo_class == SAO_EO_45D)

488 dst[width-1] = src[width-1];

489 if(diag_edge[2] && sao_eo_class == SAO_EO_135D)

490 dst[stride_dst*(height-1)+width-1] = src[stride_src*(height-1)+width-1];

491 if(diag_edge[3] && sao_eo_class == SAO_EO_45D)

492 dst[stride_dst*(height-1)] = src[stride_src*(height-1)];

493

494 }

495 }

496

497 #undef CMP

498

499 ////////////////////////////////////////////////////////////////////////////////

500 //

501 ////////////////////////////////////////////////////////////////////////////////

502 static void FUNC(put_hevc_pel_pixels)(int16_t *dst,

503 uint8_t *_src, ptrdiff_t _srcstride,

504 int height, intptr_t mx, intptr_t my, int width)

505 {

506 int x, y;

507 pixel *src = (pixel *)_src;

508 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

509

510 for (y = 0; y < height; y++) {

511 for (x = 0; x < width; x++)

512 dst[x] = src[x] << (14 - BIT_DEPTH);

513 src += srcstride;

514 dst += MAX_PB_SIZE;

515 }

516 }

517

518 static void FUNC(put_hevc_pel_uni_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

519 int height, intptr_t mx, intptr_t my, int width)

520 {

521 int y;

522 pixel *src = (pixel *)_src;

523 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

524 pixel *dst = (pixel *)_dst;

525 ptrdiff_t dststride = _dststride / sizeof(pixel);

526

527 for (y = 0; y < height; y++) {

528 memcpy(dst, src, width * sizeof(pixel));

529 src += srcstride;

530 dst += dststride;

531 }

532 }

533

534 static void FUNC(put_hevc_pel_bi_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

535 int16_t *src2,

536 int height, intptr_t mx, intptr_t my, int width)

537 {

538 int x, y;

539 pixel *src = (pixel *)_src;

540 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

541 pixel *dst = (pixel *)_dst;

542 ptrdiff_t dststride = _dststride / sizeof(pixel);

543

544 int shift = 14 + 1 - BIT_DEPTH;

545 #if BIT_DEPTH < 14

546 int offset = 1 << (shift - 1);

547 #else

548 int offset = 0;

549 #endif

550

551 for (y = 0; y < height; y++) {

552 for (x = 0; x < width; x++)

553 dst[x] = av_clip_pixel(((src[x] << (14 - BIT_DEPTH)) + src2[x] + offset) >> shift);

554 src += srcstride;

555 dst += dststride;

556 src2 += MAX_PB_SIZE;

557 }

558 }

559

560 static void FUNC(put_hevc_pel_uni_w_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

561 int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)

562 {

563 int x, y;

564 pixel *src = (pixel *)_src;

565 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

566 pixel *dst = (pixel *)_dst;

567 ptrdiff_t dststride = _dststride / sizeof(pixel);

568 int shift = denom + 14 - BIT_DEPTH;

569 #if BIT_DEPTH < 14

570 int offset = 1 << (shift - 1);

571 #else

572 int offset = 0;

573 #endif

574

575 ox = ox * (1 << (BIT_DEPTH - 8));

576 for (y = 0; y < height; y++) {

577 for (x = 0; x < width; x++)

578 dst[x] = av_clip_pixel((((src[x] << (14 - BIT_DEPTH)) * wx + offset) >> shift) + ox);

579 src += srcstride;

580 dst += dststride;

581 }

582 }

583

584 static void FUNC(put_hevc_pel_bi_w_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

585 int16_t *src2,

586 int height, int denom, int wx0, int wx1,

587 int ox0, int ox1, intptr_t mx, intptr_t my, int width)

588 {

589 int x, y;

590 pixel *src = (pixel *)_src;

591 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

592 pixel *dst = (pixel *)_dst;

593 ptrdiff_t dststride = _dststride / sizeof(pixel);

594

595 int shift = 14 + 1 - BIT_DEPTH;

596 int log2Wd = denom + shift - 1;

597

598 ox0 = ox0 * (1 << (BIT_DEPTH - 8));

599 ox1 = ox1 * (1 << (BIT_DEPTH - 8));

600 for (y = 0; y < height; y++) {

601 for (x = 0; x < width; x++) {

602 dst[x] = av_clip_pixel(( (src[x] << (14 - BIT_DEPTH)) * wx1 + src2[x] * wx0 + ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));

603 }

604 src += srcstride;

605 dst += dststride;

606 src2 += MAX_PB_SIZE;

607 }

608 }

609

610 ////////////////////////////////////////////////////////////////////////////////

611 //

612 ////////////////////////////////////////////////////////////////////////////////

613 #define QPEL_FILTER(src, stride) \

614 (filter[0] * src[x - 3 * stride] + \

615 filter[1] * src[x - 2 * stride] + \

616 filter[2] * src[x - stride] + \

617 filter[3] * src[x ] + \

618 filter[4] * src[x + stride] + \

619 filter[5] * src[x + 2 * stride] + \

620 filter[6] * src[x + 3 * stride] + \

621 filter[7] * src[x + 4 * stride])

622

623 static void FUNC(put_hevc_qpel_h)(int16_t *dst,

624 uint8_t *_src, ptrdiff_t _srcstride,

625 int height, intptr_t mx, intptr_t my, int width)

626 {

627 int x, y;

628 pixel *src = (pixel*)_src;

629 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

630 const int8_t *filter = ff_hevc_qpel_filters[mx - 1];

631 for (y = 0; y < height; y++) {

632 for (x = 0; x < width; x++)

633 dst[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

634 src += srcstride;

635 dst += MAX_PB_SIZE;

636 }

637 }

638

639 static void FUNC(put_hevc_qpel_v)(int16_t *dst,

640 uint8_t *_src, ptrdiff_t _srcstride,

641 int height, intptr_t mx, intptr_t my, int width)

642 {

643 int x, y;

644 pixel *src = (pixel*)_src;

645 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

646 const int8_t *filter = ff_hevc_qpel_filters[my - 1];

647 for (y = 0; y < height; y++) {

648 for (x = 0; x < width; x++)

649 dst[x] = QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8);

650 src += srcstride;

651 dst += MAX_PB_SIZE;

652 }

653 }

654

655 static void FUNC(put_hevc_qpel_hv)(int16_t *dst,

656 uint8_t *_src,

657 ptrdiff_t _srcstride,

658 int height, intptr_t mx,

659 intptr_t my, int width)

660 {

661 int x, y;

662 const int8_t *filter;

663 pixel *src = (pixel*)_src;

664 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

665 int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];

666 int16_t *tmp = tmp_array;

667

668 src -= QPEL_EXTRA_BEFORE * srcstride;

669 filter = ff_hevc_qpel_filters[mx - 1];

670 for (y = 0; y < height + QPEL_EXTRA; y++) {

671 for (x = 0; x < width; x++)

672 tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

673 src += srcstride;

674 tmp += MAX_PB_SIZE;

675 }

676

677 tmp = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

678 filter = ff_hevc_qpel_filters[my - 1];

679 for (y = 0; y < height; y++) {

680 for (x = 0; x < width; x++)

681 dst[x] = QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6;

682 tmp += MAX_PB_SIZE;

683 dst += MAX_PB_SIZE;

684 }

685 }

686

687 static void FUNC(put_hevc_qpel_uni_h)(uint8_t *_dst, ptrdiff_t _dststride,

688 uint8_t *_src, ptrdiff_t _srcstride,

689 int height, intptr_t mx, intptr_t my, int width)

690 {

691 int x, y;

692 pixel *src = (pixel*)_src;

693 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

694 pixel *dst = (pixel *)_dst;

695 ptrdiff_t dststride = _dststride / sizeof(pixel);

696 const int8_t *filter = ff_hevc_qpel_filters[mx - 1];

697 int shift = 14 - BIT_DEPTH;

698

699 #if BIT_DEPTH < 14

700 int offset = 1 << (shift - 1);

701 #else

702 int offset = 0;

703 #endif

704

705 for (y = 0; y < height; y++) {

706 for (x = 0; x < width; x++)

707 dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);

708 src += srcstride;

709 dst += dststride;

710 }

711 }

712

713 static void FUNC(put_hevc_qpel_bi_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

714 int16_t *src2,

715 int height, intptr_t mx, intptr_t my, int width)

716 {

717 int x, y;

718 pixel *src = (pixel*)_src;

719 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

720 pixel *dst = (pixel *)_dst;

721 ptrdiff_t dststride = _dststride / sizeof(pixel);

722

723 const int8_t *filter = ff_hevc_qpel_filters[mx - 1];

724

725 int shift = 14 + 1 - BIT_DEPTH;

726 #if BIT_DEPTH < 14

727 int offset = 1 << (shift - 1);

728 #else

729 int offset = 0;

730 #endif

731

732 for (y = 0; y < height; y++) {

733 for (x = 0; x < width; x++)

734 dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);

735 src += srcstride;

736 dst += dststride;

737 src2 += MAX_PB_SIZE;

738 }

739 }

740

741 static void FUNC(put_hevc_qpel_uni_v)(uint8_t *_dst, ptrdiff_t _dststride,

742 uint8_t *_src, ptrdiff_t _srcstride,

743 int height, intptr_t mx, intptr_t my, int width)

744 {

745 int x, y;

746 pixel *src = (pixel*)_src;

747 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

748 pixel *dst = (pixel *)_dst;

749 ptrdiff_t dststride = _dststride / sizeof(pixel);

750 const int8_t *filter = ff_hevc_qpel_filters[my - 1];

751 int shift = 14 - BIT_DEPTH;

752

753 #if BIT_DEPTH < 14

754 int offset = 1 << (shift - 1);

755 #else

756 int offset = 0;

757 #endif

758

759 for (y = 0; y < height; y++) {

760 for (x = 0; x < width; x++)

761 dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + offset) >> shift);

762 src += srcstride;

763 dst += dststride;

764 }

765 }

766

767

768 static void FUNC(put_hevc_qpel_bi_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

769 int16_t *src2,

770 int height, intptr_t mx, intptr_t my, int width)

771 {

772 int x, y;

773 pixel *src = (pixel*)_src;

774 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

775 pixel *dst = (pixel *)_dst;

776 ptrdiff_t dststride = _dststride / sizeof(pixel);

777

778 const int8_t *filter = ff_hevc_qpel_filters[my - 1];

779

780 int shift = 14 + 1 - BIT_DEPTH;

781 #if BIT_DEPTH < 14

782 int offset = 1 << (shift - 1);

783 #else

784 int offset = 0;

785 #endif

786

787 for (y = 0; y < height; y++) {

788 for (x = 0; x < width; x++)

789 dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);

790 src += srcstride;

791 dst += dststride;

792 src2 += MAX_PB_SIZE;

793 }

794 }

795

796 static void FUNC(put_hevc_qpel_uni_hv)(uint8_t *_dst, ptrdiff_t _dststride,

797 uint8_t *_src, ptrdiff_t _srcstride,

798 int height, intptr_t mx, intptr_t my, int width)

799 {

800 int x, y;

801 const int8_t *filter;

802 pixel *src = (pixel*)_src;

803 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

804 pixel *dst = (pixel *)_dst;

805 ptrdiff_t dststride = _dststride / sizeof(pixel);

806 int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];

807 int16_t *tmp = tmp_array;

808 int shift = 14 - BIT_DEPTH;

809

810 #if BIT_DEPTH < 14

811 int offset = 1 << (shift - 1);

812 #else

813 int offset = 0;

814 #endif

815

816 src -= QPEL_EXTRA_BEFORE * srcstride;

817 filter = ff_hevc_qpel_filters[mx - 1];

818 for (y = 0; y < height + QPEL_EXTRA; y++) {

819 for (x = 0; x < width; x++)

820 tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

821 src += srcstride;

822 tmp += MAX_PB_SIZE;

823 }

824

825 tmp = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

826 filter = ff_hevc_qpel_filters[my - 1];

827

828 for (y = 0; y < height; y++) {

829 for (x = 0; x < width; x++)

830 dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);

831 tmp += MAX_PB_SIZE;

832 dst += dststride;

833 }

834 }

835

836 static void FUNC(put_hevc_qpel_bi_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

837 int16_t *src2,

838 int height, intptr_t mx, intptr_t my, int width)

839 {

840 int x, y;

841 const int8_t *filter;

842 pixel *src = (pixel*)_src;

843 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

844 pixel *dst = (pixel *)_dst;

845 ptrdiff_t dststride = _dststride / sizeof(pixel);

846 int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];

847 int16_t *tmp = tmp_array;

848 int shift = 14 + 1 - BIT_DEPTH;

849 #if BIT_DEPTH < 14

850 int offset = 1 << (shift - 1);

851 #else

852 int offset = 0;

853 #endif

854

855 src -= QPEL_EXTRA_BEFORE * srcstride;

856 filter = ff_hevc_qpel_filters[mx - 1];

857 for (y = 0; y < height + QPEL_EXTRA; y++) {

858 for (x = 0; x < width; x++)

859 tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

860 src += srcstride;

861 tmp += MAX_PB_SIZE;

862 }

863

864 tmp = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

865 filter = ff_hevc_qpel_filters[my - 1];

866

867 for (y = 0; y < height; y++) {

868 for (x = 0; x < width; x++)

869 dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + src2[x] + offset) >> shift);

870 tmp += MAX_PB_SIZE;

871 dst += dststride;

872 src2 += MAX_PB_SIZE;

873 }

874 }

875

876 static void FUNC(put_hevc_qpel_uni_w_h)(uint8_t *_dst, ptrdiff_t _dststride,

877 uint8_t *_src, ptrdiff_t _srcstride,

878 int height, int denom, int wx, int ox,

879 intptr_t mx, intptr_t my, int width)

880 {

881 int x, y;

882 pixel *src = (pixel*)_src;

883 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

884 pixel *dst = (pixel *)_dst;

885 ptrdiff_t dststride = _dststride / sizeof(pixel);

886 const int8_t *filter = ff_hevc_qpel_filters[mx - 1];

887 int shift = denom + 14 - BIT_DEPTH;

888 #if BIT_DEPTH < 14

889 int offset = 1 << (shift - 1);

890 #else

891 int offset = 0;

892 #endif

893

894 ox = ox * (1 << (BIT_DEPTH - 8));

895 for (y = 0; y < height; y++) {

896 for (x = 0; x < width; x++)

897 dst[x] = av_clip_pixel((((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);

898 src += srcstride;

899 dst += dststride;

900 }

901 }

902

903 static void FUNC(put_hevc_qpel_bi_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

904 int16_t *src2,

905 int height, int denom, int wx0, int wx1,

906 int ox0, int ox1, intptr_t mx, intptr_t my, int width)

907 {

908 int x, y;

909 pixel *src = (pixel*)_src;

910 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

911 pixel *dst = (pixel *)_dst;

912 ptrdiff_t dststride = _dststride / sizeof(pixel);

913

914 const int8_t *filter = ff_hevc_qpel_filters[mx - 1];

915

916 int shift = 14 + 1 - BIT_DEPTH;

917 int log2Wd = denom + shift - 1;

918

919 ox0 = ox0 * (1 << (BIT_DEPTH - 8));

920 ox1 = ox1 * (1 << (BIT_DEPTH - 8));

921 for (y = 0; y < height; y++) {

922 for (x = 0; x < width; x++)

923 dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +

924 ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));

925 src += srcstride;

926 dst += dststride;

927 src2 += MAX_PB_SIZE;

928 }

929 }

930

931 static void FUNC(put_hevc_qpel_uni_w_v)(uint8_t *_dst, ptrdiff_t _dststride,

932 uint8_t *_src, ptrdiff_t _srcstride,

933 int height, int denom, int wx, int ox,

934 intptr_t mx, intptr_t my, int width)

935 {

936 int x, y;

937 pixel *src = (pixel*)_src;

938 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

939 pixel *dst = (pixel *)_dst;

940 ptrdiff_t dststride = _dststride / sizeof(pixel);

941 const int8_t *filter = ff_hevc_qpel_filters[my - 1];

942 int shift = denom + 14 - BIT_DEPTH;

943 #if BIT_DEPTH < 14

944 int offset = 1 << (shift - 1);

945 #else

946 int offset = 0;

947 #endif

948

949 ox = ox * (1 << (BIT_DEPTH - 8));

950 for (y = 0; y < height; y++) {

951 for (x = 0; x < width; x++)

952 dst[x] = av_clip_pixel((((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);

953 src += srcstride;

954 dst += dststride;

955 }

956 }

957

958 static void FUNC(put_hevc_qpel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

959 int16_t *src2,

960 int height, int denom, int wx0, int wx1,

961 int ox0, int ox1, intptr_t mx, intptr_t my, int width)

962 {

963 int x, y;

964 pixel *src = (pixel*)_src;

965 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

966 pixel *dst = (pixel *)_dst;

967 ptrdiff_t dststride = _dststride / sizeof(pixel);

968

969 const int8_t *filter = ff_hevc_qpel_filters[my - 1];

970

971 int shift = 14 + 1 - BIT_DEPTH;

972 int log2Wd = denom + shift - 1;

973

974 ox0 = ox0 * (1 << (BIT_DEPTH - 8));

975 ox1 = ox1 * (1 << (BIT_DEPTH - 8));

976 for (y = 0; y < height; y++) {

977 for (x = 0; x < width; x++)

978 dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +

979 ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));

980 src += srcstride;

981 dst += dststride;

982 src2 += MAX_PB_SIZE;

983 }

984 }

985

986 static void FUNC(put_hevc_qpel_uni_w_hv)(uint8_t *_dst, ptrdiff_t _dststride,

987 uint8_t *_src, ptrdiff_t _srcstride,

988 int height, int denom, int wx, int ox,

989 intptr_t mx, intptr_t my, int width)

990 {

991 int x, y;

992 const int8_t *filter;

993 pixel *src = (pixel*)_src;

994 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

995 pixel *dst = (pixel *)_dst;

996 ptrdiff_t dststride = _dststride / sizeof(pixel);

997 int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];

998 int16_t *tmp = tmp_array;

999 int shift = denom + 14 - BIT_DEPTH;

1000 #if BIT_DEPTH < 14

1001 int offset = 1 << (shift - 1);

1002 #else

1003 int offset = 0;

1004 #endif

1005

1006 src -= QPEL_EXTRA_BEFORE * srcstride;

1007 filter = ff_hevc_qpel_filters[mx - 1];

1008 for (y = 0; y < height + QPEL_EXTRA; y++) {

1009 for (x = 0; x < width; x++)

1010 tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

1011 src += srcstride;

1012 tmp += MAX_PB_SIZE;

1013 }

1014

1015 tmp = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

1016 filter = ff_hevc_qpel_filters[my - 1];

1017

1018 ox = ox * (1 << (BIT_DEPTH - 8));

1019 for (y = 0; y < height; y++) {

1020 for (x = 0; x < width; x++)

1021 dst[x] = av_clip_pixel((((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);

1022 tmp += MAX_PB_SIZE;

1023 dst += dststride;

1024 }

1025 }

1026

1027 static void FUNC(put_hevc_qpel_bi_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1028 int16_t *src2,

1029 int height, int denom, int wx0, int wx1,

1030 int ox0, int ox1, intptr_t mx, intptr_t my, int width)

1031 {

1032 int x, y;

1033 const int8_t *filter;

1034 pixel *src = (pixel*)_src;

1035 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1036 pixel *dst = (pixel *)_dst;

1037 ptrdiff_t dststride = _dststride / sizeof(pixel);

1038 int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];

1039 int16_t *tmp = tmp_array;

1040 int shift = 14 + 1 - BIT_DEPTH;

1041 int log2Wd = denom + shift - 1;

1042

1043 src -= QPEL_EXTRA_BEFORE * srcstride;

1044 filter = ff_hevc_qpel_filters[mx - 1];

1045 for (y = 0; y < height + QPEL_EXTRA; y++) {

1046 for (x = 0; x < width; x++)

1047 tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

1048 src += srcstride;

1049 tmp += MAX_PB_SIZE;

1050 }

1051

1052 tmp = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

1053 filter = ff_hevc_qpel_filters[my - 1];

1054

1055 ox0 = ox0 * (1 << (BIT_DEPTH - 8));

1056 ox1 = ox1 * (1 << (BIT_DEPTH - 8));

1057 for (y = 0; y < height; y++) {

1058 for (x = 0; x < width; x++)

1059 dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx1 + src2[x] * wx0 +

1060 ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));

1061 tmp += MAX_PB_SIZE;

1062 dst += dststride;

1063 src2 += MAX_PB_SIZE;

1064 }

1065 }

1066

1067 ////////////////////////////////////////////////////////////////////////////////

1068 //

1069 ////////////////////////////////////////////////////////////////////////////////

1070 #define EPEL_FILTER(src, stride) \

1071 (filter[0] * src[x - stride] + \

1072 filter[1] * src[x] + \

1073 filter[2] * src[x + stride] + \

1074 filter[3] * src[x + 2 * stride])

1075

1076 static void FUNC(put_hevc_epel_h)(int16_t *dst,

1077 uint8_t *_src, ptrdiff_t _srcstride,

1078 int height, intptr_t mx, intptr_t my, int width)

1079 {

1080 int x, y;

1081 pixel *src = (pixel *)_src;

1082 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1083 const int8_t *filter = ff_hevc_epel_filters[mx - 1];

1084 for (y = 0; y < height; y++) {

1085 for (x = 0; x < width; x++)

1086 dst[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

1087 src += srcstride;

1088 dst += MAX_PB_SIZE;

1089 }

1090 }

1091

1092 static void FUNC(put_hevc_epel_v)(int16_t *dst,

1093 uint8_t *_src, ptrdiff_t _srcstride,

1094 int height, intptr_t mx, intptr_t my, int width)

1095 {

1096 int x, y;

1097 pixel *src = (pixel *)_src;

1098 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1099 const int8_t *filter = ff_hevc_epel_filters[my - 1];

1100

1101 for (y = 0; y < height; y++) {

1102 for (x = 0; x < width; x++)

1103 dst[x] = EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8);

1104 src += srcstride;

1105 dst += MAX_PB_SIZE;

1106 }

1107 }

1108

1109 static void FUNC(put_hevc_epel_hv)(int16_t *dst,

1110 uint8_t *_src, ptrdiff_t _srcstride,

1111 int height, intptr_t mx, intptr_t my, int width)

1112 {

1113 int x, y;

1114 pixel *src = (pixel *)_src;

1115 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1116 const int8_t *filter = ff_hevc_epel_filters[mx - 1];

1117 int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];

1118 int16_t *tmp = tmp_array;

1119

1120 src -= EPEL_EXTRA_BEFORE * srcstride;

1121

1122 for (y = 0; y < height + EPEL_EXTRA; y++) {

1123 for (x = 0; x < width; x++)

1124 tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

1125 src += srcstride;

1126 tmp += MAX_PB_SIZE;

1127 }

1128

1129 tmp = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

1130 filter = ff_hevc_epel_filters[my - 1];

1131

1132 for (y = 0; y < height; y++) {

1133 for (x = 0; x < width; x++)

1134 dst[x] = EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6;

1135 tmp += MAX_PB_SIZE;

1136 dst += MAX_PB_SIZE;

1137 }

1138 }

1139

1140 static void FUNC(put_hevc_epel_uni_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1141 int height, intptr_t mx, intptr_t my, int width)

1142 {

1143 int x, y;

1144 pixel *src = (pixel *)_src;

1145 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1146 pixel *dst = (pixel *)_dst;

1147 ptrdiff_t dststride = _dststride / sizeof(pixel);

1148 const int8_t *filter = ff_hevc_epel_filters[mx - 1];

1149 int shift = 14 - BIT_DEPTH;

1150 #if BIT_DEPTH < 14

1151 int offset = 1 << (shift - 1);

1152 #else

1153 int offset = 0;

1154 #endif

1155

1156 for (y = 0; y < height; y++) {

1157 for (x = 0; x < width; x++)

1158 dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);

1159 src += srcstride;

1160 dst += dststride;

1161 }

1162 }

1163

1164 static void FUNC(put_hevc_epel_bi_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1165 int16_t *src2,

1166 int height, intptr_t mx, intptr_t my, int width)

1167 {

1168 int x, y;

1169 pixel *src = (pixel *)_src;

1170 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1171 pixel *dst = (pixel *)_dst;

1172 ptrdiff_t dststride = _dststride / sizeof(pixel);

1173 const int8_t *filter = ff_hevc_epel_filters[mx - 1];

1174 int shift = 14 + 1 - BIT_DEPTH;

1175 #if BIT_DEPTH < 14

1176 int offset = 1 << (shift - 1);

1177 #else

1178 int offset = 0;

1179 #endif

1180

1181 for (y = 0; y < height; y++) {

1182 for (x = 0; x < width; x++) {

1183 dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);

1184 }

1185 dst += dststride;

1186 src += srcstride;

1187 src2 += MAX_PB_SIZE;

1188 }

1189 }

1190

1191 static void FUNC(put_hevc_epel_uni_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1192 int height, intptr_t mx, intptr_t my, int width)

1193 {

1194 int x, y;

1195 pixel *src = (pixel *)_src;

1196 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1197 pixel *dst = (pixel *)_dst;

1198 ptrdiff_t dststride = _dststride / sizeof(pixel);

1199 const int8_t *filter = ff_hevc_epel_filters[my - 1];

1200 int shift = 14 - BIT_DEPTH;

1201 #if BIT_DEPTH < 14

1202 int offset = 1 << (shift - 1);

1203 #else

1204 int offset = 0;

1205 #endif

1206

1207 for (y = 0; y < height; y++) {

1208 for (x = 0; x < width; x++)

1209 dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + offset) >> shift);

1210 src += srcstride;

1211 dst += dststride;

1212 }

1213 }

1214

1215 static void FUNC(put_hevc_epel_bi_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1216 int16_t *src2,

1217 int height, intptr_t mx, intptr_t my, int width)

1218 {

1219 int x, y;

1220 pixel *src = (pixel *)_src;

1221 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1222 const int8_t *filter = ff_hevc_epel_filters[my - 1];

1223 pixel *dst = (pixel *)_dst;

1224 ptrdiff_t dststride = _dststride / sizeof(pixel);

1225 int shift = 14 + 1 - BIT_DEPTH;

1226 #if BIT_DEPTH < 14

1227 int offset = 1 << (shift - 1);

1228 #else

1229 int offset = 0;

1230 #endif

1231

1232 for (y = 0; y < height; y++) {

1233 for (x = 0; x < width; x++)

1234 dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);

1235 dst += dststride;

1236 src += srcstride;

1237 src2 += MAX_PB_SIZE;

1238 }

1239 }

1240

1241 static void FUNC(put_hevc_epel_uni_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1242 int height, intptr_t mx, intptr_t my, int width)

1243 {

1244 int x, y;

1245 pixel *src = (pixel *)_src;

1246 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1247 pixel *dst = (pixel *)_dst;

1248 ptrdiff_t dststride = _dststride / sizeof(pixel);

1249 const int8_t *filter = ff_hevc_epel_filters[mx - 1];

1250 int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];

1251 int16_t *tmp = tmp_array;

1252 int shift = 14 - BIT_DEPTH;

1253 #if BIT_DEPTH < 14

1254 int offset = 1 << (shift - 1);

1255 #else

1256 int offset = 0;

1257 #endif

1258

1259 src -= EPEL_EXTRA_BEFORE * srcstride;

1260

1261 for (y = 0; y < height + EPEL_EXTRA; y++) {

1262 for (x = 0; x < width; x++)

1263 tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

1264 src += srcstride;

1265 tmp += MAX_PB_SIZE;

1266 }

1267

1268 tmp = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

1269 filter = ff_hevc_epel_filters[my - 1];

1270

1271 for (y = 0; y < height; y++) {

1272 for (x = 0; x < width; x++)

1273 dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);

1274 tmp += MAX_PB_SIZE;

1275 dst += dststride;

1276 }

1277 }

1278

1279 static void FUNC(put_hevc_epel_bi_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1280 int16_t *src2,

1281 int height, intptr_t mx, intptr_t my, int width)

1282 {

1283 int x, y;

1284 pixel *src = (pixel *)_src;

1285 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1286 pixel *dst = (pixel *)_dst;

1287 ptrdiff_t dststride = _dststride / sizeof(pixel);

1288 const int8_t *filter = ff_hevc_epel_filters[mx - 1];

1289 int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];

1290 int16_t *tmp = tmp_array;

1291 int shift = 14 + 1 - BIT_DEPTH;

1292 #if BIT_DEPTH < 14

1293 int offset = 1 << (shift - 1);

1294 #else

1295 int offset = 0;

1296 #endif

1297

1298 src -= EPEL_EXTRA_BEFORE * srcstride;

1299

1300 for (y = 0; y < height + EPEL_EXTRA; y++) {

1301 for (x = 0; x < width; x++)

1302 tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

1303 src += srcstride;

1304 tmp += MAX_PB_SIZE;

1305 }

1306

1307 tmp = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

1308 filter = ff_hevc_epel_filters[my - 1];

1309

1310 for (y = 0; y < height; y++) {

1311 for (x = 0; x < width; x++)

1312 dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + src2[x] + offset) >> shift);

1313 tmp += MAX_PB_SIZE;

1314 dst += dststride;

1315 src2 += MAX_PB_SIZE;

1316 }

1317 }

1318

1319 static void FUNC(put_hevc_epel_uni_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1320 int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)

1321 {

1322 int x, y;

1323 pixel *src = (pixel *)_src;

1324 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1325 pixel *dst = (pixel *)_dst;

1326 ptrdiff_t dststride = _dststride / sizeof(pixel);

1327 const int8_t *filter = ff_hevc_epel_filters[mx - 1];

1328 int shift = denom + 14 - BIT_DEPTH;

1329 #if BIT_DEPTH < 14

1330 int offset = 1 << (shift - 1);

1331 #else

1332 int offset = 0;

1333 #endif

1334

1335 ox = ox * (1 << (BIT_DEPTH - 8));

1336 for (y = 0; y < height; y++) {

1337 for (x = 0; x < width; x++) {

1338 dst[x] = av_clip_pixel((((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);

1339 }

1340 dst += dststride;

1341 src += srcstride;

1342 }

1343 }

1344

1345 static void FUNC(put_hevc_epel_bi_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1346 int16_t *src2,

1347 int height, int denom, int wx0, int wx1,

1348 int ox0, int ox1, intptr_t mx, intptr_t my, int width)

1349 {

1350 int x, y;

1351 pixel *src = (pixel *)_src;

1352 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1353 pixel *dst = (pixel *)_dst;

1354 ptrdiff_t dststride = _dststride / sizeof(pixel);

1355 const int8_t *filter = ff_hevc_epel_filters[mx - 1];

1356 int shift = 14 + 1 - BIT_DEPTH;

1357 int log2Wd = denom + shift - 1;

1358

1359 ox0 = ox0 * (1 << (BIT_DEPTH - 8));

1360 ox1 = ox1 * (1 << (BIT_DEPTH - 8));

1361 for (y = 0; y < height; y++) {

1362 for (x = 0; x < width; x++)

1363 dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +

1364 ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));

1365 src += srcstride;

1366 dst += dststride;

1367 src2 += MAX_PB_SIZE;

1368 }

1369 }

1370

1371 static void FUNC(put_hevc_epel_uni_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1372 int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)

1373 {

1374 int x, y;

1375 pixel *src = (pixel *)_src;

1376 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1377 pixel *dst = (pixel *)_dst;

1378 ptrdiff_t dststride = _dststride / sizeof(pixel);

1379 const int8_t *filter = ff_hevc_epel_filters[my - 1];

1380 int shift = denom + 14 - BIT_DEPTH;

1381 #if BIT_DEPTH < 14

1382 int offset = 1 << (shift - 1);

1383 #else

1384 int offset = 0;

1385 #endif

1386

1387 ox = ox * (1 << (BIT_DEPTH - 8));

1388 for (y = 0; y < height; y++) {

1389 for (x = 0; x < width; x++) {

1390 dst[x] = av_clip_pixel((((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);

1391 }

1392 dst += dststride;

1393 src += srcstride;

1394 }

1395 }

1396

1397 static void FUNC(put_hevc_epel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1398 int16_t *src2,

1399 int height, int denom, int wx0, int wx1,

1400 int ox0, int ox1, intptr_t mx, intptr_t my, int width)

1401 {

1402 int x, y;

1403 pixel *src = (pixel *)_src;

1404 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1405 const int8_t *filter = ff_hevc_epel_filters[my - 1];

1406 pixel *dst = (pixel *)_dst;

1407 ptrdiff_t dststride = _dststride / sizeof(pixel);

1408 int shift = 14 + 1 - BIT_DEPTH;

1409 int log2Wd = denom + shift - 1;

1410

1411 ox0 = ox0 * (1 << (BIT_DEPTH - 8));

1412 ox1 = ox1 * (1 << (BIT_DEPTH - 8));

1413 for (y = 0; y < height; y++) {

1414 for (x = 0; x < width; x++)

1415 dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +

1416 ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));

1417 src += srcstride;

1418 dst += dststride;

1419 src2 += MAX_PB_SIZE;

1420 }

1421 }

1422

1423 static void FUNC(put_hevc_epel_uni_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1424 int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)

1425 {

1426 int x, y;

1427 pixel *src = (pixel *)_src;

1428 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1429 pixel *dst = (pixel *)_dst;

1430 ptrdiff_t dststride = _dststride / sizeof(pixel);

1431 const int8_t *filter = ff_hevc_epel_filters[mx - 1];

1432 int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];

1433 int16_t *tmp = tmp_array;

1434 int shift = denom + 14 - BIT_DEPTH;

1435 #if BIT_DEPTH < 14

1436 int offset = 1 << (shift - 1);

1437 #else

1438 int offset = 0;

1439 #endif

1440

1441 src -= EPEL_EXTRA_BEFORE * srcstride;

1442

1443 for (y = 0; y < height + EPEL_EXTRA; y++) {

1444 for (x = 0; x < width; x++)

1445 tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

1446 src += srcstride;

1447 tmp += MAX_PB_SIZE;

1448 }

1449

1450 tmp = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

1451 filter = ff_hevc_epel_filters[my - 1];

1452

1453 ox = ox * (1 << (BIT_DEPTH - 8));

1454 for (y = 0; y < height; y++) {

1455 for (x = 0; x < width; x++)

1456 dst[x] = av_clip_pixel((((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);

1457 tmp += MAX_PB_SIZE;

1458 dst += dststride;

1459 }

1460 }

1461

1462 static void FUNC(put_hevc_epel_bi_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

1463 int16_t *src2,

1464 int height, int denom, int wx0, int wx1,

1465 int ox0, int ox1, intptr_t mx, intptr_t my, int width)

1466 {

1467 int x, y;

1468 pixel *src = (pixel *)_src;

1469 ptrdiff_t srcstride = _srcstride / sizeof(pixel);

1470 pixel *dst = (pixel *)_dst;

1471 ptrdiff_t dststride = _dststride / sizeof(pixel);

1472 const int8_t *filter = ff_hevc_epel_filters[mx - 1];

1473 int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];

1474 int16_t *tmp = tmp_array;

1475 int shift = 14 + 1 - BIT_DEPTH;

1476 int log2Wd = denom + shift - 1;

1477

1478 src -= EPEL_EXTRA_BEFORE * srcstride;

1479

1480 for (y = 0; y < height + EPEL_EXTRA; y++) {

1481 for (x = 0; x < width; x++)

1482 tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

1483 src += srcstride;

1484 tmp += MAX_PB_SIZE;

1485 }

1486

1487 tmp = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

1488 filter = ff_hevc_epel_filters[my - 1];

1489

1490 ox0 = ox0 * (1 << (BIT_DEPTH - 8));

1491 ox1 = ox1 * (1 << (BIT_DEPTH - 8));

1492 for (y = 0; y < height; y++) {

1493 for (x = 0; x < width; x++)

1494 dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx1 + src2[x] * wx0 +

1495 ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));

1496 tmp += MAX_PB_SIZE;

1497 dst += dststride;

1498 src2 += MAX_PB_SIZE;

1499 }

1500 }// line zero

1501 #define P3 pix[-4 * xstride]

1502 #define P2 pix[-3 * xstride]

1503 #define P1 pix[-2 * xstride]

1504 #define P0 pix[-1 * xstride]

1505 #define Q0 pix[0 * xstride]

1506 #define Q1 pix[1 * xstride]

1507 #define Q2 pix[2 * xstride]

1508 #define Q3 pix[3 * xstride]

1509

1510 // line three. used only for deblocking decision

1511 #define TP3 pix[-4 * xstride + 3 * ystride]

1512 #define TP2 pix[-3 * xstride + 3 * ystride]

1513 #define TP1 pix[-2 * xstride + 3 * ystride]

1514 #define TP0 pix[-1 * xstride + 3 * ystride]

1515 #define TQ0 pix[0 * xstride + 3 * ystride]

1516 #define TQ1 pix[1 * xstride + 3 * ystride]

1517 #define TQ2 pix[2 * xstride + 3 * ystride]

1518 #define TQ3 pix[3 * xstride + 3 * ystride]

1519

1520 static void FUNC(hevc_loop_filter_luma)(uint8_t *_pix,

1521 ptrdiff_t _xstride, ptrdiff_t _ystride,

1522 int beta, int *_tc,

1523 uint8_t *_no_p, uint8_t *_no_q)

1524 {

1525 int d, j;

1526 pixel *pix = (pixel *)_pix;

1527 ptrdiff_t xstride = _xstride / sizeof(pixel);

1528 ptrdiff_t ystride = _ystride / sizeof(pixel);

1529

1530 beta <<= BIT_DEPTH - 8;

1531

1532 for (j = 0; j < 2; j++) {

1533 const int dp0 = abs(P2 - 2 * P1 + P0);

1534 const int dq0 = abs(Q2 - 2 * Q1 + Q0);

1535 const int dp3 = abs(TP2 - 2 * TP1 + TP0);

1536 const int dq3 = abs(TQ2 - 2 * TQ1 + TQ0);

1537 const int d0 = dp0 + dq0;

1538 const int d3 = dp3 + dq3;

1539 const int tc = _tc[j] << (BIT_DEPTH - 8);

1540 const int no_p = _no_p[j];

1541 const int no_q = _no_q[j];

1542

1543 if (d0 + d3 >= beta) {

1544 pix += 4 * ystride;

1545 continue;

1546 } else {

1547 const int beta_3 = beta >> 3;

1548 const int beta_2 = beta >> 2;

1549 const int tc25 = ((tc * 5 + 1) >> 1);

1550

1551 if (abs(P3 - P0) + abs(Q3 - Q0) < beta_3 && abs(P0 - Q0) < tc25 &&

1552 abs(TP3 - TP0) + abs(TQ3 - TQ0) < beta_3 && abs(TP0 - TQ0) < tc25 &&

1553 (d0 << 1) < beta_2 && (d3 << 1) < beta_2) {

1554 // strong filtering

1555 const int tc2 = tc << 1;

1556 for (d = 0; d < 4; d++) {

1557 const int p3 = P3;

1558 const int p2 = P2;

1559 const int p1 = P1;

1560 const int p0 = P0;

1561 const int q0 = Q0;

1562 const int q1 = Q1;

1563 const int q2 = Q2;

1564 const int q3 = Q3;

1565 if (!no_p) {

1566 P0 = p0 + av_clip(((p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3) - p0, -tc2, tc2);

1567 P1 = p1 + av_clip(((p2 + p1 + p0 + q0 + 2) >> 2) - p1, -tc2, tc2);

1568 P2 = p2 + av_clip(((2 * p3 + 3 * p2 + p1 + p0 + q0 + 4) >> 3) - p2, -tc2, tc2);

1569 }

1570 if (!no_q) {

1571 Q0 = q0 + av_clip(((p1 + 2 * p0 + 2 * q0 + 2 * q1 + q2 + 4) >> 3) - q0, -tc2, tc2);

1572 Q1 = q1 + av_clip(((p0 + q0 + q1 + q2 + 2) >> 2) - q1, -tc2, tc2);

1573 Q2 = q2 + av_clip(((2 * q3 + 3 * q2 + q1 + q0 + p0 + 4) >> 3) - q2, -tc2, tc2);

1574 }

1575 pix += ystride;

1576 }

1577 } else { // normal filtering

1578 int nd_p = 1;

1579 int nd_q = 1;

1580 const int tc_2 = tc >> 1;

1581 if (dp0 + dp3 < ((beta + (beta >> 1)) >> 3))

1582 nd_p = 2;

1583 if (dq0 + dq3 < ((beta + (beta >> 1)) >> 3))

1584 nd_q = 2;

1585

1586 for (d = 0; d < 4; d++) {

1587 const int p2 = P2;

1588 const int p1 = P1;

1589 const int p0 = P0;

1590 const int q0 = Q0;

1591 const int q1 = Q1;

1592 const int q2 = Q2;

1593 int delta0 = (9 * (q0 - p0) - 3 * (q1 - p1) + 8) >> 4;

1594 if (abs(delta0) < 10 * tc) {

1595 delta0 = av_clip(delta0, -tc, tc);

1596 if (!no_p)

1597 P0 = av_clip_pixel(p0 + delta0);

1598 if (!no_q)

1599 Q0 = av_clip_pixel(q0 - delta0);

1600 if (!no_p && nd_p > 1) {

1601 const int deltap1 = av_clip((((p2 + p0 + 1) >> 1) - p1 + delta0) >> 1, -tc_2, tc_2);

1602 P1 = av_clip_pixel(p1 + deltap1);

1603 }

1604 if (!no_q && nd_q > 1) {

1605 const int deltaq1 = av_clip((((q2 + q0 + 1) >> 1) - q1 - delta0) >> 1, -tc_2, tc_2);

1606 Q1 = av_clip_pixel(q1 + deltaq1);

1607 }

1608 }

1609 pix += ystride;

1610 }

1611 }

1612 }

1613 }

1614 }

1615

1616 static void FUNC(hevc_loop_filter_chroma)(uint8_t *_pix, ptrdiff_t _xstride,

1617 ptrdiff_t _ystride, int *_tc,

1618 uint8_t *_no_p, uint8_t *_no_q)

1619 {

1620 int d, j, no_p, no_q;

1621 pixel *pix = (pixel *)_pix;

1622 ptrdiff_t xstride = _xstride / sizeof(pixel);

1623 ptrdiff_t ystride = _ystride / sizeof(pixel);

1624

1625 for (j = 0; j < 2; j++) {

1626 const int tc = _tc[j] << (BIT_DEPTH - 8);

1627 if (tc <= 0) {

1628 pix += 4 * ystride;

1629 continue;

1630 }

1631 no_p = _no_p[j];

1632 no_q = _no_q[j];

1633

1634 for (d = 0; d < 4; d++) {

1635 int delta0;

1636 const int p1 = P1;

1637 const int p0 = P0;

1638 const int q0 = Q0;

1639 const int q1 = Q1;

1640 delta0 = av_clip((((q0 - p0) * 4) + p1 - q1 + 4) >> 3, -tc, tc);

1641 if (!no_p)

1642 P0 = av_clip_pixel(p0 + delta0);

1643 if (!no_q)

1644 Q0 = av_clip_pixel(q0 - delta0);

1645 pix += ystride;

1646 }

1647 }

1648 }

1649

1650 static void FUNC(hevc_h_loop_filter_chroma)(uint8_t *pix, ptrdiff_t stride,

1651 int32_t *tc, uint8_t *no_p,

1652 uint8_t *no_q)

1653 {

1654 FUNC(hevc_loop_filter_chroma)(pix, stride, sizeof(pixel), tc, no_p, no_q);

1655 }

1656

1657 static void FUNC(hevc_v_loop_filter_chroma)(uint8_t *pix, ptrdiff_t stride,

1658 int32_t *tc, uint8_t *no_p,

1659 uint8_t *no_q)

1660 {

1661 FUNC(hevc_loop_filter_chroma)(pix, sizeof(pixel), stride, tc, no_p, no_q);

1662 }

1663

1664 static void FUNC(hevc_h_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride,

1665 int beta, int32_t *tc, uint8_t *no_p,

1666 uint8_t *no_q)

1667 {

1668 FUNC(hevc_loop_filter_luma)(pix, stride, sizeof(pixel),

1669 beta, tc, no_p, no_q);

1670 }

1671

1672 static void FUNC(hevc_v_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride,

1673 int beta, int32_t *tc, uint8_t *no_p,

1674 uint8_t *no_q)

1675 {

1676 FUNC(hevc_loop_filter_luma)(pix, sizeof(pixel), stride,

1677 beta, tc, no_p, no_q);

1678 }

1679

1680 #undef P3

1681 #undef P2

1682 #undef P1

1683 #undef P0

1684 #undef Q0

1685 #undef Q1

1686 #undef Q2

1687 #undef Q3

1688

1689 #undef TP3

1690 #undef TP2

1691 #undef TP1

1692 #undef TP0

1693 #undef TQ0

1694 #undef TQ1

1695 #undef TQ2

1696 #undef TQ3

Generated on Sun Mar 8 2015 02:34:53 for FFmpeg by doxygen 1.8.2