1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3  * A V4L2 frontend for the FWHT codec
4  *
5  * Copyright 2018 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
6  */
7 
8 #include <linux/errno.h>
9 #include <linux/string.h>
10 #include <linux/videodev2.h>
11 #include "codec-v4l2-fwht.h"
12 
13 static const struct v4l2_fwht_pixfmt_info v4l2_fwht_pixfmts[] = {
14 	{ V4L2_PIX_FMT_YUV420,  1, 3, 2, 1, 1, 2, 2, 3, 3, FWHT_FL_PIXENC_YUV},
15 	{ V4L2_PIX_FMT_YVU420,  1, 3, 2, 1, 1, 2, 2, 3, 3, FWHT_FL_PIXENC_YUV},
16 	{ V4L2_PIX_FMT_YUV422P, 1, 2, 1, 1, 1, 2, 1, 3, 3, FWHT_FL_PIXENC_YUV},
17 	{ V4L2_PIX_FMT_NV12,    1, 3, 2, 1, 2, 2, 2, 3, 2, FWHT_FL_PIXENC_YUV},
18 	{ V4L2_PIX_FMT_NV21,    1, 3, 2, 1, 2, 2, 2, 3, 2, FWHT_FL_PIXENC_YUV},
19 	{ V4L2_PIX_FMT_NV16,    1, 2, 1, 1, 2, 2, 1, 3, 2, FWHT_FL_PIXENC_YUV},
20 	{ V4L2_PIX_FMT_NV61,    1, 2, 1, 1, 2, 2, 1, 3, 2, FWHT_FL_PIXENC_YUV},
21 	{ V4L2_PIX_FMT_NV24,    1, 3, 1, 1, 2, 1, 1, 3, 2, FWHT_FL_PIXENC_YUV},
22 	{ V4L2_PIX_FMT_NV42,    1, 3, 1, 1, 2, 1, 1, 3, 2, FWHT_FL_PIXENC_YUV},
23 	{ V4L2_PIX_FMT_YUYV,    2, 2, 1, 2, 4, 2, 1, 3, 1, FWHT_FL_PIXENC_YUV},
24 	{ V4L2_PIX_FMT_YVYU,    2, 2, 1, 2, 4, 2, 1, 3, 1, FWHT_FL_PIXENC_YUV},
25 	{ V4L2_PIX_FMT_UYVY,    2, 2, 1, 2, 4, 2, 1, 3, 1, FWHT_FL_PIXENC_YUV},
26 	{ V4L2_PIX_FMT_VYUY,    2, 2, 1, 2, 4, 2, 1, 3, 1, FWHT_FL_PIXENC_YUV},
27 	{ V4L2_PIX_FMT_BGR24,   3, 3, 1, 3, 3, 1, 1, 3, 1, FWHT_FL_PIXENC_RGB},
28 	{ V4L2_PIX_FMT_RGB24,   3, 3, 1, 3, 3, 1, 1, 3, 1, FWHT_FL_PIXENC_RGB},
29 	{ V4L2_PIX_FMT_HSV24,   3, 3, 1, 3, 3, 1, 1, 3, 1, FWHT_FL_PIXENC_HSV},
30 	{ V4L2_PIX_FMT_BGR32,   4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_RGB},
31 	{ V4L2_PIX_FMT_XBGR32,  4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_RGB},
32 	{ V4L2_PIX_FMT_ABGR32,  4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_RGB},
33 	{ V4L2_PIX_FMT_RGB32,   4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_RGB},
34 	{ V4L2_PIX_FMT_XRGB32,  4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_RGB},
35 	{ V4L2_PIX_FMT_ARGB32,  4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_RGB},
36 	{ V4L2_PIX_FMT_BGRX32,  4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_RGB},
37 	{ V4L2_PIX_FMT_BGRA32,  4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_RGB},
38 	{ V4L2_PIX_FMT_RGBX32,  4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_RGB},
39 	{ V4L2_PIX_FMT_RGBA32,  4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_RGB},
40 	{ V4L2_PIX_FMT_HSV32,   4, 4, 1, 4, 4, 1, 1, 4, 1, FWHT_FL_PIXENC_HSV},
41 	{ V4L2_PIX_FMT_GREY,    1, 1, 1, 1, 0, 1, 1, 1, 1, FWHT_FL_PIXENC_RGB},
42 };
43 
44 bool v4l2_fwht_validate_fmt(const struct v4l2_fwht_pixfmt_info *info,
45 			    u32 width_div, u32 height_div, u32 components_num,
46 			    u32 pixenc)
47 {
48 	if (info->width_div == width_div &&
49 	    info->height_div == height_div &&
50 	    (!pixenc || info->pixenc == pixenc) &&
51 	    info->components_num == components_num)
52 		return true;
53 	return false;
54 }
55 
56 const struct v4l2_fwht_pixfmt_info *v4l2_fwht_find_nth_fmt(u32 width_div,
57 							  u32 height_div,
58 							  u32 components_num,
59 							  u32 pixenc,
60 							  unsigned int start_idx)
61 {
62 	unsigned int i;
63 
64 	for (i = 0; i < ARRAY_SIZE(v4l2_fwht_pixfmts); i++) {
65 		bool is_valid = v4l2_fwht_validate_fmt(&v4l2_fwht_pixfmts[i],
66 						       width_div, height_div,
67 						       components_num, pixenc);
68 		if (is_valid) {
69 			if (start_idx == 0)
70 				return v4l2_fwht_pixfmts + i;
71 			start_idx--;
72 		}
73 	}
74 	return NULL;
75 }
76 
77 const struct v4l2_fwht_pixfmt_info *v4l2_fwht_find_pixfmt(u32 pixelformat)
78 {
79 	unsigned int i;
80 
81 	for (i = 0; i < ARRAY_SIZE(v4l2_fwht_pixfmts); i++)
82 		if (v4l2_fwht_pixfmts[i].id == pixelformat)
83 			return v4l2_fwht_pixfmts + i;
84 	return NULL;
85 }
86 
87 const struct v4l2_fwht_pixfmt_info *v4l2_fwht_get_pixfmt(u32 idx)
88 {
89 	if (idx >= ARRAY_SIZE(v4l2_fwht_pixfmts))
90 		return NULL;
91 	return v4l2_fwht_pixfmts + idx;
92 }
93 
94 static int prepare_raw_frame(struct fwht_raw_frame *rf,
95 			 const struct v4l2_fwht_pixfmt_info *info, u8 *buf,
96 			 unsigned int size)
97 {
98 	rf->luma = buf;
99 	rf->width_div = info->width_div;
100 	rf->height_div = info->height_div;
101 	rf->luma_alpha_step = info->luma_alpha_step;
102 	rf->chroma_step = info->chroma_step;
103 	rf->alpha = NULL;
104 	rf->components_num = info->components_num;
105 
106 	/*
107 	 * The buffer is NULL if it is the reference
108 	 * frame of an I-frame in the stateless decoder
109 	 */
110 	if (!buf) {
111 		rf->luma = NULL;
112 		rf->cb = NULL;
113 		rf->cr = NULL;
114 		rf->alpha = NULL;
115 		return 0;
116 	}
117 	switch (info->id) {
118 	case V4L2_PIX_FMT_GREY:
119 		rf->cb = NULL;
120 		rf->cr = NULL;
121 		break;
122 	case V4L2_PIX_FMT_YUV420:
123 		rf->cb = rf->luma + size;
124 		rf->cr = rf->cb + size / 4;
125 		break;
126 	case V4L2_PIX_FMT_YVU420:
127 		rf->cr = rf->luma + size;
128 		rf->cb = rf->cr + size / 4;
129 		break;
130 	case V4L2_PIX_FMT_YUV422P:
131 		rf->cb = rf->luma + size;
132 		rf->cr = rf->cb + size / 2;
133 		break;
134 	case V4L2_PIX_FMT_NV12:
135 	case V4L2_PIX_FMT_NV16:
136 	case V4L2_PIX_FMT_NV24:
137 		rf->cb = rf->luma + size;
138 		rf->cr = rf->cb + 1;
139 		break;
140 	case V4L2_PIX_FMT_NV21:
141 	case V4L2_PIX_FMT_NV61:
142 	case V4L2_PIX_FMT_NV42:
143 		rf->cr = rf->luma + size;
144 		rf->cb = rf->cr + 1;
145 		break;
146 	case V4L2_PIX_FMT_YUYV:
147 		rf->cb = rf->luma + 1;
148 		rf->cr = rf->cb + 2;
149 		break;
150 	case V4L2_PIX_FMT_YVYU:
151 		rf->cr = rf->luma + 1;
152 		rf->cb = rf->cr + 2;
153 		break;
154 	case V4L2_PIX_FMT_UYVY:
155 		rf->cb = rf->luma;
156 		rf->cr = rf->cb + 2;
157 		rf->luma++;
158 		break;
159 	case V4L2_PIX_FMT_VYUY:
160 		rf->cr = rf->luma;
161 		rf->cb = rf->cr + 2;
162 		rf->luma++;
163 		break;
164 	case V4L2_PIX_FMT_RGB24:
165 	case V4L2_PIX_FMT_HSV24:
166 		rf->cr = rf->luma;
167 		rf->cb = rf->cr + 2;
168 		rf->luma++;
169 		break;
170 	case V4L2_PIX_FMT_BGR24:
171 		rf->cb = rf->luma;
172 		rf->cr = rf->cb + 2;
173 		rf->luma++;
174 		break;
175 	case V4L2_PIX_FMT_RGB32:
176 	case V4L2_PIX_FMT_XRGB32:
177 	case V4L2_PIX_FMT_HSV32:
178 	case V4L2_PIX_FMT_ARGB32:
179 		rf->alpha = rf->luma;
180 		rf->cr = rf->luma + 1;
181 		rf->cb = rf->cr + 2;
182 		rf->luma += 2;
183 		break;
184 	case V4L2_PIX_FMT_BGR32:
185 	case V4L2_PIX_FMT_XBGR32:
186 	case V4L2_PIX_FMT_ABGR32:
187 		rf->cb = rf->luma;
188 		rf->cr = rf->cb + 2;
189 		rf->luma++;
190 		rf->alpha = rf->cr + 1;
191 		break;
192 	case V4L2_PIX_FMT_BGRX32:
193 	case V4L2_PIX_FMT_BGRA32:
194 		rf->alpha = rf->luma;
195 		rf->cb = rf->luma + 1;
196 		rf->cr = rf->cb + 2;
197 		rf->luma += 2;
198 		break;
199 	case V4L2_PIX_FMT_RGBX32:
200 	case V4L2_PIX_FMT_RGBA32:
201 		rf->alpha = rf->luma + 3;
202 		rf->cr = rf->luma;
203 		rf->cb = rf->cr + 2;
204 		rf->luma++;
205 		break;
206 	default:
207 		return -EINVAL;
208 	}
209 	return 0;
210 }
211 
212 int v4l2_fwht_encode(struct v4l2_fwht_state *state, u8 *p_in, u8 *p_out)
213 {
214 	unsigned int size = state->stride * state->coded_height;
215 	unsigned int chroma_stride = state->stride;
216 	const struct v4l2_fwht_pixfmt_info *info = state->info;
217 	struct fwht_cframe_hdr *p_hdr;
218 	struct fwht_cframe cf;
219 	struct fwht_raw_frame rf;
220 	u32 encoding;
221 	u32 flags = 0;
222 
223 	if (!info)
224 		return -EINVAL;
225 
226 	if (prepare_raw_frame(&rf, info, p_in, size))
227 		return -EINVAL;
228 
229 	if (info->planes_num == 3)
230 		chroma_stride /= 2;
231 
232 	if (info->id == V4L2_PIX_FMT_NV24 ||
233 	    info->id == V4L2_PIX_FMT_NV42)
234 		chroma_stride *= 2;
235 
236 	cf.i_frame_qp = state->i_frame_qp;
237 	cf.p_frame_qp = state->p_frame_qp;
238 	cf.rlc_data = (__be16 *)(p_out + sizeof(*p_hdr));
239 
240 	encoding = fwht_encode_frame(&rf, &state->ref_frame, &cf,
241 				     !state->gop_cnt,
242 				     state->gop_cnt == state->gop_size - 1,
243 				     state->visible_width,
244 				     state->visible_height,
245 				     state->stride, chroma_stride);
246 	if (!(encoding & FWHT_FRAME_PCODED))
247 		state->gop_cnt = 0;
248 	if (++state->gop_cnt >= state->gop_size)
249 		state->gop_cnt = 0;
250 
251 	p_hdr = (struct fwht_cframe_hdr *)p_out;
252 	p_hdr->magic1 = FWHT_MAGIC1;
253 	p_hdr->magic2 = FWHT_MAGIC2;
254 	p_hdr->version = htonl(FWHT_VERSION);
255 	p_hdr->width = htonl(state->visible_width);
256 	p_hdr->height = htonl(state->visible_height);
257 	flags |= (info->components_num - 1) << FWHT_FL_COMPONENTS_NUM_OFFSET;
258 	flags |= info->pixenc;
259 	if (encoding & FWHT_LUMA_UNENCODED)
260 		flags |= FWHT_FL_LUMA_IS_UNCOMPRESSED;
261 	if (encoding & FWHT_CB_UNENCODED)
262 		flags |= FWHT_FL_CB_IS_UNCOMPRESSED;
263 	if (encoding & FWHT_CR_UNENCODED)
264 		flags |= FWHT_FL_CR_IS_UNCOMPRESSED;
265 	if (encoding & FWHT_ALPHA_UNENCODED)
266 		flags |= FWHT_FL_ALPHA_IS_UNCOMPRESSED;
267 	if (!(encoding & FWHT_FRAME_PCODED))
268 		flags |= FWHT_FL_I_FRAME;
269 	if (rf.height_div == 1)
270 		flags |= FWHT_FL_CHROMA_FULL_HEIGHT;
271 	if (rf.width_div == 1)
272 		flags |= FWHT_FL_CHROMA_FULL_WIDTH;
273 	p_hdr->flags = htonl(flags);
274 	p_hdr->colorspace = htonl(state->colorspace);
275 	p_hdr->xfer_func = htonl(state->xfer_func);
276 	p_hdr->ycbcr_enc = htonl(state->ycbcr_enc);
277 	p_hdr->quantization = htonl(state->quantization);
278 	p_hdr->size = htonl(cf.size);
279 	return cf.size + sizeof(*p_hdr);
280 }
281 
282 int v4l2_fwht_decode(struct v4l2_fwht_state *state, u8 *p_in, u8 *p_out)
283 {
284 	u32 flags;
285 	struct fwht_cframe cf;
286 	unsigned int components_num = 3;
287 	unsigned int version;
288 	const struct v4l2_fwht_pixfmt_info *info;
289 	unsigned int hdr_width_div, hdr_height_div;
290 	struct fwht_raw_frame dst_rf;
291 	unsigned int dst_chroma_stride = state->stride;
292 	unsigned int ref_chroma_stride = state->ref_stride;
293 	unsigned int dst_size = state->stride * state->coded_height;
294 	unsigned int ref_size;
295 
296 	if (!state->info)
297 		return -EINVAL;
298 
299 	info = state->info;
300 
301 	version = ntohl(state->header.version);
302 	if (!version || version > FWHT_VERSION) {
303 		pr_err("version %d is not supported, current version is %d\n",
304 		       version, FWHT_VERSION);
305 		return -EINVAL;
306 	}
307 
308 	if (state->header.magic1 != FWHT_MAGIC1 ||
309 	    state->header.magic2 != FWHT_MAGIC2)
310 		return -EINVAL;
311 
312 	/* TODO: support resolution changes */
313 	if (ntohl(state->header.width)  != state->visible_width ||
314 	    ntohl(state->header.height) != state->visible_height)
315 		return -EINVAL;
316 
317 	flags = ntohl(state->header.flags);
318 
319 	if (version >= 2) {
320 		if ((flags & FWHT_FL_PIXENC_MSK) != info->pixenc)
321 			return -EINVAL;
322 		components_num = 1 + ((flags & FWHT_FL_COMPONENTS_NUM_MSK) >>
323 				FWHT_FL_COMPONENTS_NUM_OFFSET);
324 	}
325 
326 	if (components_num != info->components_num)
327 		return -EINVAL;
328 
329 	state->colorspace = ntohl(state->header.colorspace);
330 	state->xfer_func = ntohl(state->header.xfer_func);
331 	state->ycbcr_enc = ntohl(state->header.ycbcr_enc);
332 	state->quantization = ntohl(state->header.quantization);
333 	cf.rlc_data = (__be16 *)p_in;
334 	cf.size = ntohl(state->header.size);
335 
336 	hdr_width_div = (flags & FWHT_FL_CHROMA_FULL_WIDTH) ? 1 : 2;
337 	hdr_height_div = (flags & FWHT_FL_CHROMA_FULL_HEIGHT) ? 1 : 2;
338 	if (hdr_width_div != info->width_div ||
339 	    hdr_height_div != info->height_div)
340 		return -EINVAL;
341 
342 	if (prepare_raw_frame(&dst_rf, info, p_out, dst_size))
343 		return -EINVAL;
344 	if (info->planes_num == 3) {
345 		dst_chroma_stride /= 2;
346 		ref_chroma_stride /= 2;
347 	}
348 	if (info->id == V4L2_PIX_FMT_NV24 ||
349 	    info->id == V4L2_PIX_FMT_NV42) {
350 		dst_chroma_stride *= 2;
351 		ref_chroma_stride *= 2;
352 	}
353 
354 
355 	ref_size = state->ref_stride * state->coded_height;
356 
357 	if (prepare_raw_frame(&state->ref_frame, info, state->ref_frame.buf,
358 			      ref_size))
359 		return -EINVAL;
360 
361 	if (!fwht_decode_frame(&cf, flags, components_num,
362 			state->visible_width, state->visible_height,
363 			&state->ref_frame, state->ref_stride, ref_chroma_stride,
364 			&dst_rf, state->stride, dst_chroma_stride))
365 		return -EINVAL;
366 	return 0;
367 }
368