1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
#pragma once
#include <vector>
#include <kms++/framebuffer.h>
#include <kms++util/color16.h>
#include "conv-common.h"
namespace kms
{
/*
* Grayscale formats
*/
using Y8_Layout = FormatLayout<PlaneLayout<uint8_t,
ComponentLayout<ComponentType::Y, 8, 0>>>;
using Y10_Layout = FormatLayout<PlaneLayout<uint16_t,
ComponentLayout<ComponentType::Y, 10, 0>,
ComponentLayout<ComponentType::X, 4, 10>>>;
using Y12_Layout = FormatLayout<PlaneLayout<uint16_t,
ComponentLayout<ComponentType::Y, 12, 0>,
ComponentLayout<ComponentType::X, 4, 12>>>;
using Y16_Layout = FormatLayout<PlaneLayout<uint16_t,
ComponentLayout<ComponentType::Y, 16, 0>>>;
using Y10_P32_Layout = FormatLayout<PlaneLayout<uint32_t,
ComponentLayout<ComponentType::Y, 10, 0>, // Y0
ComponentLayout<ComponentType::Y, 10, 10>, // Y1
ComponentLayout<ComponentType::Y, 10, 20>, // Y2
ComponentLayout<ComponentType::X, 2, 30>
>>;
template<typename Layout> class Y_Writer
{
using Plane = Layout::template plane<0>;
using TStorage = Plane::storage_type;
static_assert(Layout::num_planes == 1);
static_assert(Plane::template component_count<ComponentType::Y>() >= 1);
static constexpr bool has_padding =
Plane::template component_count<ComponentType::X>();
static constexpr size_t y_idx = Plane::template find_pos<ComponentType::Y>();
static constexpr size_t x_idx =
has_padding ? Plane::template find_pos<ComponentType::X>() : 0;
static constexpr size_t y_shift = 16 - Plane::template component_size<y_idx>;
static constexpr size_t pixels_in_group =
Plane::template component_count<ComponentType::Y>();
static constexpr bool is_packed_format = pixels_in_group > 1;
public:
// Pack and write num_pixels pixels from src_line to dst_line
static void pack_line(HasIndexOperatorReturning<TStorage> auto&& dst_line,
HasIndexOperatorReturning<YUV16> auto&& src_line,
size_t num_pixels)
{
if constexpr (!is_packed_format) {
// Simple case: one Y component per storage unit
for (size_t x = 0; x < num_pixels; x++) {
const YUV16& pix = src_line[x];
std::array<component_storage_type, Plane::num_components>
components;
if constexpr (has_padding)
components[x_idx] = 0;
components[y_idx] = pix.y >> y_shift;
dst_line[x] = Plane::pack(components);
}
} else {
write_y_samples(dst_line, src_line, num_pixels);
}
}
static void write_pattern(IFramebuffer& fb, size_t start_y, size_t end_y,
auto&& generate_line)
{
std::vector<YUV16> linebuf(fb.width());
// View to the plane
auto view = make_strided_fb_view<TStorage>(fb.map(0), fb.height(),
fb.width() / pixels_in_group,
fb.stride(0));
for (size_t y_src = start_y; y_src <= end_y; y_src++) {
generate_line(y_src, linebuf);
auto dst = md::submdspan(view, y_src, md::full_extent);
pack_line(dst, linebuf, fb.width());
}
}
private:
template<typename YBuf>
static void write_y_samples(YBuf&& y_view, auto&& linebuf, size_t num_pixels)
{
for (size_t x_src = 0; x_src < num_pixels; x_src += pixels_in_group) {
auto x_dst = x_src / pixels_in_group;
write_y_group(y_view, linebuf, x_src, x_dst,
std::make_index_sequence<pixels_in_group>{});
}
}
template<typename YBuf, size_t... I>
static void write_y_group(YBuf&& y_view, auto&& linebuf, size_t x_src,
size_t x_dst, std::index_sequence<I...>)
{
std::array<component_storage_type, Plane::num_components> y_values{
static_cast<component_storage_type>(
(linebuf[x_src + I].y >>
(16 - Plane::template component_size<I>)))...
};
y_view[x_dst] = Plane::pack(y_values);
}
};
} // namespace kms
|
