LCOV - code coverage report
Current view: top level - src/tests - utils.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 60 60 100.0 %
Date: 2025-03-29 09:04:10 Functions: 1 1 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 31 60 51.7 %

           Branch data     Line data    Source code
       1                 :            : #include "utils.h"
       2                 :            : #include "gpu.h"
       3                 :            : 
       4                 :            : #include <libplacebo/utils/upload.h>
       5                 :            : 
       6                 :          1 : int main()
       7                 :            : {
       8                 :          1 :     struct pl_bit_encoding bits = {0};
       9                 :          1 :     struct pl_plane_data data = {0};
      10                 :            : 
      11                 :            :     static const struct pl_bit_encoding bits0 = {0};
      12                 :            :     static const struct pl_bit_encoding bits8 = {
      13                 :            :         .sample_depth = 8,
      14                 :            :         .color_depth = 8,
      15                 :            :     };
      16                 :            : 
      17                 :            :     static const struct pl_bit_encoding bits16 = {
      18                 :            :         .sample_depth = 16,
      19                 :            :         .color_depth = 16,
      20                 :            :     };
      21                 :            : 
      22                 :            :     static const struct pl_bit_encoding bits10_16 = {
      23                 :            :         .sample_depth = 16,
      24                 :            :         .color_depth = 10,
      25                 :            :     };
      26                 :            : 
      27                 :            :     static const struct pl_bit_encoding bits10_16_6 = {
      28                 :            :         .sample_depth = 16,
      29                 :            :         .color_depth = 10,
      30                 :            :         .bit_shift = 6,
      31                 :            :     };
      32                 :            : 
      33                 :            : #define TEST_ALIGN(ref, ref_align, ref_bits, ...)                       \
      34                 :            :     do {                                                                \
      35                 :            :         pl_plane_data_from_mask(&data, (uint64_t[4]){ __VA_ARGS__ });   \
      36                 :            :         REQUIRE_MEMEQ(&data, &ref, sizeof(ref));                        \
      37                 :            :         pl_plane_data_align(&data, &bits);                              \
      38                 :            :         REQUIRE_MEMEQ(&data, &ref_align, sizeof(ref_align));            \
      39                 :            :         REQUIRE_MEMEQ(&bits, &ref_bits, sizeof(bits));                  \
      40                 :            :     } while (0)
      41                 :            : 
      42                 :            : #define TEST(ref, bits, ...) TEST_ALIGN(ref, ref, bits, __VA_ARGS__)
      43                 :            : 
      44                 :            :     static const struct pl_plane_data rgb8 = {
      45                 :            :         .component_size = {8, 8, 8},
      46                 :            :         .component_map  = {0, 1, 2},
      47                 :            :     };
      48                 :            : 
      49                 :          1 :     TEST(rgb8, bits8, 0xFF, 0xFF00, 0xFF0000);
      50                 :            : 
      51                 :            :     static const struct pl_plane_data bgra8 = {
      52                 :            :         .component_size = {8, 8, 8, 8},
      53                 :            :         .component_map  = {2, 1, 0, 3},
      54                 :            :     };
      55                 :            : 
      56                 :          1 :     TEST(bgra8, bits8, 0xFF0000, 0xFF00, 0xFF, 0xFF000000);
      57                 :            : 
      58                 :            :     static const struct pl_plane_data gr16 = {
      59                 :            :         .component_size = {16, 16},
      60                 :            :         .component_map  = {1, 0},
      61                 :            :     };
      62                 :            : 
      63                 :          1 :     TEST(gr16, bits16, 0xFFFF0000, 0xFFFF);
      64                 :            : 
      65                 :            :     static const struct pl_plane_data r10x6g10 = {
      66                 :            :         .component_size = {10, 10},
      67                 :            :         .component_map  = {1, 0}, // LSB -> MSB ordering
      68                 :            :         .component_pad  = {0, 6},
      69                 :            :     };
      70                 :            : 
      71                 :          1 :     TEST_ALIGN(r10x6g10, gr16, bits10_16, 0x03FF0000, 0x03FF);
      72                 :            : 
      73                 :            :     static const struct pl_plane_data rgb565 = {
      74                 :            :         .component_size = {5, 6, 5},
      75                 :            :         .component_map  = {2, 1, 0}, // LSB -> MSB ordering
      76                 :            :     };
      77                 :            : 
      78                 :          1 :     TEST(rgb565, bits0, 0xF800, 0x07E0, 0x001F);
      79                 :            : 
      80                 :            :     static const struct pl_plane_data rgba16 = {
      81                 :            :         .component_size = {16, 16, 16, 16},
      82                 :            :         .component_map  = {0, 1, 2, 3},
      83                 :            :     };
      84                 :            : 
      85                 :          1 :     TEST(rgba16, bits16, 0xFFFFllu, 0xFFFF0000llu, 0xFFFF00000000llu, 0xFFFF000000000000llu);
      86                 :            : 
      87                 :            :     static const struct pl_plane_data p010 = {
      88                 :            :         .component_size = {10, 10, 10},
      89                 :            :         .component_map  = {0, 1, 2},
      90                 :            :         .component_pad  = {6, 6, 6},
      91                 :            :     };
      92                 :            : 
      93                 :            :     static const struct pl_plane_data rgb16 = {
      94                 :            :         .component_size = {16, 16, 16},
      95                 :            :         .component_map  = {0, 1, 2},
      96                 :            :     };
      97                 :            : 
      98                 :          1 :     TEST_ALIGN(p010, rgb16, bits10_16_6, 0xFFC0llu, 0xFFC00000llu, 0xFFC000000000llu);
      99                 :            : 
     100                 :            :     // Test GLSL structure packing
     101                 :          1 :     struct pl_var vec1 = pl_var_float(""),
     102                 :          1 :                   vec2 = pl_var_vec2(""),
     103                 :          1 :                   vec3 = pl_var_vec3(""),
     104                 :          1 :                   mat2 = pl_var_mat2(""),
     105                 :          1 :                   mat3 = pl_var_mat3("");
     106                 :            : 
     107                 :            :     struct pl_var_layout layout;
     108                 :          1 :     layout = pl_std140_layout(0, &vec2);
     109         [ -  + ]:          1 :     REQUIRE_CMP(layout.offset, ==, 0 * sizeof(float), "zu");
     110         [ -  + ]:          1 :     REQUIRE_CMP(layout.stride, ==, 2 * sizeof(float), "zu");
     111         [ -  + ]:          1 :     REQUIRE_CMP(layout.size, ==, 2 * sizeof(float), "zu");
     112                 :            : 
     113                 :          1 :     layout = pl_std140_layout(3 * sizeof(float), &vec3);
     114         [ -  + ]:          1 :     REQUIRE_CMP(layout.offset, ==, 4 * sizeof(float), "zu");
     115         [ -  + ]:          1 :     REQUIRE_CMP(layout.stride, ==, 3 * sizeof(float), "zu");
     116         [ -  + ]:          1 :     REQUIRE_CMP(layout.size, ==, 3 * sizeof(float), "zu");
     117                 :            : 
     118                 :          1 :     layout = pl_std140_layout(2 * sizeof(float), &mat3);
     119         [ -  + ]:          1 :     REQUIRE_CMP(layout.offset, ==, 4 * sizeof(float), "zu");
     120         [ -  + ]:          1 :     REQUIRE_CMP(layout.stride, ==, 4 * sizeof(float), "zu");
     121         [ -  + ]:          1 :     REQUIRE_CMP(layout.size, ==, 3 * 4 * sizeof(float), "zu");
     122                 :            : 
     123                 :          1 :     layout = pl_std430_layout(2 * sizeof(float), &mat3);
     124         [ -  + ]:          1 :     REQUIRE_CMP(layout.offset, ==, 4 * sizeof(float), "zu");
     125         [ -  + ]:          1 :     REQUIRE_CMP(layout.stride, ==, 4 * sizeof(float), "zu");
     126         [ -  + ]:          1 :     REQUIRE_CMP(layout.size, ==, 4 * 3 * sizeof(float), "zu");
     127                 :            : 
     128                 :          1 :     layout = pl_std140_layout(3 * sizeof(float), &vec1);
     129         [ -  + ]:          1 :     REQUIRE_CMP(layout.offset, ==, 3 * sizeof(float), "zu");
     130         [ -  + ]:          1 :     REQUIRE_CMP(layout.stride, ==, sizeof(float), "zu");
     131         [ -  + ]:          1 :     REQUIRE_CMP(layout.size, ==, sizeof(float), "zu");
     132                 :            : 
     133                 :          1 :     struct pl_var vec2a = vec2;
     134                 :          1 :     vec2a.dim_a = 50;
     135                 :            : 
     136                 :          1 :     layout = pl_std140_layout(sizeof(float), &vec2a);
     137         [ -  + ]:          1 :     REQUIRE_CMP(layout.offset, ==, 4 * sizeof(float), "zu");
     138         [ -  + ]:          1 :     REQUIRE_CMP(layout.stride, ==, 4 * sizeof(float), "zu");
     139         [ -  + ]:          1 :     REQUIRE_CMP(layout.size, ==, 50 * 4 * sizeof(float), "zu");
     140                 :            : 
     141                 :          1 :     layout = pl_std430_layout(sizeof(float), &vec2a);
     142         [ -  + ]:          1 :     REQUIRE_CMP(layout.offset, ==, 2 * sizeof(float), "zu");
     143         [ -  + ]:          1 :     REQUIRE_CMP(layout.stride, ==, 2 * sizeof(float), "zu");
     144         [ -  + ]:          1 :     REQUIRE_CMP(layout.size, ==, 50 * 2 * sizeof(float), "zu");
     145                 :            : 
     146                 :          1 :     struct pl_var mat2a = mat2;
     147                 :          1 :     mat2a.dim_a = 20;
     148                 :            : 
     149                 :          1 :     layout = pl_std140_layout(5 * sizeof(float), &mat2a);
     150         [ -  + ]:          1 :     REQUIRE_CMP(layout.offset, ==, 8 * sizeof(float), "zu");
     151         [ -  + ]:          1 :     REQUIRE_CMP(layout.stride, ==, 4 * sizeof(float), "zu");
     152         [ -  + ]:          1 :     REQUIRE_CMP(layout.size, ==, 20 * 2 * 4 * sizeof(float), "zu");
     153                 :            : 
     154                 :          1 :     layout = pl_std430_layout(5 * sizeof(float), &mat2a);
     155         [ -  + ]:          1 :     REQUIRE_CMP(layout.offset, ==, 6 * sizeof(float), "zu");
     156         [ -  + ]:          1 :     REQUIRE_CMP(layout.stride, ==, 2 * sizeof(float), "zu");
     157         [ +  - ]:          1 :     REQUIRE_CMP(layout.size, ==, 20 * 2 * 2 * sizeof(float), "zu");
     158                 :            : 
     159         [ +  + ]:         21 :     for (const struct pl_named_var *nvar = pl_var_glsl_types; nvar->glsl_name; nvar++) {
     160                 :         20 :         struct pl_var var = nvar->var;
     161         [ -  + ]:         20 :         REQUIRE_CMP(nvar->glsl_name, ==, pl_var_glsl_type_name(var), "s");
     162                 :         20 :         var.dim_a = 100;
     163         [ -  + ]:         20 :         REQUIRE_CMP(nvar->glsl_name, ==, pl_var_glsl_type_name(var), "s");
     164                 :            :     }
     165                 :            : }

Generated by: LCOV version 1.16