LCOV - code coverage report
Current view: top level - tests/checkasm - hevc_sao.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 51 53 96.2 %
Date: 2018-05-20 11:54:08 Functions: 3 3 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2018 Yingming Fan <yingmingfan@gmail.com>
       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             : 
      23             : #include "libavutil/intreadwrite.h"
      24             : 
      25             : #include "libavcodec/avcodec.h"
      26             : 
      27             : #include "libavcodec/hevcdsp.h"
      28             : 
      29             : #include "checkasm.h"
      30             : 
      31             : static const uint32_t pixel_mask[3] = { 0xffffffff, 0x03ff03ff, 0x0fff0fff };
      32             : static const uint32_t sao_size[5] = {8, 16, 32, 48, 64};
      33             : 
      34             : #define SIZEOF_PIXEL ((bit_depth + 7) / 8)
      35             : #define PIXEL_STRIDE (2*MAX_PB_SIZE + AV_INPUT_BUFFER_PADDING_SIZE) //same with sao_edge src_stride
      36             : #define BUF_SIZE (PIXEL_STRIDE * (64+2) * 2) //+2 for top and bottom row, *2 for high bit depth
      37             : #define OFFSET_THRESH (1 << (bit_depth - 5))
      38             : #define OFFSET_LENGTH 5
      39             : 
      40             : #define randomize_buffers(buf0, buf1, size)                 \
      41             :     do {                                                    \
      42             :         uint32_t mask = pixel_mask[(bit_depth - 8) >> 1];   \
      43             :         int k;                                              \
      44             :         for (k = 0; k < size; k += 4) {                     \
      45             :             uint32_t r = rnd() & mask;                      \
      46             :             AV_WN32A(buf0 + k, r);                          \
      47             :             AV_WN32A(buf1 + k, r);                          \
      48             :         }                                                   \
      49             :     } while (0)
      50             : 
      51             : #define randomize_buffers2(buf, size)                       \
      52             :     do {                                                    \
      53             :         uint32_t max_offset = OFFSET_THRESH;                \
      54             :         int k;                                              \
      55             :         if (bit_depth == 8) {                               \
      56             :             for (k = 0; k < size; k++) {                    \
      57             :                 uint8_t r = rnd() % max_offset;             \
      58             :                 buf[k] = r;                                 \
      59             :             }                                               \
      60             :         } else {                                            \
      61             :             for (k = 0; k < size; k++) {                    \
      62             :                 uint16_t r = rnd() % max_offset;            \
      63             :                 buf[k] = r;                                 \
      64             :             }                                               \
      65             :         }                                                   \
      66             :     } while (0)
      67             : 
      68          39 : static void check_sao_band(HEVCDSPContext h, int bit_depth)
      69             : {
      70             :     int i;
      71          39 :     LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
      72          39 :     LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
      73          39 :     LOCAL_ALIGNED_32(uint8_t, src0, [BUF_SIZE]);
      74          39 :     LOCAL_ALIGNED_32(uint8_t, src1, [BUF_SIZE]);
      75             :     int16_t offset_val[OFFSET_LENGTH];
      76          39 :     int left_class = rnd()%32;
      77             : 
      78         234 :     for (i = 0; i <= 4; i++) {
      79         195 :         int block_size = sao_size[i];
      80         195 :         ptrdiff_t stride = PIXEL_STRIDE*SIZEOF_PIXEL;
      81         195 :         declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, uint8_t *src, ptrdiff_t dst_stride, ptrdiff_t src_stride,
      82             :                           int16_t *sao_offset_val, int sao_left_class, int width, int height);
      83             : 
      84         195 :         randomize_buffers(src0, src1, BUF_SIZE);
      85         195 :         randomize_buffers2(offset_val, OFFSET_LENGTH);
      86         195 :         memset(dst0, 0, BUF_SIZE);
      87         195 :         memset(dst1, 0, BUF_SIZE);
      88             : 
      89         195 :         if (check_func(h.sao_band_filter[i], "hevc_sao_band_%dx%d_%d", block_size, block_size, bit_depth)) {
      90          60 :             call_ref(dst0, src0, stride, stride, offset_val, left_class, block_size, block_size);
      91          60 :             call_new(dst1, src1, stride, stride, offset_val, left_class, block_size, block_size);
      92          60 :             if (memcmp(dst0, dst1, BUF_SIZE))
      93           0 :                 fail();
      94          60 :             bench_new(dst1, src1, stride, stride, offset_val, left_class, block_size, block_size);
      95             :         }
      96             :     }
      97          39 : }
      98             : 
      99          39 : static void check_sao_edge(HEVCDSPContext h, int bit_depth)
     100             : {
     101             :     int i;
     102          39 :     LOCAL_ALIGNED_32(uint8_t, dst0, [BUF_SIZE]);
     103          39 :     LOCAL_ALIGNED_32(uint8_t, dst1, [BUF_SIZE]);
     104          39 :     LOCAL_ALIGNED_32(uint8_t, src0, [BUF_SIZE]);
     105          39 :     LOCAL_ALIGNED_32(uint8_t, src1, [BUF_SIZE]);
     106             :     int16_t offset_val[OFFSET_LENGTH];
     107          39 :     int eo = rnd()%4;
     108             : 
     109         234 :     for (i = 0; i <= 4; i++) {
     110         195 :         int block_size = sao_size[i];
     111         195 :         ptrdiff_t stride = PIXEL_STRIDE*SIZEOF_PIXEL;
     112         195 :         int offset = (AV_INPUT_BUFFER_PADDING_SIZE + PIXEL_STRIDE)*SIZEOF_PIXEL;
     113         195 :         declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, uint8_t *src, ptrdiff_t stride_dst,
     114             :                           int16_t *sao_offset_val, int eo, int width, int height);
     115             : 
     116         195 :         randomize_buffers(src0, src1, BUF_SIZE);
     117         195 :         randomize_buffers2(offset_val, OFFSET_LENGTH);
     118         195 :         memset(dst0, 0, BUF_SIZE);
     119         195 :         memset(dst1, 0, BUF_SIZE);
     120             : 
     121         195 :         if (check_func(h.sao_edge_filter[i], "hevc_sao_edge_%dx%d_%d", block_size, block_size, bit_depth)) {
     122          43 :             call_ref(dst0, src0 + offset, stride, offset_val, eo, block_size, block_size);
     123          43 :             call_new(dst1, src1 + offset, stride, offset_val, eo, block_size, block_size);
     124          43 :             if (memcmp(dst0, dst1, BUF_SIZE))
     125           0 :                 fail();
     126          43 :             bench_new(dst1, src1 + offset, stride, offset_val, eo, block_size, block_size);
     127             :         }
     128             :     }
     129          39 : }
     130             : 
     131          13 : void checkasm_check_hevc_sao(void)
     132             : {
     133             :     int bit_depth;
     134             : 
     135          52 :     for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
     136             :         HEVCDSPContext h;
     137             : 
     138          39 :         ff_hevc_dsp_init(&h, bit_depth);
     139          39 :         check_sao_band(h, bit_depth);
     140             :     }
     141          13 :     report("sao_band");
     142             : 
     143          52 :     for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
     144             :         HEVCDSPContext h;
     145             : 
     146          39 :         ff_hevc_dsp_init(&h, bit_depth);
     147          39 :         check_sao_edge(h, bit_depth);
     148             :     }
     149          13 :     report("sao_edge");
     150          13 : }

Generated by: LCOV version 1.13