塔塔粉是什么粉 - 什么东西含铅量高新闻网

塔塔粉是什么粉

Directory:	../../../ffmpeg/
File:	src/tests/checkasm/hevc_sao.c
Date:	2025-08-05 11:35:17

	Exec	Total	Coverage
Lines:	56	56	100.0%
Functions:	3	3	100.0%
Branches:	42	56	75.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2018 Yingming Fan <yingmingfan@gmail.com>
    
       *
    
       * This file is part of FFmpeg.
    
       *
    
       * FFmpeg is free software; you can redistribute it and/or modify
    
       * it under the terms of the GNU General Public License as published by
    
       * the Free Software Foundation; either version 2 of the License, or
    
       * (at your option) any later version.
    
       *
    
       * FFmpeg is distributed in the hope that it will be useful,
    
       * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
       * GNU General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU General Public License along
    
       * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
    
       * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
    
       */
    
      #include <string.h>
    
      #include "libavutil/intreadwrite.h"
    
      #include "libavutil/mem_internal.h"
    
      #include "libavcodec/hevc/dsp.h"
    
      #include "checkasm.h"
    
      static const uint32_t pixel_mask[3] = { 0xffffffff, 0x03ff03ff, 0x0fff0fff };
    
      static const uint32_t sao_size[5] = {8, 16, 32, 48, 64};
    
      #define SIZEOF_PIXEL ((bit_depth + 7) / 8)
    
      #define PIXEL_STRIDE (2*MAX_PB_SIZE + AV_INPUT_BUFFER_PADDING_SIZE) //same with sao_edge src_stride
    
      #define BUF_SIZE (PIXEL_STRIDE * (64+2) * 2) //+2 for top and bottom row, *2 for high bit depth
    
      #define OFFSET_THRESH (1 << (bit_depth - 5))
    
      #define OFFSET_LENGTH 5
    
      #define randomize_buffers(buf0, buf1, size)                 \
    
          do {                                                    \
    
              uint32_t mask = pixel_mask[(bit_depth - 8) >> 1];   \
    
              int k;                                              \
    
              for (k = 0; k < size; k += 4) {                     \
    
                  uint32_t r = rnd() & mask;                      \
    
                  AV_WN32A(buf0 + k, r);                          \
    
                  AV_WN32A(buf1 + k, r);                          \
    
              }                                                   \
    
          } while (0)
    
      #define randomize_buffers2(buf, size)                       \
    
          do {                                                    \
    
              uint32_t max_offset = OFFSET_THRESH;                \
    
              int k;                                              \
    
              if (bit_depth == 8) {                               \
    
                  for (k = 0; k < size; k++) {                    \
    
                      uint8_t r = rnd() % max_offset;             \
    
                      buf[k] = r;                                 \
    
                  }                                               \
    
              } else {                                            \
    
                  for (k = 0; k < size; k++) {                    \
    
                      uint16_t r = rnd() % max_offset;            \
    
                      buf[k] = r;                                 \
    
                  }                                               \
    
              }                                                   \
    
          } while (0)
    
      39
      static void check_sao_band(HEVCDSPContext *h, int bit_depth)
    
      {
    
          int i;
    
      39
          PIXEL_RECT(dst0, MAX_PB_SIZE, MAX_PB_SIZE);
    
      39
          PIXEL_RECT(dst1, MAX_PB_SIZE, MAX_PB_SIZE);
    
      39
          LOCAL_ALIGNED_32(uint8_t, src0, [BUF_SIZE]);
    
      39
          LOCAL_ALIGNED_32(uint8_t, src1, [BUF_SIZE]);
    
          int16_t offset_val[OFFSET_LENGTH];
    
      39
          int left_class = rnd()%32;
    
      39
          const int walign = 16;
    
        2/2✓ Branch 0 taken 195 times.
✓ Branch 1 taken 39 times.

      234
          for (i = 0; i <= 4; i++) {
    
      195
              int block_size = sao_size[i];
    
        2/2✓ Branch 0 taken 156 times.
✓ Branch 1 taken 39 times.

      195
              int prev_size = i > 0 ? sao_size[i - 1] : 0;
    
      195
              ptrdiff_t stride = PIXEL_STRIDE*SIZEOF_PIXEL;
    
      195
              declare_func(void, uint8_t *dst, const uint8_t *src, ptrdiff_t dst_stride, ptrdiff_t src_stride,
    
                           const int16_t *sao_offset_val, int sao_left_class, int width, int height);
    
        2/2✓ Branch 3 taken 60 times.
✓ Branch 4 taken 135 times.

      195
              if (check_func(h->sao_band_filter[i], "hevc_sao_band_%d_%d", block_size, bit_depth)) {
    
        2/2✓ Branch 0 taken 192 times.
✓ Branch 1 taken 60 times.

      252
                  for (int w = prev_size + 4; w <= block_size; w += 4) {
    
        2/2✓ Branch 1 taken 1216512 times.
✓ Branch 2 taken 192 times.

      1216704
                      randomize_buffers(src0, src1, BUF_SIZE);
    
        6/6✓ Branch 0 taken 64 times.
✓ Branch 1 taken 128 times.
✓ Branch 3 taken 320 times.
✓ Branch 4 taken 64 times.
✓ Branch 6 taken 640 times.
✓ Branch 7 taken 128 times.

      1152
                      randomize_buffers2(offset_val, OFFSET_LENGTH);
    
      192
                      CLEAR_PIXEL_RECT(dst0);
    
      192
                      CLEAR_PIXEL_RECT(dst1);
    
      192
                      call_ref(dst0, src0, dst0_stride, stride, offset_val, left_class, w, block_size);
    
      192
                      call_new(dst1, src1, dst1_stride, stride, offset_val, left_class, w, block_size);
    
        2/2✓ Branch 0 taken 128 times.
✓ Branch 1 taken 64 times.

      192
                      checkasm_check_pixel_padded_align(dst0, dst0_stride, dst1, dst1_stride, w, block_size, "dst", walign, 1);
    
                  }
    
        1/8✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.

      60
                  bench_new(dst1, src1, dst1_stride, stride, offset_val, left_class, block_size, block_size);
    
              }
    
          }
    
      39
      }
    
      39
      static void check_sao_edge(HEVCDSPContext *h, int bit_depth)
    
      {
    
          int i;
    
      39
          PIXEL_RECT(dst0, MAX_PB_SIZE, MAX_PB_SIZE);
    
      39
          PIXEL_RECT(dst1, MAX_PB_SIZE, MAX_PB_SIZE);
    
      39
          LOCAL_ALIGNED_32(uint8_t, src0, [BUF_SIZE]);
    
      39
          LOCAL_ALIGNED_32(uint8_t, src1, [BUF_SIZE]);
    
          int16_t offset_val[OFFSET_LENGTH];
    
      39
          int eo = rnd()%4;
    
      39
          const int walign = 16;
    
        2/2✓ Branch 0 taken 195 times.
✓ Branch 1 taken 39 times.

      234
          for (i = 0; i <= 4; i++) {
    
      195
              int block_size = sao_size[i];
    
        2/2✓ Branch 0 taken 156 times.
✓ Branch 1 taken 39 times.

      195
              int prev_size = i > 0 ? sao_size[i - 1] : 0;
    
      195
              int offset = (AV_INPUT_BUFFER_PADDING_SIZE + PIXEL_STRIDE)*SIZEOF_PIXEL;
    
      195
              declare_func(void, uint8_t *dst, const uint8_t *src, ptrdiff_t stride_dst,
    
                           const int16_t *sao_offset_val, int eo, int width, int height);
    
        2/2✓ Branch 3 taken 43 times.
✓ Branch 4 taken 152 times.

      195
              if (check_func(h->sao_edge_filter[i], "hevc_sao_edge_%d_%d", block_size, bit_depth)) {
    
        2/2✓ Branch 0 taken 140 times.
✓ Branch 1 taken 43 times.

      183
                  for (int w = prev_size + 4; w <= block_size; w += 4) {
    
        2/2✓ Branch 1 taken 887040 times.
✓ Branch 2 taken 140 times.

      887180
                      randomize_buffers(src0, src1, BUF_SIZE);
    
        6/6✓ Branch 0 taken 44 times.
✓ Branch 1 taken 96 times.
✓ Branch 3 taken 220 times.
✓ Branch 4 taken 44 times.
✓ Branch 6 taken 480 times.
✓ Branch 7 taken 96 times.

      840
                      randomize_buffers2(offset_val, OFFSET_LENGTH);
    
      140
                      CLEAR_PIXEL_RECT(dst0);
    
      140
                      CLEAR_PIXEL_RECT(dst1);
    
      140
                      call_ref(dst0, src0 + offset, dst0_stride, offset_val, eo, w, block_size);
    
      140
                      call_new(dst1, src1 + offset, dst1_stride, offset_val, eo, w, block_size);
    
        2/2✓ Branch 0 taken 96 times.
✓ Branch 1 taken 44 times.

      140
                      checkasm_check_pixel_padded_align(dst0, dst0_stride, dst1, dst1_stride, w, block_size, "dst", walign, 1);
    
                  }
    
        1/8✗ Branch 1 not taken.
✓ Branch 2 taken 43 times.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.

      43
                  bench_new(dst1, src1 + offset, dst1_stride, offset_val, eo, block_size, block_size);
    
              }
    
          }
    
      39
      }
    
      13
      void checkasm_check_hevc_sao(void)
    
      {
    
          int bit_depth;
    
        2/2✓ Branch 0 taken 39 times.
✓ Branch 1 taken 13 times.

      52
          for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
    
              HEVCDSPContext h;
    
      39
              ff_hevc_dsp_init(&h, bit_depth);
    
      39
              check_sao_band(&h, bit_depth);
    
          }
    
      13
          report("sao_band");
    
        2/2✓ Branch 0 taken 39 times.
