falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
101790 Commits
32 Branches
424MB
Branch: n4.4-jackoutdev
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'n4.4-jackoutdev'
${ noResults }
FFmpeg/tests/checkasm/h264dsp.c

454 lines
22KB
Raw Permalink Blame History 

  1. /*

  2.  * Copyright (c) 2016 Martin Storsjo

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

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

  7.  * it under the terms of the GNU General Public License as published by

  8.  * the Free Software Foundation; either version 2 of the License, or

  9.  * (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

  14.  * GNU General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU General Public License along

  17.  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,

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

  19.  */

  20. 

  21. #include <string.h>

  22. #include "checkasm.h"

  23. #include "libavcodec/avcodec.h"

  24. #include "libavcodec/h264dsp.h"

  25. #include "libavcodec/h264data.h"

  26. #include "libavutil/common.h"

  27. #include "libavutil/internal.h"

  28. #include "libavutil/intreadwrite.h"

  29. #include "libavutil/mem_internal.h"

  30. 

  31. static const uint32_t pixel_mask[3] = { 0xffffffff, 0x01ff01ff, 0x03ff03ff };

  32. static const uint32_t pixel_mask_lf[3] = { 0xff0fff0f, 0x01ff000f, 0x03ff000f };

  33. 

  34. #define SIZEOF_PIXEL ((bit_depth + 7) / 8)

  35. #define SIZEOF_COEF  (2 * ((bit_depth + 7) / 8))

  36. #define PIXEL_STRIDE 16

  37. 

  38. #define randomize_buffers()                                                  \

  39.     do {                                                                     \

  40.         int x, y;                                                            \

  41.         uint32_t mask = pixel_mask[bit_depth - 8];                           \

  42.         for (y = 0; y < sz; y++) {                                           \

  43.             for (x = 0; x < PIXEL_STRIDE; x += 4) {                          \

  44.                 AV_WN32A(src + y * PIXEL_STRIDE + x, rnd() & mask);          \

  45.                 AV_WN32A(dst + y * PIXEL_STRIDE + x, rnd() & mask);          \

  46.             }                                                                \

  47.             for (x = 0; x < sz; x++) {                                       \

  48.                 if (bit_depth == 8) {                                        \

  49.                     coef[y * sz + x] = src[y * PIXEL_STRIDE + x] -           \

  50.                                        dst[y * PIXEL_STRIDE + x];            \

  51.                 } else {                                                     \

  52.                     ((int32_t *)coef)[y * sz + x] =                          \

  53.                         ((uint16_t *)src)[y * (PIXEL_STRIDE/2) + x] -        \

  54.                         ((uint16_t *)dst)[y * (PIXEL_STRIDE/2) + x];         \

  55.                 }                                                            \

  56.             }                                                                \

  57.         }                                                                    \

  58.     } while (0)

  59. 

  60. #define dct4x4_impl(size, dctcoef)                                           \

  61. static void dct4x4_##size(dctcoef *coef)                                     \

  62. {                                                                            \

  63.     int i, y, x;                                                             \

  64.     dctcoef tmp[16];                                                         \

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

  66.         const int z0 = coef[i*4 + 0] + coef[i*4 + 3];                        \

  67.         const int z1 = coef[i*4 + 1] + coef[i*4 + 2];                        \

  68.         const int z2 = coef[i*4 + 0] - coef[i*4 + 3];                        \

  69.         const int z3 = coef[i*4 + 1] - coef[i*4 + 2];                        \

  70.         tmp[i + 4*0] =   z0 +   z1;                                          \

  71.         tmp[i + 4*1] = 2*z2 +   z3;                                          \

  72.         tmp[i + 4*2] =   z0 -   z1;                                          \

  73.         tmp[i + 4*3] =   z2 - 2*z3;                                          \

  74.     }                                                                        \

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

  76.         const int z0 = tmp[i*4 + 0] + tmp[i*4 + 3];                          \

  77.         const int z1 = tmp[i*4 + 1] + tmp[i*4 + 2];                          \

  78.         const int z2 = tmp[i*4 + 0] - tmp[i*4 + 3];                          \

  79.         const int z3 = tmp[i*4 + 1] - tmp[i*4 + 2];                          \

  80.         coef[i*4 + 0] =   z0 +   z1;                                         \

  81.         coef[i*4 + 1] = 2*z2 +   z3;                                         \

  82.         coef[i*4 + 2] =   z0 -   z1;                                         \

  83.         coef[i*4 + 3] =   z2 - 2*z3;                                         \

  84.     }                                                                        \

  85.     for (y = 0; y < 4; y++) {                                                \

  86.         for (x = 0; x < 4; x++) {                                            \

  87.             static const int scale[] = { 13107 * 10, 8066 * 13, 5243 * 16 }; \

  88.             const int idx = (y & 1) + (x & 1);                               \

  89.             coef[y*4 + x] = (coef[y*4 + x] * scale[idx] + (1 << 14)) >> 15;  \

  90.         }                                                                    \

  91.     }                                                                        \

  92. }

  93. 

  94. #define DCT8_1D(src, srcstride, dst, dststride) do {                         \

  95.     const int a0 = (src)[srcstride * 0] + (src)[srcstride * 7];              \

  96.     const int a1 = (src)[srcstride * 0] - (src)[srcstride * 7];              \

  97.     const int a2 = (src)[srcstride * 1] + (src)[srcstride * 6];              \

  98.     const int a3 = (src)[srcstride * 1] - (src)[srcstride * 6];              \

  99.     const int a4 = (src)[srcstride * 2] + (src)[srcstride * 5];              \

  100.     const int a5 = (src)[srcstride * 2] - (src)[srcstride * 5];              \

  101.     const int a6 = (src)[srcstride * 3] + (src)[srcstride * 4];              \

  102.     const int a7 = (src)[srcstride * 3] - (src)[srcstride * 4];              \

  103.     const int b0 = a0 + a6;                                                  \

  104.     const int b1 = a2 + a4;                                                  \

  105.     const int b2 = a0 - a6;                                                  \

  106.     const int b3 = a2 - a4;                                                  \

  107.     const int b4 = a3 + a5 + (a1 + (a1 >> 1));                               \

  108.     const int b5 = a1 - a7 - (a5 + (a5 >> 1));                               \

  109.     const int b6 = a1 + a7 - (a3 + (a3 >> 1));                               \

  110.     const int b7 = a3 - a5 + (a7 + (a7 >> 1));                               \

  111.     (dst)[dststride * 0] =  b0 +  b1;                                        \

  112.     (dst)[dststride * 1] =  b4 + (b7 >> 2);                                  \

  113.     (dst)[dststride * 2] =  b2 + (b3 >> 1);                                  \

  114.     (dst)[dststride * 3] =  b5 + (b6 >> 2);                                  \

  115.     (dst)[dststride * 4] =  b0  - b1;                                        \

  116.     (dst)[dststride * 5] =  b6 - (b5 >> 2);                                  \

  117.     (dst)[dststride * 6] = (b2 >> 1) - b3;                                   \

  118.     (dst)[dststride * 7] = (b4 >> 2) - b7;                                   \

  119. } while (0)

  120. 

  121. #define dct8x8_impl(size, dctcoef)                                           \

  122. static void dct8x8_##size(dctcoef *coef)                                     \

  123. {                                                                            \

  124.     int i, x, y;                                                             \

  125.     dctcoef tmp[64];                                                         \

  126.     for (i = 0; i < 8; i++)                                                  \

  127.         DCT8_1D(coef + i, 8, tmp + i, 8);                                    \

  128.                                                                              \

  129.     for (i = 0; i < 8; i++)                                                  \

  130.         DCT8_1D(tmp + 8*i, 1, coef + i, 8);                                  \

  131.                                                                              \

  132.     for (y = 0; y < 8; y++) {                                                \

  133.         for (x = 0; x < 8; x++) {                                            \

  134.             static const int scale[] = {                                     \

  135.                 13107 * 20, 11428 * 18, 20972 * 32,                          \

  136.                 12222 * 19, 16777 * 25, 15481 * 24,                          \

  137.             };                                                               \

  138.             static const int idxmap[] = {                                    \

  139.                 0, 3, 4, 3,                                                  \

  140.                 3, 1, 5, 1,                                                  \

  141.                 4, 5, 2, 5,                                                  \

  142.                 3, 1, 5, 1,                                                  \

  143.             };                                                               \

  144.             const int idx = idxmap[(y & 3) * 4 + (x & 3)];                   \

  145.             coef[y*8 + x] = ((int64_t)coef[y*8 + x] *                        \

  146.                              scale[idx] + (1 << 17)) >> 18;                  \

  147.         }                                                                    \

  148.     }                                                                        \

  149. }

  150. 

  151. dct4x4_impl(16, int16_t)

  152. dct4x4_impl(32, int32_t)

  153. 

  154. dct8x8_impl(16, int16_t)

  155. dct8x8_impl(32, int32_t)

  156. 

  157. static void dct4x4(int16_t *coef, int bit_depth)

  158. {

  159.     if (bit_depth == 8)

  160.         dct4x4_16(coef);

  161.     else

  162.         dct4x4_32((int32_t *) coef);

  163. }

  164. 

  165. static void dct8x8(int16_t *coef, int bit_depth)

  166. {

  167.     if (bit_depth == 8) {

  168.         dct8x8_16(coef);

  169.     } else {

  170.         dct8x8_32((int32_t *) coef);

  171.     }

  172. }

  173. 

  174. 

  175. static void check_idct(void)

  176. {

  177.     LOCAL_ALIGNED_16(uint8_t, src,  [8 * 8 * 2]);

  178.     LOCAL_ALIGNED_16(uint8_t, dst,  [8 * 8 * 2]);

  179.     LOCAL_ALIGNED_16(uint8_t, dst0, [8 * 8 * 2]);

  180.     LOCAL_ALIGNED_16(uint8_t, dst1_base, [8 * 8 * 2 + 32]);

  181.     LOCAL_ALIGNED_16(int16_t, coef, [8 * 8 * 2]);

  182.     LOCAL_ALIGNED_16(int16_t, subcoef0, [8 * 8 * 2]);

  183.     LOCAL_ALIGNED_16(int16_t, subcoef1, [8 * 8 * 2]);

  184.     H264DSPContext h;

  185.     int bit_depth, sz, align, dc;

  186.     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t *block, int stride);

  187. 

  188.     for (bit_depth = 8; bit_depth <= 10; bit_depth++) {

  189.         ff_h264dsp_init(&h, bit_depth, 1);

  190.         for (sz = 4; sz <= 8; sz += 4) {

  191.             randomize_buffers();

  192. 

  193.             if (sz == 4)

  194.                 dct4x4(coef, bit_depth);

  195.             else

  196.                 dct8x8(coef, bit_depth);

  197. 

  198.             for (dc = 0; dc <= 1; dc++) {

  199.                 void (*idct)(uint8_t *, int16_t *, int) = NULL;

  200.                 switch ((sz << 1) | dc) {

  201.                 case (4 << 1) | 0: idct = h.h264_idct_add; break;

  202.                 case (4 << 1) | 1: idct = h.h264_idct_dc_add; break;

  203.                 case (8 << 1) | 0: idct = h.h264_idct8_add; break;

  204.                 case (8 << 1) | 1: idct = h.h264_idct8_dc_add; break;

  205.                 }

  206.                 if (check_func(idct, "h264_idct%d_add%s_%dbpp", sz, dc ? "_dc" : "", bit_depth)) {

  207.                     for (align = 0; align < 16; align += sz * SIZEOF_PIXEL) {

  208.                         uint8_t *dst1 = dst1_base + align;

  209.                         if (dc) {

  210.                             memset(subcoef0, 0, sz * sz * SIZEOF_COEF);

  211.                             memcpy(subcoef0, coef, SIZEOF_COEF);

  212.                         } else {

  213.                             memcpy(subcoef0, coef, sz * sz * SIZEOF_COEF);

  214.                         }

  215.                         memcpy(dst0, dst, sz * PIXEL_STRIDE);

  216.                         memcpy(dst1, dst, sz * PIXEL_STRIDE);

  217.                         memcpy(subcoef1, subcoef0, sz * sz * SIZEOF_COEF);

  218.                         call_ref(dst0, subcoef0, PIXEL_STRIDE);

  219.                         call_new(dst1, subcoef1, PIXEL_STRIDE);

  220.                         if (memcmp(dst0, dst1, sz * PIXEL_STRIDE) ||

  221.                             memcmp(subcoef0, subcoef1, sz * sz * SIZEOF_COEF))

  222.                             fail();

  223.                         bench_new(dst1, subcoef1, sz * SIZEOF_PIXEL);

  224.                     }

  225.                 }

  226.             }

  227.         }

  228.     }

  229. }

  230. 

  231. static void check_idct_multiple(void)

  232. {

  233.     LOCAL_ALIGNED_16(uint8_t, dst_full,  [16 * 16 * 2]);

  234.     LOCAL_ALIGNED_16(int16_t, coef_full, [16 * 16 * 2]);

  235.     LOCAL_ALIGNED_16(uint8_t, dst0,  [16 * 16 * 2]);

  236.     LOCAL_ALIGNED_16(uint8_t, dst1,  [16 * 16 * 2]);

  237.     LOCAL_ALIGNED_16(int16_t, coef0, [16 * 16 * 2]);

  238.     LOCAL_ALIGNED_16(int16_t, coef1, [16 * 16 * 2]);

  239.     LOCAL_ALIGNED_16(uint8_t, nnzc,  [15 * 8]);

  240.     H264DSPContext h;

  241.     int bit_depth, i, y, func;

  242.     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, const int *block_offset, int16_t *block, int stride, const uint8_t nnzc[15*8]);

  243. 

  244.     for (bit_depth = 8; bit_depth <= 10; bit_depth++) {

  245.         ff_h264dsp_init(&h, bit_depth, 1);

  246.         for (func = 0; func < 3; func++) {

  247.             void (*idct)(uint8_t *, const int *, int16_t *, int, const uint8_t[]) = NULL;

  248.             const char *name;

  249.             int sz = 4, intra = 0;

  250.             int block_offset[16] = { 0 };

  251.             switch (func) {

  252.             case 0:

  253.                 idct = h.h264_idct_add16;

  254.                 name = "h264_idct_add16";

  255.                 break;

  256.             case 1:

  257.                 idct = h.h264_idct_add16intra;

  258.                 name = "h264_idct_add16intra";

  259.                 intra = 1;

  260.                 break;

  261.             case 2:

  262.                 idct = h.h264_idct8_add4;

  263.                 name = "h264_idct8_add4";

  264.                 sz = 8;

  265.                 break;

  266.             }

  267.             memset(nnzc, 0, 15 * 8);

  268.             memset(coef_full, 0, 16 * 16 * SIZEOF_COEF);

  269.             for (i = 0; i < 16 * 16; i += sz * sz) {

  270.                 uint8_t src[8 * 8 * 2];

  271.                 uint8_t dst[8 * 8 * 2];

  272.                 int16_t coef[8 * 8 * 2];

  273.                 int index = i / sz;

  274.                 int block_y = (index / 16) * sz;

  275.                 int block_x = index % 16;

  276.                 int offset = (block_y * 16 + block_x) * SIZEOF_PIXEL;

  277.                 int nnz = rnd() % 3;

  278. 

  279.                 randomize_buffers();

  280.                 if (sz == 4)

  281.                     dct4x4(coef, bit_depth);

  282.                 else

  283.                     dct8x8(coef, bit_depth);

  284. 

  285.                 for (y = 0; y < sz; y++)

  286.                     memcpy(&dst_full[offset + y * 16 * SIZEOF_PIXEL],

  287.                            &dst[PIXEL_STRIDE * y], sz * SIZEOF_PIXEL);

  288. 

  289.                 if (nnz > 1)

  290.                     nnz = sz * sz;

  291.                 memcpy(&coef_full[i * SIZEOF_COEF/sizeof(coef[0])],

  292.                        coef, nnz * SIZEOF_COEF);

  293. 

  294.                 if (intra && nnz == 1)

  295.                     nnz = 0;

  296. 

  297.                 nnzc[scan8[i / 16]] = nnz;

  298.                 block_offset[i / 16] = offset;

  299.             }

  300. 

  301.             if (check_func(idct, "%s_%dbpp", name, bit_depth)) {

  302.                 memcpy(coef0, coef_full, 16 * 16 * SIZEOF_COEF);

  303.                 memcpy(coef1, coef_full, 16 * 16 * SIZEOF_COEF);

  304.                 memcpy(dst0, dst_full, 16 * 16 * SIZEOF_PIXEL);

  305.                 memcpy(dst1, dst_full, 16 * 16 * SIZEOF_PIXEL);

  306.                 call_ref(dst0, block_offset, coef0, 16 * SIZEOF_PIXEL, nnzc);

  307.                 call_new(dst1, block_offset, coef1, 16 * SIZEOF_PIXEL, nnzc);

  308.                 if (memcmp(dst0, dst1, 16 * 16 * SIZEOF_PIXEL) ||

  309.                     memcmp(coef0, coef1, 16 * 16 * SIZEOF_COEF))

  310.                     fail();

  311.                 bench_new(dst1, block_offset, coef1, 16 * SIZEOF_PIXEL, nnzc);

  312.             }

  313.         }

  314.     }

  315. }

  316. 

  317. 

  318. static void check_loop_filter(void)

  319. {

  320.     LOCAL_ALIGNED_16(uint8_t, dst, [32 * 16 * 2]);

  321.     LOCAL_ALIGNED_16(uint8_t, dst0, [32 * 16 * 2]);

  322.     LOCAL_ALIGNED_16(uint8_t, dst1, [32 * 16 * 2]);

  323.     H264DSPContext h;

  324.     int bit_depth;

  325.     int alphas[36], betas[36];

  326.     int8_t tc0[36][4];

  327. 

  328.     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *pix, ptrdiff_t stride,

  329.                       int alpha, int beta, int8_t *tc0);

  330. 

  331.     for (bit_depth = 8; bit_depth <= 10; bit_depth++) {

  332.         int i, j, a, c;

  333.         uint32_t mask = pixel_mask_lf[bit_depth - 8];

  334.         ff_h264dsp_init(&h, bit_depth, 1);

  335.         for (i = 35, a = 255, c = 250; i >= 0; i--) {

  336.             alphas[i] = a << (bit_depth - 8);

  337.             betas[i]  = (i + 1) / 2 << (bit_depth - 8);

  338.             tc0[i][0] = tc0[i][3] = (c + 6) / 10;

  339.             tc0[i][1] = (c + 7) / 15;

  340.             tc0[i][2] = (c + 9) / 20;

  341.             a = a*9/10;

  342.             c = c*9/10;

  343.         }

  344. 

  345. #define CHECK_LOOP_FILTER(name, align, idc)                             \

  346.         do {                                                            \

  347.             if (check_func(h.name, #name #idc "_%dbpp", bit_depth)) {   \

  348.                 for (j = 0; j < 36; j++) {                              \

  349.                     intptr_t off = 8 * 32 + (j & 15) * 4 * !align;      \

  350.                     for (i = 0; i < 1024; i+=4) {                       \

  351.                         AV_WN32A(dst + i, rnd() & mask);                \

  352.                     }                                                   \

  353.                     memcpy(dst0, dst, 32 * 16 * 2);                     \

  354.                     memcpy(dst1, dst, 32 * 16 * 2);                     \

  355.                                                                         \

  356.                     call_ref(dst0 + off, 32, alphas[j], betas[j], tc0[j]); \

  357.                     call_new(dst1 + off, 32, alphas[j], betas[j], tc0[j]); \

  358.                     if (memcmp(dst0, dst1, 32 * 16 * SIZEOF_PIXEL)) {   \

  359.                         fprintf(stderr, #name #idc ": j:%d, alpha:%d beta:%d " \

  360.                                 "tc0:{%d,%d,%d,%d}\n", j, alphas[j], betas[j], \

  361.                                 tc0[j][0], tc0[j][1], tc0[j][2], tc0[j][3]); \

  362.                         fail();                                         \

  363.                     }                                                   \

  364.                     bench_new(dst1, 32, alphas[j], betas[j], tc0[j]);   \

  365.                 }                                                       \

  366.             }                                                           \

  367.         } while (0)

  368. 

  369.         CHECK_LOOP_FILTER(h264_v_loop_filter_luma, 1,);

  370.         CHECK_LOOP_FILTER(h264_h_loop_filter_luma, 0,);

  371.         CHECK_LOOP_FILTER(h264_h_loop_filter_luma_mbaff, 0,);

  372.         CHECK_LOOP_FILTER(h264_v_loop_filter_chroma, 1,);

  373.         CHECK_LOOP_FILTER(h264_h_loop_filter_chroma, 0,);

  374.         CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_mbaff, 0,);

  375. 

  376.         ff_h264dsp_init(&h, bit_depth, 2);

  377.         CHECK_LOOP_FILTER(h264_h_loop_filter_chroma, 0, 422);

  378.         CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_mbaff, 0, 422);

  379. #undef CHECK_LOOP_FILTER

  380.     }

  381. }

  382. 

  383. static void check_loop_filter_intra(void)

  384. {

  385.     LOCAL_ALIGNED_16(uint8_t, dst, [32 * 16 * 2]);

  386.     LOCAL_ALIGNED_16(uint8_t, dst0, [32 * 16 * 2]);

  387.     LOCAL_ALIGNED_16(uint8_t, dst1, [32 * 16 * 2]);

  388.     H264DSPContext h;

  389.     int bit_depth;

  390.     int alphas[36], betas[36];

  391. 

  392.     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *pix, ptrdiff_t stride,

  393.                       int alpha, int beta);

  394. 

  395.     for (bit_depth = 8; bit_depth <= 10; bit_depth++) {

  396.         int i, j, a;

  397.         uint32_t mask = pixel_mask_lf[bit_depth - 8];

  398.         ff_h264dsp_init(&h, bit_depth, 1);

  399.         for (i = 35, a = 255; i >= 0; i--) {

  400.             alphas[i] = a << (bit_depth - 8);

  401.             betas[i]  = (i + 1) / 2 << (bit_depth - 8);

  402.             a = a*9/10;

  403.         }

  404. 

  405. #define CHECK_LOOP_FILTER(name, align, idc)                             \

  406.         do {                                                            \

  407.             if (check_func(h.name, #name #idc "_%dbpp", bit_depth)) {   \

  408.                 for (j = 0; j < 36; j++) {                              \

  409.                     intptr_t off = 8 * 32 + (j & 15) * 4 * !align;      \

  410.                     for (i = 0; i < 1024; i+=4) {                       \

  411.                         AV_WN32A(dst + i, rnd() & mask);                \

  412.                     }                                                   \

  413.                     memcpy(dst0, dst, 32 * 16 * 2);                     \

  414.                     memcpy(dst1, dst, 32 * 16 * 2);                     \

  415.                                                                         \

  416.                     call_ref(dst0 + off, 32, alphas[j], betas[j]);      \

  417.                     call_new(dst1 + off, 32, alphas[j], betas[j]);      \

  418.                     if (memcmp(dst0, dst1, 32 * 16 * SIZEOF_PIXEL)) {   \

  419.                         fprintf(stderr, #name #idc ": j:%d, alpha:%d beta:%d\n", \

  420.                                 j, alphas[j], betas[j]);                \

  421.                         fail();                                         \

  422.                     }                                                   \

  423.                     bench_new(dst1, 32, alphas[j], betas[j]);           \

  424.                 }                                                       \

  425.             }                                                           \

  426.         } while (0)

  427. 

  428.         CHECK_LOOP_FILTER(h264_v_loop_filter_luma_intra, 1,);

  429.         CHECK_LOOP_FILTER(h264_h_loop_filter_luma_intra, 0,);

  430.         CHECK_LOOP_FILTER(h264_h_loop_filter_luma_mbaff_intra, 0,);

  431.         CHECK_LOOP_FILTER(h264_v_loop_filter_chroma_intra, 1,);

  432.         CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_intra, 0,);

  433.         CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_mbaff_intra, 0,);

  434. 

  435.         ff_h264dsp_init(&h, bit_depth, 2);

  436.         CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_intra, 0, 422);

  437.         CHECK_LOOP_FILTER(h264_h_loop_filter_chroma_mbaff_intra, 0, 422);

  438. #undef CHECK_LOOP_FILTER

  439.     }

  440. }

  441. 

  442. void checkasm_check_h264dsp(void)

  443. {

  444.     check_idct();

  445.     check_idct_multiple();

  446.     report("idct");

  447. 

  448.     check_loop_filter();

  449.     report("loop_filter");

  450. 

  451.     check_loop_filter_intra();

  452.     report("loop_filter_intra");

  453. }