Cogs.Core
H265Parser.cpp
1#include "H265Data.h"
2#include "Parser.h"
3
4#include <string>
5
6// #define PRINT_NALU
7
8namespace Cogs::Core{
9
10#if 0
11static std::string parse_st(const uint8_t * /*data*/, size_t &bit)
12{
13 assert(bit % 8 == 0);
14 assert(false);
15 return "";
16}
17
18static void byte_aligned()
19{
20}
21
22static void more_data_in_byte_stream()
23{
24}
25
26static void more_data_in_payload()
27{
28}
29
30static void more_rbsp_trailing_data()
31{
32}
33
34static void payload_extension_present()
35{
36}
37
38static void ppic_layer_id()
39{
40}
41#endif
42
43static void rbsp_trailing_bits(const uint8_t *data, size_t &bit)
44{
45 uint32_t rbsp_stop_one_bit = parse_u(1, data, bit);
46 assert(rbsp_stop_one_bit == 0x1);
47 while(bit%8 != 0){
48 uint32_t rbsp_alignment_zero_bit = parse_u(1, data, bit);
49 assert(rbsp_alignment_zero_bit == 0x0);
50 }
51}
52
53void profile_tier_level(H265ProfileTierLevel &tier, const uint8_t *data, size_t &bit, uint32_t profilePresentFlag, uint32_t maxNumSubLayersMinus1)
54{
55 tier = {};
56 tier.profilePresentFlag = profilePresentFlag;
57 tier.maxNumSubLayersMinus1 = maxNumSubLayersMinus1;
58
59 if(profilePresentFlag){
60 tier.general_profile_space = parse_u(2, data, bit);
61 tier.general_tier_flag = parse_u(1, data, bit);
62 tier.general_profile_idc = parse_u(5, data, bit);
63
64 for(uint32_t i=0; i<32; i++)
65 tier.general_profile_compatibility_flags =
66 (tier.general_profile_compatibility_flags<<1) | parse_u(1, data, bit);
67 //tier.general_profile_compatibility_flags = parse_u(32, data, bit);
68
69 tier.general_progressive_source_flag = parse_u(1, data, bit);
70 tier.general_interlaced_source_glag = parse_u(1, data, bit);
71 tier.general_non_packed_constraint_flag = parse_u(1, data, bit);
72 tier.general_frame_only_constraint_flag = parse_u(1, data, bit);
73
74 if(tier.general_profile_idc == 4 || tier.general_profile_compatibility_flags&(0x80000000>>4) ||
75 tier.general_profile_idc == 5 || tier.general_profile_compatibility_flags&(0x80000000>>5) ||
76 tier.general_profile_idc == 6 || tier.general_profile_compatibility_flags&(0x80000000>>6) ||
77 tier.general_profile_idc == 7 || tier.general_profile_compatibility_flags&(0x80000000>>7) ||
78 tier.general_profile_idc == 8 || tier.general_profile_compatibility_flags&(0x80000000>>8) ||
79 tier.general_profile_idc == 9 || tier.general_profile_compatibility_flags&(0x80000000>>9) ||
80 tier.general_profile_idc == 10 || tier.general_profile_compatibility_flags&(0x80000000>>10) ||
81 tier.general_profile_idc == 11 || tier.general_profile_compatibility_flags&(0x80000000>>11)){
82 tier.general_max_12bit_constraint_flag = parse_u(1, data, bit);
83 tier.general_max_10bit_constraint_flag = parse_u(1, data, bit);
84 tier.general_max_8bit_constraint_flag = parse_u(1, data, bit);
85 tier.general_max_422chroma_constraint_flag = parse_u(1, data, bit);
86 tier.general_max_420chroma_constraint_flag = parse_u(1, data, bit);
87 tier.general_max_monochrome_constraint_flag = parse_u(1, data, bit);
88 tier.general_intra_constraint_flag = parse_u(1, data, bit);
89 tier.general_on_picture_only_constraint_flag = parse_u(1, data, bit);
90 tier.general_lower_bit_rate_constraint_flag = parse_u(1, data, bit);
91 if(tier.general_profile_idc == 5 || tier.general_profile_compatibility_flags&(0x80000000>>5) ||
92 tier.general_profile_idc == 9 || tier.general_profile_compatibility_flags&(0x80000000>>9) ||
93 tier.general_profile_idc == 10 || tier.general_profile_compatibility_flags&(0x80000000>>10) ||
94 tier.general_profile_idc == 11 || tier.general_profile_compatibility_flags&(0x80000000>>11)){
95 tier.general_max_14bit_constraint_flag = parse_u(1, data, bit);
96 uint32_t zero = parse_u(32, data, bit); // zero bits (33)
97 assert(zero == 0);
98 zero = parse_u(1, data, bit); // zero bits (33)
99 assert(zero == 0);
100 }
101 else{
102 uint32_t zero = parse_u(32, data, bit); // zero bits (34)
103 assert(zero == 0);
104 zero = parse_u(2, data, bit); // zero bits (34)
105 assert(zero == 0);
106 }
107 }
108 else if(tier.general_profile_idc == 2 || tier.general_profile_compatibility_flags&(0x80000000>>2)){
109 uint32_t zero = parse_u(7, data, bit); // zero bits
110 assert(zero == 0);
111 tier.general_one_picture_only_constraint_flag = parse_u(1, data, bit);
112 zero = parse_u(32, data, bit); // zero bits (35)
113 assert(zero == 0);
114 zero = parse_u(3, data, bit); // zero bits (35)
115 assert(zero == 0);
116 }
117 else{
118 uint32_t zero = parse_u(32, data, bit); // zero bits (43)
119 assert(zero == 0);
120 zero = parse_u(11, data, bit); // zero bits (43)
121 assert(zero == 0);
122 }
123 if(tier.general_profile_idc == 1 || tier.general_profile_compatibility_flags&(0x80000000>>1) ||
124 tier.general_profile_idc == 2 || tier.general_profile_compatibility_flags&(0x80000000>>2) ||
125 tier.general_profile_idc == 3 || tier.general_profile_compatibility_flags&(0x80000000>>3) ||
126 tier.general_profile_idc == 4 || tier.general_profile_compatibility_flags&(0x80000000>>4) ||
127 tier.general_profile_idc == 5 || tier.general_profile_compatibility_flags&(0x80000000>>5) ||
128 tier.general_profile_idc == 9 || tier.general_profile_compatibility_flags&(0x80000000>>9) ||
129 tier.general_profile_idc == 11 || tier.general_profile_compatibility_flags&(0x80000000>>11)){
130 tier.general_inbld_flag = parse_u(1, data, bit);
131 }
132 else{
133 uint32_t zero = parse_u(1, data, bit); // zero bit
134 assert(zero == 0);
135 }
136 }
137
138 tier.general_level_idc = parse_u(8, data, bit);
139 // vid bit 128
140
141 for(uint32_t i=0; i<maxNumSubLayersMinus1; i++){
142 tier.sub_layer_profile_present_flag[i] = parse_u(1, data, bit);
143 tier.sub_layer_level_present_flag[i] = parse_u(1, data, bit);
144 }
145 if(maxNumSubLayersMinus1>0){
146 for(uint32_t i=maxNumSubLayersMinus1; i<8; i++){
147 // uint32_t zero = parse_u(2, data, bit); // zero bits
148 // assert(zero == 0); // TODO
149 }
150 }
151
152 for(uint32_t i=0; i<maxNumSubLayersMinus1; i++){
153 if(tier.sub_layer_profile_present_flag[i]){
154 tier.sub_layer_profile_space[i] = parse_u(2, data, bit);
155 tier.sub_layer_tier_flag[i] = parse_u(1, data, bit);
156 tier.sub_layer_profile_idc[i] = parse_u(5, data, bit);
157
158 for(uint32_t j=0; j<32; j++)
159 tier.sub_layer_profile_compatibility_flags[i] =
160 (tier.sub_layer_profile_compatibility_flags[i]<<1) | parse_u(1, data, bit);
161
162 tier.sub_layer_progressive_source_flag[i] = parse_u(1, data, bit);
163 tier.sub_layer_interlaced_source_flag[i] = parse_u(1, data, bit);
164 tier.sub_layer_non_packed_constraint_flag[i] = parse_u(1, data, bit);
165 tier.sub_layer_frame_only_constraint_flag[i] = parse_u(1, data, bit);
166 if(tier.sub_layer_profile_idc[i] == 4 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>4) ||
167 tier.sub_layer_profile_idc[i] == 5 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>5) ||
168 tier.sub_layer_profile_idc[i] == 6 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>6) ||
169 tier.sub_layer_profile_idc[i] == 7 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>7) ||
170 tier.sub_layer_profile_idc[i] == 8 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>8) ||
171 tier.sub_layer_profile_idc[i] == 9 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>9) ||
172 tier.sub_layer_profile_idc[i] == 10 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>10) ||
173 tier.sub_layer_profile_idc[i] == 11 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>11)){
174 tier.sub_layer_max_12bit_constraint_flag[i] = parse_u(1, data, bit);
175 tier.sub_layer_max_10bit_constraint_flag[i] = parse_u(1, data, bit);
176 tier.sub_layer_max_8bit_constraint_flag[i] = parse_u(1, data, bit);
177 tier.sub_layer_max_422chroma_constraint_flag[i] = parse_u(1, data, bit);
178 tier.sub_layer_max_420chroma_constraint_flag[i] = parse_u(1, data, bit);
179 tier.sub_layer_max_monochrome_constraint_flag[i] = parse_u(1, data, bit);
180 tier.sub_layer_intra_constraint_flag[i] = parse_u(1, data, bit);
181 tier.sub_layer_one_picture_only_constraint_flag[i] = parse_u(1, data, bit);
182 tier.sub_layer_lower_bit_rate_constraint_flag[i] = parse_u(1, data, bit);
183 if(tier.sub_layer_profile_idc[i] == 5 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>5) ||
184 tier.sub_layer_profile_idc[i] == 9 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>9) ||
185 tier.sub_layer_profile_idc[i] == 10 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>10) ||
186 tier.sub_layer_profile_idc[i] == 11 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>11)){
187 tier.sub_layer_max_14bit_constraint_flag[i] = parse_u(1, data, bit);
188 uint32_t zero = parse_u(32, data, bit); // zero bits (33)
189 assert(zero == 0);
190 zero = parse_u(1, data, bit); // zero bits (33)
191 assert(zero == 0);
192 }
193 else{
194 uint32_t zero = parse_u(32, data, bit); // zero bits (34)
195 assert(zero == 0);
196 zero = parse_u(2, data, bit); // zero bits (34)
197 assert(zero == 0);
198 }
199 }
200 else if(tier.sub_layer_profile_idc[i] == 2 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>2)){
201 uint32_t zero = parse_u(7, data, bit); // zero bits
202 assert(zero == 0);
203 tier.sub_layer_inbld_flag[i] = parse_u(1, data, bit);
204 zero = parse_u(32, data, bit); // zero bits (35)
205 assert(zero == 0);
206 zero = parse_u(3, data, bit); // zero bits (35)
207 assert(zero == 0);
208 }
209 else{
210 uint32_t zero = parse_u(32, data, bit); // zero bits (43)
211 assert(zero == 0);
212 zero = parse_u(11, data, bit); // zero bits (43)
213 assert(zero == 0);
214 }
215 if(tier.sub_layer_profile_idc[i] == 1 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>1) ||
216 tier.sub_layer_profile_idc[i] == 2 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>2) ||
217 tier.sub_layer_profile_idc[i] == 3 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>3) ||
218 tier.sub_layer_profile_idc[i] == 4 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>4) ||
219 tier.sub_layer_profile_idc[i] == 5 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>5) ||
220 tier.sub_layer_profile_idc[i] == 9 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>9) ||
221 tier.sub_layer_profile_idc[i] == 11 || tier.sub_layer_profile_compatibility_flags[i]&(0x80000000>>11)){
222 tier.sub_layer_inbld_flag[i] = parse_u(1, data, bit);
223 }
224 else{
225 uint32_t zero = parse_u(1, data, bit);
226 assert(zero == 0);
227 }
228 }
229 if(tier.sub_layer_level_present_flag[i]){
230 tier.sub_layer_level_idc[i] = parse_u(8, data, bit);
231 }
232 }
233}
234
235void hrd_parameters(const uint8_t * /*data*/, size_t /*size*/,
236 uint32_t commonInfPresentFlag, uint32_t maxNumbSubLayersMinus1)
237{
238 if(commonInfPresentFlag){
239 assert(false);
240 }
241 for(uint32_t i=0; i<maxNumbSubLayersMinus1; i++){
242 assert(false);
243 }
244}
245
246void video_parameter_set_rbsp(H265ParseData &parse, const uint8_t *data, size_t size)
247{
248#ifdef PRINT_NALU
249 printf("video_data:");
250 for(uint32_t i=0; i<size; i++){
251 if(i%8 == 0) printf("\n");
252 printf("0x%02x ", data[i]);
253 }
254 printf("\n");
255#endif
256
257 H265VideoParameterSet &set(parse.video_set);
258 set = {};
259 size_t bit = 0;
260
261 set.vps_video_parameter_set_id = parse_u(4, data, bit);
262 set.vps_base_layer_internal_flag = parse_u(1, data, bit);
263 set.vps_base_layer_available_flag = parse_u(1, data, bit);
264 set.vps_max_layers_minus1 = parse_u(6, data, bit);
265 set.vps_max_sub_layers_minus1 = parse_u(3, data, bit);
266 set.vps_temporal_id_nesting_flag = parse_u(1, data, bit);
267 uint32_t vps_reserved_0xffff_16_bits = parse_u(16, data, bit);
268 assert(vps_reserved_0xffff_16_bits == 0xffff);
269
270 profile_tier_level(set.tier, data, bit, 1, set.vps_max_sub_layers_minus1);
271
272 set.vps_sub_layer_ordering_info_present_flag = parse_u(1, data, bit);
273 for(uint32_t i=(set.vps_sub_layer_ordering_info_present_flag?0:set.vps_max_sub_layers_minus1);
274 i<=set.vps_max_sub_layers_minus1; i++){
275 set.vps_max_dec_pic_buffering_minus1[i] = parse_ue(data, bit);
276 set.vps_max_num_reorder_pics[i] = parse_ue(data, bit);
277 set.vps_max_latency_increase_plus1[i] = parse_ue(data, bit);
278 }
279
280 set.vps_max_layer_id = parse_u(6, data, bit);
281 set.vps_num_layer_sets_minus1 = parse_ue(data, bit);
282 for(uint32_t i=1; i<= set.vps_num_layer_sets_minus1; i++){
283 for(uint32_t j=0; j<set.vps_max_layer_id; j++){
284 //set.layer_id_included_flag[i][j] =
285 parse_u(1, data, bit);
286 }
287 }
288
289 // VPS Timing Info
290 set.vps_timing_info_present_flag = parse_u(1, data, bit);
291 if(set.vps_timing_info_present_flag){
292 set.vps_num_units_in_tick = parse_u(32, data, bit);
293 set.vps_time_scale = parse_u(32, data, bit);
294 set.vps_poc_proportional_to_timing_flag = parse_u(1, data, bit);
295 if(set.vps_poc_proportional_to_timing_flag){
296 set.vps_num_ticks_poc_diff_one_minus1 = parse_ue(data, bit);
297 }
298 set.vps_num_hrd_parameters = parse_ue(data, bit);
299 for(uint32_t i=0; i<set.vps_num_hrd_parameters; i++){
300 set.hrd_layer_set_idx[i] = parse_ue(data, bit);
301 if(i > 0){
302 set.cprms_present_flag[i] = parse_u(1, data, bit);
303 }
304 hrd_parameters(data, size, set.cprms_present_flag[i], set.vps_max_sub_layers_minus1);
305 }
306 }
307
308 // VPS Extension
309 uint32_t vps_extension_flag = parse_u(1, data, bit);
310 if(vps_extension_flag){
311 while(more_rbsp_data(data, size, bit)){
312 //uint32_t vps_extension_data_flag =
313 parse_u(1, data, bit);
314 }
315 }
316
317 rbsp_trailing_bits(data, bit);
318}
319
320void seq_parameter_set_rbsp(H265ParseData &parse, const uint8_t *data, size_t size)
321{
322#ifdef PRINT_NALU
323 printf("seq_data:");
324 for(uint32_t i=0; i<size; i++){
325 if(i%8 == 0) printf("\n");
326 printf("0x%02x ", data[i]);
327 }
328 printf("\n");
329#endif
330
331 H265SeqParameterSet &set(parse.seq_set);
332 set = {};
333 size_t bit = 0;
334
335 set.sps_video_parameter_set_id = parse_u(4, data, bit);
336 set.sps_max_sub_layers_minus1 = parse_u(3, data, bit);
337 set.sps_temporal_id_nesting_flag = parse_u(1, data, bit);
338
339 profile_tier_level(set.tier, data, bit, 1, set.sps_max_sub_layers_minus1);
340
341 set.sps_seq_parameter_set_id = parse_ue(data, bit);
342 set.chroma_format_idc = parse_ue(data, bit);
343 if(set.chroma_format_idc == 3)
344 set.separate_colour_plane_flag = parse_u(1, data, bit);
345 set.pic_width_in_luma_samples = parse_ue(data, bit);
346 set.pic_height_in_luma_samples = parse_ue(data, bit);
347 set.conformance_window_flag = parse_u(1, data, bit);
348
349 if(set.conformance_window_flag){
350 set.conf_win_left_offset = parse_ue(data, bit);
351 set.conf_win_right_offset = parse_ue(data, bit);
352 set.conf_win_top_offset = parse_ue(data, bit);
353 set.conf_win_bottom_offset = parse_ue(data, bit);
354 }
355
356 set.bit_depth_luma_minus8 = parse_ue(data, bit);
357 set.bit_depth_chroma_minus8 = parse_ue(data, bit);
358 set.log2_max_pic_order_cnt_lsb_minus4 = parse_ue(data, bit);
359 set.sps_sub_layer_ordering_info_present_flag = parse_u(1, data, bit);
360
361 assert(set.sps_max_sub_layers_minus1 < sizeof(set.sps_max_dec_pic_buffering_minus1)/sizeof(set.sps_max_dec_pic_buffering_minus1[0]));
362 for(uint32_t i = (set.sps_sub_layer_ordering_info_present_flag?0:set.sps_max_sub_layers_minus1);
363 i<=set.sps_max_sub_layers_minus1; i++){
364 set.sps_max_dec_pic_buffering_minus1[i] = parse_ue(data, bit);
365 set.sps_max_num_reorder_pics[i] = parse_ue(data, bit);
366 set.sps_max_latency_increase_plus1[i] = parse_ue(data, bit);
367 }
368
369 set.log2_min_luma_coding_block_size_minus3 = parse_ue(data, bit);
370 set.log2_diff_max_min_luma_coding_block_size = parse_ue(data, bit);
371 set.log2_min_luma_transform_block_size_minus2 = parse_ue(data, bit);
372 set.log2_diff_max_min_luma_transform_block_size = parse_ue(data, bit);
373
374 set.max_tranform_hierarchy_depth_inter = parse_ue(data, bit);
375 set.max_tranform_hierarchy_depth_intra = parse_ue(data, bit);
376 set.scaling_list_enabled_flag = parse_u(1, data, bit);
377 if(set.scaling_list_enabled_flag){
378 set.sps_scaling_list_data_present_flag = parse_u(1, data, bit);
379 if(set.sps_scaling_list_data_present_flag){
380 return; // TODO
381 // assert(false); // scaling_list_data
382 }
383 }
384
385 set.amp_enabled_flag = parse_u(1, data, bit);
386 set.sample_adaptive_offset_enabled_flag = parse_u(1, data, bit);
387 set.pcm_enabled_flag = parse_u(1, data, bit);
388 if(set.pcm_enabled_flag){
389 set.pcm_sample_bit_depth_luma_minus1 = parse_u(4, data, bit);
390 set.pcm_sample_bit_depth_chroma_minus1 = parse_u(4, data, bit);
391 set.log2_min_pcm_luma_coding_block_size_minus3 = parse_ue(data, bit);
392 set.log2_idff_max_min_pcm_luma_coding_block_size = parse_ue(data, bit);
393 set.pcm_loop_filter_disabled_flag = parse_u(1, data, bit);
394 }
395
396 set.num_short_term_ref_pic_sets = parse_ue(data, bit);
397 if(set.num_short_term_ref_pic_sets)
398 return; // TODO
399 // for(uint32_t i=0; i<set.num_short_term_ref_pic_sets; i++){
400 // assert(false); // st_ref_pic_set
401 // }
402
403 set.long_term_ref_pic_present_flag = parse_u(1, data, bit);
404 if(set.long_term_ref_pic_present_flag){
405 set.num_long_term_ref_pics_sps = parse_ue(data, bit);
406 for(uint32_t i=0; i<set.num_long_term_ref_pics_sps; i++){
407 assert(false); //set.lt_ref_pic_poc_lsb_sps[i] = parse_uv();
408 set.used_by_cuff_pic_lt_sps_flag[i] = parse_u(1, data, bit);
409 }
410 }
411
412 set.sps_temporarl_mvp_enabled_flag = parse_u(1, data, bit);
413 set.string_intra_smoothing_enabled_flag = parse_u(1, data, bit);
414
415 set.vui_parameters_present_flag = parse_u(1, data, bit);
416 if(set.vui_parameters_present_flag){
417 H265VuiParameters &vui(parse.vui);
418 // Sample Aspect Ratio (SAR)
419 vui.aspect_ratio_info_present = parse_u(1, data, bit);
420 if(vui.aspect_ratio_info_present){
421 uint32_t aspect_ratio_idc = parse_u(8, data, bit);
422 uint32_t aspect_ratio_width[255] = {
423 1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2
424 };
425 uint32_t aspect_ratio_height[255] = {
426 1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1
427 };
428 if(aspect_ratio_idc == 255){ // Extended_SAR
429 vui.sar_width = parse_u(16, data, bit);
430 vui.sar_height = parse_u(16, data, bit);
431 }
432 else{
433 assert(aspect_ratio_idc<=16);
434 vui.sar_width = aspect_ratio_width[aspect_ratio_idc];
435 vui.sar_height = aspect_ratio_height[aspect_ratio_idc];
436 }
437 }
438 // Overscan Info
439 vui.overscan_info_present_flag = parse_u(1, data, bit);
440 if(vui.overscan_info_present_flag){
441 vui.overscan_appropriate_flag = parse_u(1, data, bit);
442 }
443 // Video Signal Type
444 vui.video_signal_type_present_flag = parse_u(1, data, bit);
445 if(vui.video_signal_type_present_flag){
446 vui.video_format = parse_u(3, data, bit);
447 vui.video_full_range_flag = parse_u(1, data, bit);
448 vui.colour_description_present_flag = parse_u(1, data, bit);
449 if(vui.colour_description_present_flag){
450 vui.colour_primaries = parse_u(8, data, bit);
451 vui.transfer_characteristics = parse_u(8, data, bit);
452 vui.matrix_coefficients = parse_u(8, data, bit);
453 }
454 }
455 // Chroma Location Info
456 vui.chroma_loc_info_present_flag = parse_u(1, data, bit);
457 if(vui.chroma_loc_info_present_flag){
458 vui.chroma_sample_loc_type_top_field = parse_ue(data, bit);
459 vui.chroma_sample_loc_type_bottom_field = parse_ue(data, bit);
460 }
461
462 vui.neutral_chroma_indication_flag = parse_u(1, data, bit);
463 vui.field_seq_flag = parse_u(1, data, bit);
464 vui.frame_field_info_present_flag = parse_u(1, data, bit);
465
466 // Default Display Window
467 vui.default_display_window_flag = parse_u(1, data, bit);
468 if(vui.default_display_window_flag){
469 vui.def_disp_win_left_offset = parse_ue(data, bit);
470 vui.def_disp_win_right_offset = parse_ue(data, bit);
471 vui.def_disp_win_top_offset = parse_ue(data, bit);
472 vui.def_disp_win_bottom_offset = parse_ue(data, bit);
473 }
474
475 // Timing Information
476 vui.vui_timing_info_present_flag = parse_u(1, data, bit);
477 if(vui.vui_timing_info_present_flag){
478 vui.vui_num_units_in_tick = parse_u(32, data, bit);
479 vui.vui_time_scale = parse_u(32, data, bit);
480 vui.vui_poc_proportional_to_timing_flag = parse_u(1, data, bit);
481 if(vui.vui_poc_proportional_to_timing_flag)
482 vui.vui_num_ticks_poc_diff_one_minus1 = parse_ue(data, bit);
483 vui.vui_hrd_parameters_present_flag = parse_u(1, data, bit);
484 if(vui.vui_hrd_parameters_present_flag)
485 assert(false); // HrdParameters hrd; // TODO
486 }
487
488 // Bitstream restriction parameters
489 vui.bitstream_restriction_flag = parse_u(1, data, bit);
490 if(vui.bitstream_restriction_flag){
491 vui.tiles_fixed_structure_flag = parse_u(1, data, bit);
492 vui.motion_vectors_over_pic_boundaries_flag = parse_u(1, data, bit);
493 vui.restricted_ref_pic_lists_flag = parse_u(1, data, bit);
494 vui.min_spatial_segmentation_idc = parse_ue(data, bit);
495 vui.max_bytes_per_pic_denom = parse_ue(data, bit);
496 vui.max_bits_per_min_cu_denom = parse_ue(data, bit);
497 vui.log2_max_mv_length_horizontal = parse_ue(data, bit);
498 vui.log2_max_mv_length_vertical = parse_ue(data, bit);
499 }
500 }
501
502 set.sps_extension_present_flag = parse_u(1, data, bit);
503 if(set.sps_extension_present_flag){
504 set.sps_range_extension_flag = parse_u(1, data, bit);
505 set.sps_multilayer_extension_flag = parse_u(1, data, bit);
506 set.sps_3d_extension_flag = parse_u(1, data, bit);
507 set.sps_scc_extenion_flag = parse_u(1, data, bit);
508 set.sps_extension_4bits = parse_u(4, data, bit);
509 }
510
511 if(set.sps_extension_present_flag){
512 assert(false); // sps_range_extension
513 }
514 if(set.sps_multilayer_extension_flag){
515 assert(false); // sps_multilayer_extenssion_flag
516 }
517 if(set.sps_3d_extension_flag){
518 assert(false); // sps_3d_extension
519 }
520 if(set.sps_scc_extenion_flag){
521 assert(false); // sps_scc_extension
522 }
523 if(set.sps_extension_4bits){
524 while(more_rbsp_data(data, size, bit)){
525 parse_u(1, data, bit);
526 }
527 }
528
529 rbsp_trailing_bits(data, bit);
530}
531
532void pic_parameter_set_rbsp(H265ParseData &parse, uint8_t *data, size_t size)
533{
534#ifdef PRINT_NALU
535 printf("pps_data:");
536 for(uint32_t i=0; i<size; i++){
537 if(i%8 == 0) printf("\n");
538 printf("0x%02x ", data[i]);
539 }
540 printf("\n");
541#else
542 (void)data;
543 (void)size;
544#endif
545
546 H265PicParameterSet &set(parse.pic_set);
547 set = {};
548 //size_t bit = 0;
549}
550
551void video_parameter_set_nalu(H265ParseData &parse, const uint8_t *data, size_t size)
552{
553#ifdef PRINT_NALU
554 printf("vps_nalu:");
555 for(uint32_t i=0; i<size; i++){
556 if(i%8 == 0) printf("\n");
557 printf("0x%02x ", data[i]);
558 }
559 printf("\n");
560#endif
561 size_t i=0;
562
563 // NAL header
564 size_t bit = i*8;
565 i = i+2;
566 H265NALheader header = {};
567 header.forbidden_zero_bit = parse_f(1, data, bit);
568 assert(header.forbidden_zero_bit == 0);
569 header.type = parse_u(6, data, bit);
570 header.layerId0 = parse_u(1, data, bit);
571 header.layerId1 = parse_u(5, data, bit);
572 header.TID = parse_u(3, data, bit);
573 assert(header.type == 32);
574
575 size_t rbsp_size = size-2;
576 uint32_t NumBytesInRBSP = 0;
577 uint8_t *rbsp = new uint8_t[rbsp_size];
578
579 size_t j=size;
580 while(i<j){
581 if(i+2 < j && data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x03){
582 rbsp[NumBytesInRBSP++] = data[i++];
583 rbsp[NumBytesInRBSP++] = data[i++];
584 i++;
585 }
586 else{
587 rbsp[NumBytesInRBSP++] = data[i++];
588 }
589 assert(NumBytesInRBSP <= rbsp_size);
590 }
591
592 video_parameter_set_rbsp(parse, rbsp, NumBytesInRBSP);
593
594 delete[] rbsp;
595}
596
597void seq_parameter_set_nalu(H265ParseData &parse, const uint8_t *data, size_t size)
598{
599#ifdef PRINT_NALU
600 printf("sps_nalu:");
601 for(uint32_t i=0; i<size; i++){
602 if(i%8 == 0) printf("\n");
603 printf("0x%02x ", data[i]);
604 }
605 printf("\n");
606#endif
607 size_t i=0;
608
609 // NAL header
610 size_t bit = i*8;
611 i = i+2;
612 H265NALheader header = {};
613 header.forbidden_zero_bit = parse_f(1, data, bit);
614 assert(header.forbidden_zero_bit == 0);
615 header.type = parse_u(6, data, bit);
616 header.layerId0 = parse_u(1, data, bit);
617 header.layerId1 = parse_u(5, data, bit);
618 header.TID = parse_u(3, data, bit);
619 assert(header.type == 33);
620
621 size_t rbsp_size = size-2;
622 uint32_t NumBytesInRBSP = 0;
623 uint8_t *rbsp = new uint8_t[rbsp_size];
624
625 size_t j=size;
626 while(i<j){
627 if(i+2 < j && data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x03){
628 rbsp[NumBytesInRBSP++] = data[i++];
629 rbsp[NumBytesInRBSP++] = data[i++];
630 i++;
631 }
632 else{
633 rbsp[NumBytesInRBSP++] = data[i++];
634 }
635 assert(NumBytesInRBSP <= rbsp_size);
636 }
637
638 seq_parameter_set_rbsp(parse, rbsp, NumBytesInRBSP);
639
640 delete[] rbsp;
641}
642
643void pic_parameter_set_nalu(H265ParseData &parse, const uint8_t *data, size_t size)
644{
645#ifdef PRINT_NALU
646 printf("pps_nalu:");
647 for(uint32_t i=0; i<size; i++){
648 if(i%8 == 0) printf("\n");
649 printf("0x%02x ", data[i]);
650 }
651 printf("\n");
652#endif
653 size_t i=0;
654
655 // NAL header
656 size_t bit = i*8;
657 i = i+2;
658 H265NALheader header = {};
659 header.forbidden_zero_bit = parse_f(1, data, bit);
660 assert(header.forbidden_zero_bit == 0);
661 header.type = parse_u(6, data, bit);
662 header.layerId0 = parse_u(1, data, bit);
663 header.layerId1 = parse_u(5, data, bit);
664 header.TID = parse_u(3, data, bit);
665 assert(header.type == 34);
666
667 size_t rbsp_size = size-2;
668 uint32_t NumBytesInRBSP = 0;
669 uint8_t *rbsp = new uint8_t[rbsp_size];
670
671 size_t j=size;
672 while(i<j){
673 if(i+2 < j && data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x03){
674 rbsp[NumBytesInRBSP++] = data[i++];
675 rbsp[NumBytesInRBSP++] = data[i++];
676 i++;
677 }
678 else{
679 rbsp[NumBytesInRBSP++] = data[i++];
680 }
681 assert(NumBytesInRBSP <= rbsp_size);
682 }
683
684 pic_parameter_set_rbsp(parse, rbsp, NumBytesInRBSP);
685
686 delete[] rbsp;
687}
688
689void byte_stream_nal_unit(H265ParseData &parse, const uint8_t *data, size_t size)
690{
691#ifdef PRINT_NALU
692 printf("nalu:");
693 for(uint32_t i=0; i<size; i++){
694 if(i%8 == 0) printf("\n");
695 printf("0x%02x ", data[i]);
696 }
697 printf("\n");
698#endif
699
700 size_t i=0;
701 // Remove leading zero
702 while(!(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x00 && data[i+3] == 0x01) &&
703 !(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x01)){
704 assert(data[i] == 0x00);
705 i++;
706 }
707
708 while(i <= size){
709 // NAL Start prefix
710 if(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x00 && data[i+3] == 0x01){
711 i += 4;
712 }
713 else{
714 assert(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x01);
715 i += 3;
716 }
717
718 // NAL header
719 size_t bit = i*8;
720 i = i+2;
721 H265NALheader header = {};
722 header.forbidden_zero_bit = parse_f(1, data, bit);
723 assert(header.forbidden_zero_bit == 0);
724 header.type = parse_u(6, data, bit);
725 header.layerId0 = parse_u(1, data, bit);
726 header.layerId1 = parse_u(5, data, bit);
727 header.TID = parse_u(3, data, bit);
728
729 // Find next NALU
730 size_t j=i;
731 while(!(data[j+0] == 0x00 && data[j+1] == 0x00 && data[j+2] == 0x00 && data[j+3] == 0x01) &&
732 !(data[j+0] == 0x00 && data[j+1] == 0x00 && data[j+2] == 0x01) &&
733 j < size){
734 j++;
735 }
736 size_t rbsp_size = j-i;
737
738 uint32_t NumBytesInRBSP = 0;
739 if(header.type >= 32 && header.type <= 34){
740 uint8_t *rbsp = new uint8_t[rbsp_size];
741 while(i<j){
742 if(i+2 < j && data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x03){
743 rbsp[NumBytesInRBSP++] = data[i++];
744 rbsp[NumBytesInRBSP++] = data[i++];
745 i++;
746 }
747 else{
748 rbsp[NumBytesInRBSP++] = data[i++];
749 }
750 assert(NumBytesInRBSP <= rbsp_size);
751 }
752
753 switch(header.type){
754 case 32:
755 video_parameter_set_rbsp(parse, rbsp, NumBytesInRBSP);
756 break;
757 case 33:
758 seq_parameter_set_rbsp(parse, rbsp, NumBytesInRBSP);
759 break;
760 case 34:
761 pic_parameter_set_rbsp(parse, rbsp, NumBytesInRBSP);
762 break;
763 case 35: // Access unit delimiter
764 break;
765 case 36: // End of sequence
766 break;
767 case 37: // End of Bitstream
768 break;
769 case 38: // Filler data
770 break;
771 case 39: // SEI
772 case 40:
773 break;
774 }
775
776 delete[] rbsp;
777 }
778
779 i=j;
780 if(i == size) break;
781 }
782}
783
784void extract_spspps(const uint8_t *data, size_t size, std::string &vps, std::string &sps, std::string &pps)
785{
786 size_t i=0;
787 // Remove leading zero
788 while(!(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x00 && data[i+3] == 0x01) &&
789 !(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x01)){
790 assert(data[i] == 0x00);
791 i++;
792 }
793
794 while(i < size){
795 // NAL Start prefix
796 if(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x00 && data[i+3] == 0x01){
797 i += 4;
798 }
799 else{
800 assert(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x01);
801 i += 3;
802 }
803
804 // NAL header
805 size_t bit = i*8;
806 // i = i+2;
807 H265NALheader header = {};
808 header.forbidden_zero_bit = parse_f(1, data, bit);
809 assert(header.forbidden_zero_bit == 0);
810 header.type = parse_u(6, data, bit);
811 header.layerId0 = parse_u(1, data, bit);
812 header.layerId1 = parse_u(5, data, bit);
813 header.TID = parse_u(3, data, bit);
814
815 // Find next NALU
816 size_t j=i;
817 while(!(data[j+0] == 0x00 && data[j+1] == 0x00 && data[j+2] == 0x00 && data[j+3] == 0x01) &&
818 !(data[j+0] == 0x00 && data[j+1] == 0x00 && data[j+2] == 0x01) &&
819 j < size){
820 j++;
821 }
822 size_t rbsp_size = j-i;
823
824 switch(header.type){
825 case 32:
826 vps = std::string((char*)&data[i], rbsp_size);
827 if (!sps.empty() && !pps.empty()) {
828 return;
829 }
830 break;
831 case 33:
832 sps = std::string((char*)&data[i], rbsp_size);
833 if (!vps.empty() && !pps.empty()) {
834 return;
835 }
836 break;
837 case 34:
838 pps = std::string((char*)&data[i], rbsp_size);
839 if (!vps.empty() && !sps.empty()) {
840 return;
841 }
842 break;
843 }
844 i=j;
845 }
846}
847
848bool COGSCORE_DLL_API extract_nalu_header(H265NALheader &header, const uint8_t *data, size_t size)
849{
850 size_t i=0;
851 if(i+3 >= size) return false;
852 // Remove leading zero
853 while(!(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x00 && data[i+3] == 0x01) &&
854 !(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x01)){
855 if(data[i] != 0x00) return false;
856 i++;
857 if(i+3 >= size) return false;
858 }
859
860 // NAL Start prefix
861 if(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x00 && data[i+3] == 0x01){
862 i += 4;
863 }
864 else if(data[i+0] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x01){
865 i += 3;
866 }
867 else{
868 return false;
869 }
870
871 // NAL header
872 size_t bit = i*8;
873 header.forbidden_zero_bit = parse_f(1, data, bit);
874 if(header.forbidden_zero_bit != 0) return false;
875 header.type = parse_u(6, data, bit);
876 header.layerId0 = parse_u(1, data, bit);
877 header.layerId1 = parse_u(5, data, bit);
878 header.TID = parse_u(3, data, bit);
879 return true;
880}
881
882}// namespace ...
Cogs::Core
Contains the Engine, Renderer, resource managers and other systems needed to run Cogs....
Definition: ComponentFunctions.h:10
Generated by doxygen 1.9.6