✓ Branch 1 taken 13 times.

      52
          for (bit_depth = 8; bit_depth <= 12; bit_depth += 2) {
    
              HEVCDSPContext h;
    
      39
              ff_hevc_dsp_init(&h, bit_depth);
    
      39
              check_sao_edge(&h, bit_depth);
    
          }
    
      13
          report("sao_edge");
    
      13
      }

人的反义词是什么	港澳通行证签注是什么意思	prc是什么	成都市市长是什么级别	1992属什么生肖
随诊复查是什么意思	嗜什么意思	1962年属什么生肖	鹅肝为什么那么贵	遗传代谢病是什么意思
出单是什么意思	南红是什么	倾注是什么意思	为什么下雨会打雷	农田种什么最赚钱
菲林是什么	胆囊炎吃什么药好得快	翻来覆去的覆什么意思	冥冥中是什么意思	脱肛吃什么药

picc是什么hcv8jop4ns2r.cn	公安局跟派出所有什么区别hcv7jop6ns6r.cn	什么叫姑息治疗hcv9jop5ns4r.cn	脸浮肿是什么病的前兆hcv8jop0ns8r.cn	中图分类号是什么hcv8jop3ns1r.cn
莲蓬是什么bjhyzcsm.com	为什么叫印度三哥bjhyzcsm.com	喝红茶对身体有什么好处hcv8jop1ns5r.cn	清醒的反义词是什么hcv8jop8ns7r.cn	骨龄是什么意思hcv9jop6ns4r.cn
后生可畏是什么意思gysmod.com	什么叫肺纤维化hcv8jop3ns7r.cn	家里停电了打什么电话wuhaiwuya.com	脖子上有肿块挂什么科hcv8jop0ns9r.cn	phe是什么氨基酸hcv8jop7ns8r.cn
故宫什么时候建的hcv9jop0ns3r.cn	清朝什么时候灭亡的hcv9jop6ns8r.cn	女方起诉离婚需要什么证件hcv9jop7ns9r.cn	樊胜美是什么电视剧hcv9jop2ns6r.cn	肌张力高对宝宝有什么影响hcv8jop9ns1r.cn

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

Function (Line)	Call count	Block coverage
check_sao_band (line 67)	called 39 times, returned 39 times	72.0%
check_sao_edge (line 102)	called 39 times, returned 39 times	72.0%
checkasm_check_hevc_sao (line 136)	called 13 times, returned 13 times	100.0%