1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2019-2020 Pengutronix, Michael Tretter <kernel@pengutronix.de>
4 *
5 * Convert NAL units between raw byte sequence payloads (RBSP) and C structs.
6 *
7 * The conversion is defined in "ITU-T Rec. H.265 (02/2018) high efficiency
8 * video coding". Decoder drivers may use the parser to parse RBSP from
9 * encoded streams and configure the hardware, if the hardware is not able to
10 * parse RBSP itself. Encoder drivers may use the generator to generate the
11 * RBSP for VPS/SPS/PPS nal units and add them to the encoded stream if the
12 * hardware does not generate the units.
13 */
14
15 #include <linux/kernel.h>
16 #include <linux/types.h>
17 #include <linux/string.h>
18 #include <linux/v4l2-controls.h>
19
20 #include <linux/device.h>
21 #include <linux/export.h>
22 #include <linux/log2.h>
23
24 #include "nal-hevc.h"
25 #include "nal-rbsp.h"
26
27 /*
28 * See Rec. ITU-T H.265 (02/2018) Table 7-1 - NAL unit type codes and NAL unit
29 * type classes
30 */
31 enum nal_unit_type {
32 VPS_NUT = 32,
33 SPS_NUT = 33,
34 PPS_NUT = 34,
35 FD_NUT = 38,
36 };
37
nal_hevc_write_start_code_prefix(struct rbsp * rbsp)38 static void nal_hevc_write_start_code_prefix(struct rbsp *rbsp)
39 {
40 u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);
41 int i = 4;
42
43 if (DIV_ROUND_UP(rbsp->pos, 8) + i > rbsp->size) {
44 rbsp->error = -EINVAL;
45 return;
46 }
47
48 p[0] = 0x00;
49 p[1] = 0x00;
50 p[2] = 0x00;
51 p[3] = 0x01;
52
53 rbsp->pos += i * 8;
54 }
55
nal_hevc_read_start_code_prefix(struct rbsp * rbsp)56 static void nal_hevc_read_start_code_prefix(struct rbsp *rbsp)
57 {
58 u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);
59 int i = 4;
60
61 if (DIV_ROUND_UP(rbsp->pos, 8) + i > rbsp->size) {
62 rbsp->error = -EINVAL;
63 return;
64 }
65
66 if (p[0] != 0x00 || p[1] != 0x00 || p[2] != 0x00 || p[3] != 0x01) {
67 rbsp->error = -EINVAL;
68 return;
69 }
70
71 rbsp->pos += i * 8;
72 }
73
nal_hevc_write_filler_data(struct rbsp * rbsp)74 static void nal_hevc_write_filler_data(struct rbsp *rbsp)
75 {
76 u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);
77 int i;
78
79 /* Keep 1 byte extra for terminating the NAL unit */
80 i = rbsp->size - DIV_ROUND_UP(rbsp->pos, 8) - 1;
81 memset(p, 0xff, i);
82 rbsp->pos += i * 8;
83 }
84
nal_hevc_read_filler_data(struct rbsp * rbsp)85 static void nal_hevc_read_filler_data(struct rbsp *rbsp)
86 {
87 u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);
88
89 while (*p == 0xff) {
90 if (DIV_ROUND_UP(rbsp->pos, 8) > rbsp->size) {
91 rbsp->error = -EINVAL;
92 return;
93 }
94
95 p++;
96 rbsp->pos += 8;
97 }
98 }
99
nal_hevc_rbsp_profile_tier_level(struct rbsp * rbsp,struct nal_hevc_profile_tier_level * ptl)100 static void nal_hevc_rbsp_profile_tier_level(struct rbsp *rbsp,
101 struct nal_hevc_profile_tier_level *ptl)
102 {
103 unsigned int i;
104 unsigned int max_num_sub_layers_minus_1 = 0;
105
106 rbsp_bits(rbsp, 2, &ptl->general_profile_space);
107 rbsp_bit(rbsp, &ptl->general_tier_flag);
108 rbsp_bits(rbsp, 5, &ptl->general_profile_idc);
109 for (i = 0; i < 32; i++)
110 rbsp_bit(rbsp, &ptl->general_profile_compatibility_flag[i]);
111 rbsp_bit(rbsp, &ptl->general_progressive_source_flag);
112 rbsp_bit(rbsp, &ptl->general_interlaced_source_flag);
113 rbsp_bit(rbsp, &ptl->general_non_packed_constraint_flag);
114 rbsp_bit(rbsp, &ptl->general_frame_only_constraint_flag);
115 if (ptl->general_profile_idc == 4 ||
116 ptl->general_profile_compatibility_flag[4] ||
117 ptl->general_profile_idc == 5 ||
118 ptl->general_profile_compatibility_flag[5] ||
119 ptl->general_profile_idc == 6 ||
120 ptl->general_profile_compatibility_flag[6] ||
121 ptl->general_profile_idc == 7 ||
122 ptl->general_profile_compatibility_flag[7] ||
123 ptl->general_profile_idc == 8 ||
124 ptl->general_profile_compatibility_flag[8] ||
125 ptl->general_profile_idc == 9 ||
126 ptl->general_profile_compatibility_flag[9] ||
127 ptl->general_profile_idc == 10 ||
128 ptl->general_profile_compatibility_flag[10]) {
129 rbsp_bit(rbsp, &ptl->general_max_12bit_constraint_flag);
130 rbsp_bit(rbsp, &ptl->general_max_10bit_constraint_flag);
131 rbsp_bit(rbsp, &ptl->general_max_8bit_constraint_flag);
132 rbsp_bit(rbsp, &ptl->general_max_422chroma_constraint_flag);
133 rbsp_bit(rbsp, &ptl->general_max_420chroma_constraint_flag);
134 rbsp_bit(rbsp, &ptl->general_max_monochrome_constraint_flag);
135 rbsp_bit(rbsp, &ptl->general_intra_constraint_flag);
136 rbsp_bit(rbsp, &ptl->general_one_picture_only_constraint_flag);
137 rbsp_bit(rbsp, &ptl->general_lower_bit_rate_constraint_flag);
138 if (ptl->general_profile_idc == 5 ||
139 ptl->general_profile_compatibility_flag[5] ||
140 ptl->general_profile_idc == 9 ||
141 ptl->general_profile_compatibility_flag[9] ||
142 ptl->general_profile_idc == 10 ||
143 ptl->general_profile_compatibility_flag[10]) {
144 rbsp_bit(rbsp, &ptl->general_max_14bit_constraint_flag);
145 rbsp_bits(rbsp, 32, &ptl->general_reserved_zero_33bits);
146 rbsp_bits(rbsp, 33 - 32, &ptl->general_reserved_zero_33bits);
147 } else {
148 rbsp_bits(rbsp, 32, &ptl->general_reserved_zero_34bits);
149 rbsp_bits(rbsp, 34 - 2, &ptl->general_reserved_zero_34bits);
150 }
151 } else if (ptl->general_profile_idc == 2 ||
152 ptl->general_profile_compatibility_flag[2]) {
153 rbsp_bits(rbsp, 7, &ptl->general_reserved_zero_7bits);
154 rbsp_bit(rbsp, &ptl->general_one_picture_only_constraint_flag);
155 rbsp_bits(rbsp, 32, &ptl->general_reserved_zero_35bits);
156 rbsp_bits(rbsp, 35 - 32, &ptl->general_reserved_zero_35bits);
157 } else {
158 rbsp_bits(rbsp, 32, &ptl->general_reserved_zero_43bits);
159 rbsp_bits(rbsp, 43 - 32, &ptl->general_reserved_zero_43bits);
160 }
161 if ((ptl->general_profile_idc >= 1 && ptl->general_profile_idc <= 5) ||
162 ptl->general_profile_idc == 9 ||
163 ptl->general_profile_compatibility_flag[1] ||
164 ptl->general_profile_compatibility_flag[2] ||
165 ptl->general_profile_compatibility_flag[3] ||
166 ptl->general_profile_compatibility_flag[4] ||
167 ptl->general_profile_compatibility_flag[5] ||
168 ptl->general_profile_compatibility_flag[9])
169 rbsp_bit(rbsp, &ptl->general_inbld_flag);
170 else
171 rbsp_bit(rbsp, &ptl->general_reserved_zero_bit);
172 rbsp_bits(rbsp, 8, &ptl->general_level_idc);
173 if (max_num_sub_layers_minus_1 > 0)
174 rbsp_unsupported(rbsp);
175 }
176
nal_hevc_rbsp_vps(struct rbsp * rbsp,struct nal_hevc_vps * vps)177 static void nal_hevc_rbsp_vps(struct rbsp *rbsp, struct nal_hevc_vps *vps)
178 {
179 unsigned int i, j;
180 unsigned int reserved_0xffff_16bits = 0xffff;
181
182 rbsp_bits(rbsp, 4, &vps->video_parameter_set_id);
183 rbsp_bit(rbsp, &vps->base_layer_internal_flag);
184 rbsp_bit(rbsp, &vps->base_layer_available_flag);
185 rbsp_bits(rbsp, 6, &vps->max_layers_minus1);
186 rbsp_bits(rbsp, 3, &vps->max_sub_layers_minus1);
187 rbsp_bits(rbsp, 1, &vps->temporal_id_nesting_flag);
188 rbsp_bits(rbsp, 16, &reserved_0xffff_16bits);
189 nal_hevc_rbsp_profile_tier_level(rbsp, &vps->profile_tier_level);
190 rbsp_bit(rbsp, &vps->sub_layer_ordering_info_present_flag);
191 for (i = vps->sub_layer_ordering_info_present_flag ? 0 : vps->max_sub_layers_minus1;
192 i <= vps->max_sub_layers_minus1; i++) {
193 rbsp_uev(rbsp, &vps->max_dec_pic_buffering_minus1[i]);
194 rbsp_uev(rbsp, &vps->max_num_reorder_pics[i]);
195 rbsp_uev(rbsp, &vps->max_latency_increase_plus1[i]);
196 }
197 rbsp_bits(rbsp, 6, &vps->max_layer_id);
198 rbsp_uev(rbsp, &vps->num_layer_sets_minus1);
199 for (i = 0; i <= vps->num_layer_sets_minus1; i++)
200 for (j = 0; j <= vps->max_layer_id; j++)
201 rbsp_bit(rbsp, &vps->layer_id_included_flag[i][j]);
202 rbsp_bit(rbsp, &vps->timing_info_present_flag);
203 if (vps->timing_info_present_flag)
204 rbsp_unsupported(rbsp);
205 rbsp_bit(rbsp, &vps->extension_flag);
206 if (vps->extension_flag)
207 rbsp_unsupported(rbsp);
208 }
209
nal_hevc_rbsp_sub_layer_hrd_parameters(struct rbsp * rbsp,struct nal_hevc_sub_layer_hrd_parameters * hrd)210 static void nal_hevc_rbsp_sub_layer_hrd_parameters(struct rbsp *rbsp,
211 struct nal_hevc_sub_layer_hrd_parameters *hrd)
212 {
213 unsigned int i;
214 unsigned int cpb_cnt = 1;
215
216 for (i = 0; i < cpb_cnt; i++) {
217 rbsp_uev(rbsp, &hrd->bit_rate_value_minus1[i]);
218 rbsp_uev(rbsp, &hrd->cpb_size_value_minus1[i]);
219 rbsp_bit(rbsp, &hrd->cbr_flag[i]);
220 }
221 }
222
nal_hevc_rbsp_hrd_parameters(struct rbsp * rbsp,struct nal_hevc_hrd_parameters * hrd)223 static void nal_hevc_rbsp_hrd_parameters(struct rbsp *rbsp,
224 struct nal_hevc_hrd_parameters *hrd)
225 {
226 unsigned int i;
227 unsigned int max_num_sub_layers_minus_1 = 0;
228
229 rbsp_bit(rbsp, &hrd->nal_hrd_parameters_present_flag);
230 rbsp_bit(rbsp, &hrd->vcl_hrd_parameters_present_flag);
231 if (hrd->nal_hrd_parameters_present_flag || hrd->vcl_hrd_parameters_present_flag) {
232 rbsp_bit(rbsp, &hrd->sub_pic_hrd_params_present_flag);
233 if (hrd->sub_pic_hrd_params_present_flag) {
234 rbsp_bits(rbsp, 8, &hrd->tick_divisor_minus2);
235 rbsp_bits(rbsp, 5, &hrd->du_cpb_removal_delay_increment_length_minus1);
236 rbsp_bit(rbsp, &hrd->sub_pic_cpb_params_in_pic_timing_sei_flag);
237 rbsp_bits(rbsp, 5, &hrd->dpb_output_delay_du_length_minus1);
238 }
239 rbsp_bits(rbsp, 4, &hrd->bit_rate_scale);
240 rbsp_bits(rbsp, 4, &hrd->cpb_size_scale);
241 if (hrd->sub_pic_hrd_params_present_flag)
242 rbsp_bits(rbsp, 4, &hrd->cpb_size_du_scale);
243 rbsp_bits(rbsp, 5, &hrd->initial_cpb_removal_delay_length_minus1);
244 rbsp_bits(rbsp, 5, &hrd->au_cpb_removal_delay_length_minus1);
245 rbsp_bits(rbsp, 5, &hrd->dpb_output_delay_length_minus1);
246 }
247 for (i = 0; i <= max_num_sub_layers_minus_1; i++) {
248 rbsp_bit(rbsp, &hrd->fixed_pic_rate_general_flag[i]);
249 if (!hrd->fixed_pic_rate_general_flag[i])
250 rbsp_bit(rbsp, &hrd->fixed_pic_rate_within_cvs_flag[i]);
251 if (hrd->fixed_pic_rate_within_cvs_flag[i])
252 rbsp_uev(rbsp, &hrd->elemental_duration_in_tc_minus1[i]);
253 else
254 rbsp_bit(rbsp, &hrd->low_delay_hrd_flag[i]);
255 if (!hrd->low_delay_hrd_flag[i])
256 rbsp_uev(rbsp, &hrd->cpb_cnt_minus1[i]);
257 if (hrd->nal_hrd_parameters_present_flag)
258 nal_hevc_rbsp_sub_layer_hrd_parameters(rbsp, &hrd->vcl_hrd[i]);
259 if (hrd->vcl_hrd_parameters_present_flag)
260 nal_hevc_rbsp_sub_layer_hrd_parameters(rbsp, &hrd->vcl_hrd[i]);
261 }
262 }
263
nal_hevc_rbsp_vui_parameters(struct rbsp * rbsp,struct nal_hevc_vui_parameters * vui)264 static void nal_hevc_rbsp_vui_parameters(struct rbsp *rbsp,
265 struct nal_hevc_vui_parameters *vui)
266 {
267 if (!vui) {
268 rbsp->error = -EINVAL;
269 return;
270 }
271
272 rbsp_bit(rbsp, &vui->aspect_ratio_info_present_flag);
273 if (vui->aspect_ratio_info_present_flag) {
274 rbsp_bits(rbsp, 8, &vui->aspect_ratio_idc);
275 if (vui->aspect_ratio_idc == 255) {
276 rbsp_bits(rbsp, 16, &vui->sar_width);
277 rbsp_bits(rbsp, 16, &vui->sar_height);
278 }
279 }
280
281 rbsp_bit(rbsp, &vui->overscan_info_present_flag);
282 if (vui->overscan_info_present_flag)
283 rbsp_bit(rbsp, &vui->overscan_appropriate_flag);
284
285 rbsp_bit(rbsp, &vui->video_signal_type_present_flag);
286 if (vui->video_signal_type_present_flag) {
287 rbsp_bits(rbsp, 3, &vui->video_format);
288 rbsp_bit(rbsp, &vui->video_full_range_flag);
289
290 rbsp_bit(rbsp, &vui->colour_description_present_flag);
291 if (vui->colour_description_present_flag) {
292 rbsp_bits(rbsp, 8, &vui->colour_primaries);
293 rbsp_bits(rbsp, 8, &vui->transfer_characteristics);
294 rbsp_bits(rbsp, 8, &vui->matrix_coeffs);
295 }
296 }
297
298 rbsp_bit(rbsp, &vui->chroma_loc_info_present_flag);
299 if (vui->chroma_loc_info_present_flag) {
300 rbsp_uev(rbsp, &vui->chroma_sample_loc_type_top_field);
301 rbsp_uev(rbsp, &vui->chroma_sample_loc_type_bottom_field);
302 }
303
304 rbsp_bit(rbsp, &vui->neutral_chroma_indication_flag);
305 rbsp_bit(rbsp, &vui->field_seq_flag);
306 rbsp_bit(rbsp, &vui->frame_field_info_present_flag);
307 rbsp_bit(rbsp, &vui->default_display_window_flag);
308 if (vui->default_display_window_flag) {
309 rbsp_uev(rbsp, &vui->def_disp_win_left_offset);
310 rbsp_uev(rbsp, &vui->def_disp_win_right_offset);
311 rbsp_uev(rbsp, &vui->def_disp_win_top_offset);
312 rbsp_uev(rbsp, &vui->def_disp_win_bottom_offset);
313 }
314
315 rbsp_bit(rbsp, &vui->vui_timing_info_present_flag);
316 if (vui->vui_timing_info_present_flag) {
317 rbsp_bits(rbsp, 32, &vui->vui_num_units_in_tick);
318 rbsp_bits(rbsp, 32, &vui->vui_time_scale);
319 rbsp_bit(rbsp, &vui->vui_poc_proportional_to_timing_flag);
320 if (vui->vui_poc_proportional_to_timing_flag)
321 rbsp_uev(rbsp, &vui->vui_num_ticks_poc_diff_one_minus1);
322 rbsp_bit(rbsp, &vui->vui_hrd_parameters_present_flag);
323 if (vui->vui_hrd_parameters_present_flag)
324 nal_hevc_rbsp_hrd_parameters(rbsp, &vui->nal_hrd_parameters);
325 }
326
327 rbsp_bit(rbsp, &vui->bitstream_restriction_flag);
328 if (vui->bitstream_restriction_flag) {
329 rbsp_bit(rbsp, &vui->tiles_fixed_structure_flag);
330 rbsp_bit(rbsp, &vui->motion_vectors_over_pic_boundaries_flag);
331 rbsp_bit(rbsp, &vui->restricted_ref_pic_lists_flag);
332 rbsp_uev(rbsp, &vui->min_spatial_segmentation_idc);
333 rbsp_uev(rbsp, &vui->max_bytes_per_pic_denom);
334 rbsp_uev(rbsp, &vui->max_bits_per_min_cu_denom);
335 rbsp_uev(rbsp, &vui->log2_max_mv_length_horizontal);
336 rbsp_uev(rbsp, &vui->log2_max_mv_length_vertical);
337 }
338 }
339
nal_hevc_rbsp_sps(struct rbsp * rbsp,struct nal_hevc_sps * sps)340 static void nal_hevc_rbsp_sps(struct rbsp *rbsp, struct nal_hevc_sps *sps)
341 {
342 unsigned int i;
343
344 rbsp_bits(rbsp, 4, &sps->video_parameter_set_id);
345 rbsp_bits(rbsp, 3, &sps->max_sub_layers_minus1);
346 rbsp_bit(rbsp, &sps->temporal_id_nesting_flag);
347 nal_hevc_rbsp_profile_tier_level(rbsp, &sps->profile_tier_level);
348 rbsp_uev(rbsp, &sps->seq_parameter_set_id);
349
350 rbsp_uev(rbsp, &sps->chroma_format_idc);
351 if (sps->chroma_format_idc == 3)
352 rbsp_bit(rbsp, &sps->separate_colour_plane_flag);
353 rbsp_uev(rbsp, &sps->pic_width_in_luma_samples);
354 rbsp_uev(rbsp, &sps->pic_height_in_luma_samples);
355 rbsp_bit(rbsp, &sps->conformance_window_flag);
356 if (sps->conformance_window_flag) {
357 rbsp_uev(rbsp, &sps->conf_win_left_offset);
358 rbsp_uev(rbsp, &sps->conf_win_right_offset);
359 rbsp_uev(rbsp, &sps->conf_win_top_offset);
360 rbsp_uev(rbsp, &sps->conf_win_bottom_offset);
361 }
362 rbsp_uev(rbsp, &sps->bit_depth_luma_minus8);
363 rbsp_uev(rbsp, &sps->bit_depth_chroma_minus8);
364
365 rbsp_uev(rbsp, &sps->log2_max_pic_order_cnt_lsb_minus4);
366
367 rbsp_bit(rbsp, &sps->sub_layer_ordering_info_present_flag);
368 for (i = (sps->sub_layer_ordering_info_present_flag ? 0 : sps->max_sub_layers_minus1);
369 i <= sps->max_sub_layers_minus1; i++) {
370 rbsp_uev(rbsp, &sps->max_dec_pic_buffering_minus1[i]);
371 rbsp_uev(rbsp, &sps->max_num_reorder_pics[i]);
372 rbsp_uev(rbsp, &sps->max_latency_increase_plus1[i]);
373 }
374 rbsp_uev(rbsp, &sps->log2_min_luma_coding_block_size_minus3);
375 rbsp_uev(rbsp, &sps->log2_diff_max_min_luma_coding_block_size);
376 rbsp_uev(rbsp, &sps->log2_min_luma_transform_block_size_minus2);
377 rbsp_uev(rbsp, &sps->log2_diff_max_min_luma_transform_block_size);
378 rbsp_uev(rbsp, &sps->max_transform_hierarchy_depth_inter);
379 rbsp_uev(rbsp, &sps->max_transform_hierarchy_depth_intra);
380
381 rbsp_bit(rbsp, &sps->scaling_list_enabled_flag);
382 if (sps->scaling_list_enabled_flag)
383 rbsp_unsupported(rbsp);
384
385 rbsp_bit(rbsp, &sps->amp_enabled_flag);
386 rbsp_bit(rbsp, &sps->sample_adaptive_offset_enabled_flag);
387 rbsp_bit(rbsp, &sps->pcm_enabled_flag);
388 if (sps->pcm_enabled_flag) {
389 rbsp_bits(rbsp, 4, &sps->pcm_sample_bit_depth_luma_minus1);
390 rbsp_bits(rbsp, 4, &sps->pcm_sample_bit_depth_chroma_minus1);
391 rbsp_uev(rbsp, &sps->log2_min_pcm_luma_coding_block_size_minus3);
392 rbsp_uev(rbsp, &sps->log2_diff_max_min_pcm_luma_coding_block_size);
393 rbsp_bit(rbsp, &sps->pcm_loop_filter_disabled_flag);
394 }
395
396 rbsp_uev(rbsp, &sps->num_short_term_ref_pic_sets);
397 if (sps->num_short_term_ref_pic_sets > 0)
398 rbsp_unsupported(rbsp);
399
400 rbsp_bit(rbsp, &sps->long_term_ref_pics_present_flag);
401 if (sps->long_term_ref_pics_present_flag)
402 rbsp_unsupported(rbsp);
403
404 rbsp_bit(rbsp, &sps->sps_temporal_mvp_enabled_flag);
405 rbsp_bit(rbsp, &sps->strong_intra_smoothing_enabled_flag);
406 rbsp_bit(rbsp, &sps->vui_parameters_present_flag);
407 if (sps->vui_parameters_present_flag)
408 nal_hevc_rbsp_vui_parameters(rbsp, &sps->vui);
409
410 rbsp_bit(rbsp, &sps->extension_present_flag);
411 if (sps->extension_present_flag) {
412 rbsp_bit(rbsp, &sps->sps_range_extension_flag);
413 rbsp_bit(rbsp, &sps->sps_multilayer_extension_flag);
414 rbsp_bit(rbsp, &sps->sps_3d_extension_flag);
415 rbsp_bit(rbsp, &sps->sps_scc_extension_flag);
416 rbsp_bits(rbsp, 5, &sps->sps_extension_4bits);
417 }
418 if (sps->sps_range_extension_flag)
419 rbsp_unsupported(rbsp);
420 if (sps->sps_multilayer_extension_flag)
421 rbsp_unsupported(rbsp);
422 if (sps->sps_3d_extension_flag)
423 rbsp_unsupported(rbsp);
424 if (sps->sps_scc_extension_flag)
425 rbsp_unsupported(rbsp);
426 if (sps->sps_extension_4bits)
427 rbsp_unsupported(rbsp);
428 }
429
nal_hevc_rbsp_pps(struct rbsp * rbsp,struct nal_hevc_pps * pps)430 static void nal_hevc_rbsp_pps(struct rbsp *rbsp, struct nal_hevc_pps *pps)
431 {
432 unsigned int i;
433
434 rbsp_uev(rbsp, &pps->pps_pic_parameter_set_id);
435 rbsp_uev(rbsp, &pps->pps_seq_parameter_set_id);
436 rbsp_bit(rbsp, &pps->dependent_slice_segments_enabled_flag);
437 rbsp_bit(rbsp, &pps->output_flag_present_flag);
438 rbsp_bits(rbsp, 3, &pps->num_extra_slice_header_bits);
439 rbsp_bit(rbsp, &pps->sign_data_hiding_enabled_flag);
440 rbsp_bit(rbsp, &pps->cabac_init_present_flag);
441 rbsp_uev(rbsp, &pps->num_ref_idx_l0_default_active_minus1);
442 rbsp_uev(rbsp, &pps->num_ref_idx_l1_default_active_minus1);
443 rbsp_sev(rbsp, &pps->init_qp_minus26);
444 rbsp_bit(rbsp, &pps->constrained_intra_pred_flag);
445 rbsp_bit(rbsp, &pps->transform_skip_enabled_flag);
446 rbsp_bit(rbsp, &pps->cu_qp_delta_enabled_flag);
447 if (pps->cu_qp_delta_enabled_flag)
448 rbsp_uev(rbsp, &pps->diff_cu_qp_delta_depth);
449 rbsp_sev(rbsp, &pps->pps_cb_qp_offset);
450 rbsp_sev(rbsp, &pps->pps_cr_qp_offset);
451 rbsp_bit(rbsp, &pps->pps_slice_chroma_qp_offsets_present_flag);
452 rbsp_bit(rbsp, &pps->weighted_pred_flag);
453 rbsp_bit(rbsp, &pps->weighted_bipred_flag);
454 rbsp_bit(rbsp, &pps->transquant_bypass_enabled_flag);
455 rbsp_bit(rbsp, &pps->tiles_enabled_flag);
456 rbsp_bit(rbsp, &pps->entropy_coding_sync_enabled_flag);
457 if (pps->tiles_enabled_flag) {
458 rbsp_uev(rbsp, &pps->num_tile_columns_minus1);
459 rbsp_uev(rbsp, &pps->num_tile_rows_minus1);
460 rbsp_bit(rbsp, &pps->uniform_spacing_flag);
461 if (!pps->uniform_spacing_flag) {
462 for (i = 0; i < pps->num_tile_columns_minus1; i++)
463 rbsp_uev(rbsp, &pps->column_width_minus1[i]);
464 for (i = 0; i < pps->num_tile_rows_minus1; i++)
465 rbsp_uev(rbsp, &pps->row_height_minus1[i]);
466 }
467 rbsp_bit(rbsp, &pps->loop_filter_across_tiles_enabled_flag);
468 }
469 rbsp_bit(rbsp, &pps->pps_loop_filter_across_slices_enabled_flag);
470 rbsp_bit(rbsp, &pps->deblocking_filter_control_present_flag);
471 if (pps->deblocking_filter_control_present_flag) {
472 rbsp_bit(rbsp, &pps->deblocking_filter_override_enabled_flag);
473 rbsp_bit(rbsp, &pps->pps_deblocking_filter_disabled_flag);
474 if (!pps->pps_deblocking_filter_disabled_flag) {
475 rbsp_sev(rbsp, &pps->pps_beta_offset_div2);
476 rbsp_sev(rbsp, &pps->pps_tc_offset_div2);
477 }
478 }
479 rbsp_bit(rbsp, &pps->pps_scaling_list_data_present_flag);
480 if (pps->pps_scaling_list_data_present_flag)
481 rbsp_unsupported(rbsp);
482 rbsp_bit(rbsp, &pps->lists_modification_present_flag);
483 rbsp_uev(rbsp, &pps->log2_parallel_merge_level_minus2);
484 rbsp_bit(rbsp, &pps->slice_segment_header_extension_present_flag);
485 rbsp_bit(rbsp, &pps->pps_extension_present_flag);
486 if (pps->pps_extension_present_flag) {
487 rbsp_bit(rbsp, &pps->pps_range_extension_flag);
488 rbsp_bit(rbsp, &pps->pps_multilayer_extension_flag);
489 rbsp_bit(rbsp, &pps->pps_3d_extension_flag);
490 rbsp_bit(rbsp, &pps->pps_scc_extension_flag);
491 rbsp_bits(rbsp, 4, &pps->pps_extension_4bits);
492 }
493 if (pps->pps_range_extension_flag)
494 rbsp_unsupported(rbsp);
495 if (pps->pps_multilayer_extension_flag)
496 rbsp_unsupported(rbsp);
497 if (pps->pps_3d_extension_flag)
498 rbsp_unsupported(rbsp);
499 if (pps->pps_scc_extension_flag)
500 rbsp_unsupported(rbsp);
501 if (pps->pps_extension_4bits)
502 rbsp_unsupported(rbsp);
503 }
504
505 /**
506 * nal_hevc_write_vps() - Write PPS NAL unit into RBSP format
507 * @dev: device pointer
508 * @dest: the buffer that is filled with RBSP data
509 * @n: maximum size of @dest in bytes
510 * @vps: &struct nal_hevc_vps to convert to RBSP
511 *
512 * Convert @vps to RBSP data and write it into @dest.
513 *
514 * The size of the VPS NAL unit is not known in advance and this function will
515 * fail, if @dest does not hold sufficient space for the VPS NAL unit.
516 *
517 * Return: number of bytes written to @dest or negative error code
518 */
nal_hevc_write_vps(const struct device * dev,void * dest,size_t n,struct nal_hevc_vps * vps)519 ssize_t nal_hevc_write_vps(const struct device *dev,
520 void *dest, size_t n, struct nal_hevc_vps *vps)
521 {
522 struct rbsp rbsp;
523 unsigned int forbidden_zero_bit = 0;
524 unsigned int nal_unit_type = VPS_NUT;
525 unsigned int nuh_layer_id = 0;
526 unsigned int nuh_temporal_id_plus1 = 1;
527
528 if (!dest)
529 return -EINVAL;
530
531 rbsp_init(&rbsp, dest, n, &write);
532
533 nal_hevc_write_start_code_prefix(&rbsp);
534
535 /* NAL unit header */
536 rbsp_bit(&rbsp, &forbidden_zero_bit);
537 rbsp_bits(&rbsp, 6, &nal_unit_type);
538 rbsp_bits(&rbsp, 6, &nuh_layer_id);
539 rbsp_bits(&rbsp, 3, &nuh_temporal_id_plus1);
540
541 nal_hevc_rbsp_vps(&rbsp, vps);
542
543 rbsp_trailing_bits(&rbsp);
544
545 if (rbsp.error)
546 return rbsp.error;
547
548 return DIV_ROUND_UP(rbsp.pos, 8);
549 }
550 EXPORT_SYMBOL_GPL(nal_hevc_write_vps);
551
552 /**
553 * nal_hevc_read_vps() - Read VPS NAL unit from RBSP format
554 * @dev: device pointer
555 * @vps: the &struct nal_hevc_vps to fill from the RBSP data
556 * @src: the buffer that contains the RBSP data
557 * @n: size of @src in bytes
558 *
559 * Read RBSP data from @src and use it to fill @vps.
560 *
561 * Return: number of bytes read from @src or negative error code
562 */
nal_hevc_read_vps(const struct device * dev,struct nal_hevc_vps * vps,void * src,size_t n)563 ssize_t nal_hevc_read_vps(const struct device *dev,
564 struct nal_hevc_vps *vps, void *src, size_t n)
565 {
566 struct rbsp rbsp;
567 unsigned int forbidden_zero_bit;
568 unsigned int nal_unit_type;
569 unsigned int nuh_layer_id;
570 unsigned int nuh_temporal_id_plus1;
571
572 if (!src)
573 return -EINVAL;
574
575 rbsp_init(&rbsp, src, n, &read);
576
577 nal_hevc_read_start_code_prefix(&rbsp);
578
579 rbsp_bit(&rbsp, &forbidden_zero_bit);
580 rbsp_bits(&rbsp, 6, &nal_unit_type);
581 rbsp_bits(&rbsp, 6, &nuh_layer_id);
582 rbsp_bits(&rbsp, 3, &nuh_temporal_id_plus1);
583
584 if (rbsp.error ||
585 forbidden_zero_bit != 0 ||
586 nal_unit_type != VPS_NUT)
587 return -EINVAL;
588
589 nal_hevc_rbsp_vps(&rbsp, vps);
590
591 rbsp_trailing_bits(&rbsp);
592
593 if (rbsp.error)
594 return rbsp.error;
595
596 return DIV_ROUND_UP(rbsp.pos, 8);
597 }
598 EXPORT_SYMBOL_GPL(nal_hevc_read_vps);
599
600 /**
601 * nal_hevc_write_sps() - Write SPS NAL unit into RBSP format
602 * @dev: device pointer
603 * @dest: the buffer that is filled with RBSP data
604 * @n: maximum size of @dest in bytes
605 * @sps: &struct nal_hevc_sps to convert to RBSP
606 *
607 * Convert @sps to RBSP data and write it into @dest.
608 *
609 * The size of the SPS NAL unit is not known in advance and this function will
610 * fail, if @dest does not hold sufficient space for the SPS NAL unit.
611 *
612 * Return: number of bytes written to @dest or negative error code
613 */
nal_hevc_write_sps(const struct device * dev,void * dest,size_t n,struct nal_hevc_sps * sps)614 ssize_t nal_hevc_write_sps(const struct device *dev,
615 void *dest, size_t n, struct nal_hevc_sps *sps)
616 {
617 struct rbsp rbsp;
618 unsigned int forbidden_zero_bit = 0;
619 unsigned int nal_unit_type = SPS_NUT;
620 unsigned int nuh_layer_id = 0;
621 unsigned int nuh_temporal_id_plus1 = 1;
622
623 if (!dest)
624 return -EINVAL;
625
626 rbsp_init(&rbsp, dest, n, &write);
627
628 nal_hevc_write_start_code_prefix(&rbsp);
629
630 /* NAL unit header */
631 rbsp_bit(&rbsp, &forbidden_zero_bit);
632 rbsp_bits(&rbsp, 6, &nal_unit_type);
633 rbsp_bits(&rbsp, 6, &nuh_layer_id);
634 rbsp_bits(&rbsp, 3, &nuh_temporal_id_plus1);
635
636 nal_hevc_rbsp_sps(&rbsp, sps);
637
638 rbsp_trailing_bits(&rbsp);
639
640 if (rbsp.error)
641 return rbsp.error;
642
643 return DIV_ROUND_UP(rbsp.pos, 8);
644 }
645 EXPORT_SYMBOL_GPL(nal_hevc_write_sps);
646
647 /**
648 * nal_hevc_read_sps() - Read SPS NAL unit from RBSP format
649 * @dev: device pointer
650 * @sps: the &struct nal_hevc_sps to fill from the RBSP data
651 * @src: the buffer that contains the RBSP data
652 * @n: size of @src in bytes
653 *
654 * Read RBSP data from @src and use it to fill @sps.
655 *
656 * Return: number of bytes read from @src or negative error code
657 */
nal_hevc_read_sps(const struct device * dev,struct nal_hevc_sps * sps,void * src,size_t n)658 ssize_t nal_hevc_read_sps(const struct device *dev,
659 struct nal_hevc_sps *sps, void *src, size_t n)
660 {
661 struct rbsp rbsp;
662 unsigned int forbidden_zero_bit;
663 unsigned int nal_unit_type;
664 unsigned int nuh_layer_id;
665 unsigned int nuh_temporal_id_plus1;
666
667 if (!src)
668 return -EINVAL;
669
670 rbsp_init(&rbsp, src, n, &read);
671
672 nal_hevc_read_start_code_prefix(&rbsp);
673
674 rbsp_bit(&rbsp, &forbidden_zero_bit);
675 rbsp_bits(&rbsp, 6, &nal_unit_type);
676 rbsp_bits(&rbsp, 6, &nuh_layer_id);
677 rbsp_bits(&rbsp, 3, &nuh_temporal_id_plus1);
678
679 if (rbsp.error ||
680 forbidden_zero_bit != 0 ||
681 nal_unit_type != SPS_NUT)
682 return -EINVAL;
683
684 nal_hevc_rbsp_sps(&rbsp, sps);
685
686 rbsp_trailing_bits(&rbsp);
687
688 if (rbsp.error)
689 return rbsp.error;
690
691 return DIV_ROUND_UP(rbsp.pos, 8);
692 }
693 EXPORT_SYMBOL_GPL(nal_hevc_read_sps);
694
695 /**
696 * nal_hevc_write_pps() - Write PPS NAL unit into RBSP format
697 * @dev: device pointer
698 * @dest: the buffer that is filled with RBSP data
699 * @n: maximum size of @dest in bytes
700 * @pps: &struct nal_hevc_pps to convert to RBSP
701 *
702 * Convert @pps to RBSP data and write it into @dest.
703 *
704 * The size of the PPS NAL unit is not known in advance and this function will
705 * fail, if @dest does not hold sufficient space for the PPS NAL unit.
706 *
707 * Return: number of bytes written to @dest or negative error code
708 */
nal_hevc_write_pps(const struct device * dev,void * dest,size_t n,struct nal_hevc_pps * pps)709 ssize_t nal_hevc_write_pps(const struct device *dev,
710 void *dest, size_t n, struct nal_hevc_pps *pps)
711 {
712 struct rbsp rbsp;
713 unsigned int forbidden_zero_bit = 0;
714 unsigned int nal_unit_type = PPS_NUT;
715 unsigned int nuh_layer_id = 0;
716 unsigned int nuh_temporal_id_plus1 = 1;
717
718 if (!dest)
719 return -EINVAL;
720
721 rbsp_init(&rbsp, dest, n, &write);
722
723 nal_hevc_write_start_code_prefix(&rbsp);
724
725 /* NAL unit header */
726 rbsp_bit(&rbsp, &forbidden_zero_bit);
727 rbsp_bits(&rbsp, 6, &nal_unit_type);
728 rbsp_bits(&rbsp, 6, &nuh_layer_id);
729 rbsp_bits(&rbsp, 3, &nuh_temporal_id_plus1);
730
731 nal_hevc_rbsp_pps(&rbsp, pps);
732
733 rbsp_trailing_bits(&rbsp);
734
735 if (rbsp.error)
736 return rbsp.error;
737
738 return DIV_ROUND_UP(rbsp.pos, 8);
739 }
740 EXPORT_SYMBOL_GPL(nal_hevc_write_pps);
741
742 /**
743 * nal_hevc_read_pps() - Read PPS NAL unit from RBSP format
744 * @dev: device pointer
745 * @pps: the &struct nal_hevc_pps to fill from the RBSP data
746 * @src: the buffer that contains the RBSP data
747 * @n: size of @src in bytes
748 *
749 * Read RBSP data from @src and use it to fill @pps.
750 *
751 * Return: number of bytes read from @src or negative error code
752 */
nal_hevc_read_pps(const struct device * dev,struct nal_hevc_pps * pps,void * src,size_t n)753 ssize_t nal_hevc_read_pps(const struct device *dev,
754 struct nal_hevc_pps *pps, void *src, size_t n)
755 {
756 struct rbsp rbsp;
757 unsigned int forbidden_zero_bit;
758 unsigned int nal_unit_type;
759 unsigned int nuh_layer_id;
760 unsigned int nuh_temporal_id_plus1;
761
762 if (!src)
763 return -EINVAL;
764
765 rbsp_init(&rbsp, src, n, &read);
766
767 nal_hevc_read_start_code_prefix(&rbsp);
768
769 /* NAL unit header */
770 rbsp_bit(&rbsp, &forbidden_zero_bit);
771 rbsp_bits(&rbsp, 6, &nal_unit_type);
772 rbsp_bits(&rbsp, 6, &nuh_layer_id);
773 rbsp_bits(&rbsp, 3, &nuh_temporal_id_plus1);
774
775 nal_hevc_rbsp_pps(&rbsp, pps);
776
777 rbsp_trailing_bits(&rbsp);
778
779 if (rbsp.error)
780 return rbsp.error;
781
782 return DIV_ROUND_UP(rbsp.pos, 8);
783 }
784 EXPORT_SYMBOL_GPL(nal_hevc_read_pps);
785
786 /**
787 * nal_hevc_write_filler() - Write filler data RBSP
788 * @dev: device pointer
789 * @dest: buffer to fill with filler data
790 * @n: size of the buffer to fill with filler data
791 *
792 * Write a filler data RBSP to @dest with a size of @n bytes and return the
793 * number of written filler data bytes.
794 *
795 * Use this function to generate dummy data in an RBSP data stream that can be
796 * safely ignored by hevc decoders.
797 *
798 * The RBSP format of the filler data is specified in Rec. ITU-T H.265
799 * (02/2018) 7.3.2.8 Filler data RBSP syntax.
800 *
801 * Return: number of filler data bytes (including marker) or negative error
802 */
nal_hevc_write_filler(const struct device * dev,void * dest,size_t n)803 ssize_t nal_hevc_write_filler(const struct device *dev, void *dest, size_t n)
804 {
805 struct rbsp rbsp;
806 unsigned int forbidden_zero_bit = 0;
807 unsigned int nal_unit_type = FD_NUT;
808 unsigned int nuh_layer_id = 0;
809 unsigned int nuh_temporal_id_plus1 = 1;
810
811 if (!dest)
812 return -EINVAL;
813
814 rbsp_init(&rbsp, dest, n, &write);
815
816 nal_hevc_write_start_code_prefix(&rbsp);
817
818 rbsp_bit(&rbsp, &forbidden_zero_bit);
819 rbsp_bits(&rbsp, 6, &nal_unit_type);
820 rbsp_bits(&rbsp, 6, &nuh_layer_id);
821 rbsp_bits(&rbsp, 3, &nuh_temporal_id_plus1);
822
823 nal_hevc_write_filler_data(&rbsp);
824 rbsp_trailing_bits(&rbsp);
825
826 if (rbsp.error)
827 return rbsp.error;
828
829 return DIV_ROUND_UP(rbsp.pos, 8);
830 }
831 EXPORT_SYMBOL_GPL(nal_hevc_write_filler);
832
833 /**
834 * nal_hevc_read_filler() - Read filler data RBSP
835 * @dev: device pointer
836 * @src: buffer with RBSP data that is read
837 * @n: maximum size of src that shall be read
838 *
839 * Read a filler data RBSP from @src up to a maximum size of @n bytes and
840 * return the size of the filler data in bytes including the marker.
841 *
842 * This function is used to parse filler data and skip the respective bytes in
843 * the RBSP data.
844 *
845 * The RBSP format of the filler data is specified in Rec. ITU-T H.265
846 * (02/2018) 7.3.2.8 Filler data RBSP syntax.
847 *
848 * Return: number of filler data bytes (including marker) or negative error
849 */
nal_hevc_read_filler(const struct device * dev,void * src,size_t n)850 ssize_t nal_hevc_read_filler(const struct device *dev, void *src, size_t n)
851 {
852 struct rbsp rbsp;
853 unsigned int forbidden_zero_bit;
854 unsigned int nal_unit_type;
855 unsigned int nuh_layer_id;
856 unsigned int nuh_temporal_id_plus1;
857
858 if (!src)
859 return -EINVAL;
860
861 rbsp_init(&rbsp, src, n, &read);
862
863 nal_hevc_read_start_code_prefix(&rbsp);
864
865 rbsp_bit(&rbsp, &forbidden_zero_bit);
866 rbsp_bits(&rbsp, 6, &nal_unit_type);
867 rbsp_bits(&rbsp, 6, &nuh_layer_id);
868 rbsp_bits(&rbsp, 3, &nuh_temporal_id_plus1);
869
870 if (rbsp.error)
871 return rbsp.error;
872 if (forbidden_zero_bit != 0 ||
873 nal_unit_type != FD_NUT)
874 return -EINVAL;
875
876 nal_hevc_read_filler_data(&rbsp);
877 rbsp_trailing_bits(&rbsp);
878
879 if (rbsp.error)
880 return rbsp.error;
881
882 return DIV_ROUND_UP(rbsp.pos, 8);
883 }
884 EXPORT_SYMBOL_GPL(nal_hevc_read_filler);
885