1 /*
2 * Copyright © Microsoft Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include "d3d12_video_encoder_bitstream_builder_hevc.h"
25 #include <cmath>
26
27 static uint8_t
convert_profile12_to_stdprofile(D3D12_VIDEO_ENCODER_PROFILE_HEVC profile)28 convert_profile12_to_stdprofile(D3D12_VIDEO_ENCODER_PROFILE_HEVC profile)
29 {
30 switch (profile)
31 {
32 case D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN:
33 {
34 return 1;
35 } break;
36 case D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN10:
37 {
38 return 2;
39 } break;
40 case D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN_444:
41 {
42 return 4;
43 } break;
44 default:
45 {
46 unreachable("Unsupported D3D12_VIDEO_ENCODER_PROFILE_HEVC value");
47 } break;
48 }
49 }
50
51 void
init_profile_tier_level(HEVCProfileTierLevel * ptl,uint8_t HEVCProfileIdc,uint8_t HEVCLevelIdc,bool isHighTier)52 d3d12_video_bitstream_builder_hevc::init_profile_tier_level(HEVCProfileTierLevel *ptl,
53 uint8_t HEVCProfileIdc,
54 uint8_t HEVCLevelIdc,
55 bool isHighTier)
56 {
57 memset(ptl, 0, sizeof(HEVCProfileTierLevel));
58
59 ptl->general_profile_space = 0; // must be 0
60 ptl->general_tier_flag = isHighTier ? 1 : 0;
61 ptl->general_profile_idc = HEVCProfileIdc;
62
63 memset(ptl->general_profile_compatibility_flag, 0, sizeof(ptl->general_profile_compatibility_flag));
64 ptl->general_profile_compatibility_flag[ptl->general_profile_idc] = 1;
65
66 ptl->general_progressive_source_flag = 1; // yes
67 ptl->general_interlaced_source_flag = 0; // no
68 ptl->general_non_packed_constraint_flag = 1; // no frame packing arrangement SEI messages
69 ptl->general_frame_only_constraint_flag = 1;
70 ptl->general_level_idc = HEVCLevelIdc;
71
72 if (ptl->general_profile_idc == 4 /*MAIN444*/)
73 {
74 ptl->general_intra_constraint_flag = 1;
75 ptl->general_max_12bit_constraint_flag = 1;
76 ptl->general_max_10bit_constraint_flag = 1;
77 ptl->general_max_8bit_constraint_flag = 1;
78 }
79 }
80
81 void
d3d12_video_encoder_convert_from_d3d12_level_hevc(D3D12_VIDEO_ENCODER_LEVELS_HEVC level12,uint32_t & specLevel)82 d3d12_video_encoder_convert_from_d3d12_level_hevc(D3D12_VIDEO_ENCODER_LEVELS_HEVC level12,
83 uint32_t &specLevel)
84 {
85 specLevel = 3u;
86 switch(level12)
87 {
88 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_1:
89 {
90 specLevel *= 10;
91 } break;
92 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_2:
93 {
94 specLevel *= 20;
95 } break;
96 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_21:
97 {
98 specLevel *= 21;
99 } break;
100 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_3:
101 {
102 specLevel *= 30;
103 } break;
104 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_31:
105 {
106 specLevel *= 31;
107 } break;
108 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_4:
109 {
110 specLevel *= 40;
111 } break;
112 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_41:
113 {
114 specLevel *= 41;
115 } break;
116 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_5:
117 {
118 specLevel *= 50;
119 } break;
120 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_51:
121 {
122 specLevel *= 51;
123 } break;
124 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_52:
125 {
126 specLevel *= 52;
127 } break;
128 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_6 :
129 {
130 specLevel *= 60;
131 } break;
132 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_61 :
133 {
134 specLevel *= 61;
135 } break;
136 case D3D12_VIDEO_ENCODER_LEVELS_HEVC_62 :
137 {
138 specLevel *= 62;
139 } break;
140 default:
141 {
142 unreachable("Unsupported D3D12_VIDEO_ENCODER_LEVELS_HEVC value");
143 } break;
144 }
145 }
146
147 D3D12_VIDEO_ENCODER_LEVELS_HEVC
d3d12_video_encoder_convert_level_hevc(uint32_t hevcSpecLevel)148 d3d12_video_encoder_convert_level_hevc(uint32_t hevcSpecLevel)
149 {
150 hevcSpecLevel = hevcSpecLevel / 3u;
151 switch(hevcSpecLevel)
152 {
153 case 10:
154 {
155 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_1;
156 } break;
157 case 20:
158 {
159 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_2;
160 } break;
161 case 21:
162 {
163 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_21;
164 } break;
165 case 30:
166 {
167 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_3;
168 } break;
169 case 31:
170 {
171 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_31;
172 } break;
173 case 40:
174 {
175 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_4;
176 } break;
177 case 41:
178 {
179 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_41;
180 } break;
181 case 50:
182 {
183 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_5;
184 } break;
185 case 51:
186 {
187 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_51;
188 } break;
189 case 52:
190 {
191 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_52;
192 } break;
193 case 60:
194 {
195 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_6;
196 } break;
197 case 61:
198 {
199 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_61;
200 } break;
201 case 62:
202 {
203 return D3D12_VIDEO_ENCODER_LEVELS_HEVC_62;
204 } break;
205 default:
206 {
207 unreachable("Unsupported D3D12_VIDEO_ENCODER_LEVELS_HEVC value");
208 } break;
209 }
210 }
211
212 uint8_t
d3d12_video_encoder_convert_12cusize_to_pixel_size_hevc(const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE & cuSize)213 d3d12_video_encoder_convert_12cusize_to_pixel_size_hevc(const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE& cuSize)
214 {
215 switch(cuSize)
216 {
217 case D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_8x8:
218 {
219 return 8u;
220 } break;
221 case D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_16x16:
222 {
223 return 16u;
224 } break;
225 case D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_32x32:
226 {
227 return 32u;
228 } break;
229 case D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_64x64:
230 {
231 return 64u;
232 } break;
233 default:
234 {
235 unreachable(L"Not a supported cu size");
236 return 0u;
237 } break;
238 }
239 }
240
241 D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE
d3d12_video_encoder_convert_pixel_size_hevc_to_12cusize(const uint32_t & cuSize)242 d3d12_video_encoder_convert_pixel_size_hevc_to_12cusize(const uint32_t& cuSize)
243 {
244 switch(cuSize)
245 {
246 case 8u:
247 {
248 return D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_8x8;
249 } break;
250 case 16u:
251 {
252 return D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_16x16;
253 } break;
254 case 32u:
255 {
256 return D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_32x32;
257 } break;
258 case 64u:
259 {
260 return D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_64x64;
261 } break;
262 default:
263 {
264 unreachable(L"Not a supported cu size");
265 } break;
266 }
267 }
268
269 uint8_t
d3d12_video_encoder_convert_12tusize_to_pixel_size_hevc(const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE & TUSize)270 d3d12_video_encoder_convert_12tusize_to_pixel_size_hevc(const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE& TUSize)
271 {
272 switch(TUSize)
273 {
274 case D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_4x4:
275 {
276 return 4u;
277 } break;
278 case D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_8x8:
279 {
280 return 8u;
281 } break;
282 case D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_16x16:
283 {
284 return 16u;
285 } break;
286 case D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_32x32:
287 {
288 return 32u;
289 } break;
290 default:
291 {
292 unreachable(L"Not a supported TU size");
293 } break;
294 }
295 }
296
297 D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE
d3d12_video_encoder_convert_pixel_size_hevc_to_12tusize(const uint32_t & TUSize)298 d3d12_video_encoder_convert_pixel_size_hevc_to_12tusize(const uint32_t& TUSize)
299 {
300 switch(TUSize)
301 {
302 case 4u:
303 {
304 return D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_4x4;
305 } break;
306 case 8u:
307 {
308 return D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_8x8;
309 } break;
310 case 16u:
311 {
312 return D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_16x16;
313 } break;
314 case 32u:
315 {
316 return D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_32x32;
317 } break;
318 default:
319 {
320 unreachable(L"Not a supported TU size");
321 } break;
322 }
323 }
324
325 HevcVideoParameterSet
build_vps(const struct pipe_h265_enc_vid_param & vidData,const D3D12_VIDEO_ENCODER_PROFILE_HEVC & profile,const D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC & level,const DXGI_FORMAT inputFmt,bool gopHasBFrames,uint8_t vps_video_parameter_set_id,std::vector<BYTE> & headerBitstream,std::vector<BYTE>::iterator placingPositionStart,size_t & writtenBytes)326 d3d12_video_bitstream_builder_hevc::build_vps(const struct pipe_h265_enc_vid_param & vidData,
327 const D3D12_VIDEO_ENCODER_PROFILE_HEVC& profile,
328 const D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC& level,
329 const DXGI_FORMAT inputFmt,
330 bool gopHasBFrames,
331 uint8_t vps_video_parameter_set_id,
332 std::vector<BYTE> &headerBitstream,
333 std::vector<BYTE>::iterator placingPositionStart,
334 size_t &writtenBytes)
335 {
336 uint8_t HEVCProfileIdc = convert_profile12_to_stdprofile(profile);
337 uint32_t HEVCLevelIdc = 0u;
338 d3d12_video_encoder_convert_from_d3d12_level_hevc(level.Level, HEVCLevelIdc);
339 bool isHighTier = (level.Tier == D3D12_VIDEO_ENCODER_TIER_HEVC_HIGH);
340
341 HevcVideoParameterSet m_latest_vps = {};
342 m_latest_vps.nalu = {
343 // forbidden_zero_bit
344 0u,
345 // nal_unit_type
346 HEVC_NALU_VPS_NUT,
347 // nuh_layer_id
348 0u,
349 // nuh_temporal_id_plus1
350 1u
351 };
352
353 m_latest_vps.vps_video_parameter_set_id = vps_video_parameter_set_id,
354 m_latest_vps.vps_reserved_three_2bits = 3u;
355 m_latest_vps.vps_max_layers_minus1 = 0u;
356 m_latest_vps.vps_max_sub_layers_minus1 = 0u;
357 m_latest_vps.vps_temporal_id_nesting_flag = 1u;
358 m_latest_vps.vps_reserved_0xffff_16bits = 0xFFFF;
359 init_profile_tier_level(&m_latest_vps.ptl, HEVCProfileIdc, HEVCLevelIdc, isHighTier);
360 m_latest_vps.vps_sub_layer_ordering_info_present_flag = 0u;
361 for (int i = (m_latest_vps.vps_sub_layer_ordering_info_present_flag ? 0 : m_latest_vps.vps_max_sub_layers_minus1); i <= m_latest_vps.vps_max_sub_layers_minus1; i++) {
362 m_latest_vps.vps_max_dec_pic_buffering_minus1[i] = vidData.vps_max_dec_pic_buffering_minus1[i];
363 m_latest_vps.vps_max_num_reorder_pics[i] = gopHasBFrames ? m_latest_vps.vps_max_dec_pic_buffering_minus1[i] : 0;
364 m_latest_vps.vps_max_latency_increase_plus1[i] = 0; // When vps_max_latency_increase_plus1[ i ] is equal to 0, no corresponding limit is expressed.
365 }
366
367 // Print built VPS structure
368 debug_printf("[HEVCBitstreamBuilder] HevcVideoParameterSet Structure generated before writing to bitstream:\n");
369 print_vps(m_latest_vps);
370
371 m_hevcEncoder.vps_to_nalu_bytes(&m_latest_vps, headerBitstream, placingPositionStart, writtenBytes);
372
373 return m_latest_vps;
374 }
375
376 HevcSeqParameterSet
build_sps(const HevcVideoParameterSet & parentVPS,const struct pipe_h265_enc_seq_param & seqData,uint8_t seq_parameter_set_id,const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC & encodeResolution,const D3D12_BOX & crop_window_upper_layer,const UINT picDimensionMultipleRequirement,const DXGI_FORMAT & inputFmt,const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC & codecConfig,const D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC & hevcGOP,std::vector<BYTE> & headerBitstream,std::vector<BYTE>::iterator placingPositionStart,size_t & writtenBytes)377 d3d12_video_bitstream_builder_hevc::build_sps(const HevcVideoParameterSet& parentVPS,
378 const struct pipe_h265_enc_seq_param & seqData,
379 uint8_t seq_parameter_set_id,
380 const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC& encodeResolution,
381 const D3D12_BOX& crop_window_upper_layer,
382 const UINT picDimensionMultipleRequirement,
383 const DXGI_FORMAT& inputFmt,
384 const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC& codecConfig,
385 const D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC& hevcGOP,
386 std::vector<BYTE> &headerBitstream,
387 std::vector<BYTE>::iterator placingPositionStart,
388 size_t &writtenBytes)
389 {
390 HevcSeqParameterSet m_latest_sps = {};
391
392 // In case is 420 10 bits
393 if(inputFmt == DXGI_FORMAT_P010)
394 {
395 m_latest_sps.bit_depth_luma_minus8 = 2;
396 m_latest_sps.bit_depth_chroma_minus8 = 2;
397 }
398
399 uint8_t minCuSize = d3d12_video_encoder_convert_12cusize_to_pixel_size_hevc(codecConfig.MinLumaCodingUnitSize);
400 uint8_t maxCuSize = d3d12_video_encoder_convert_12cusize_to_pixel_size_hevc(codecConfig.MaxLumaCodingUnitSize);
401 uint8_t minTuSize = d3d12_video_encoder_convert_12tusize_to_pixel_size_hevc(codecConfig.MinLumaTransformUnitSize);
402 uint8_t maxTuSize = d3d12_video_encoder_convert_12tusize_to_pixel_size_hevc(codecConfig.MaxLumaTransformUnitSize);
403
404 m_latest_sps.nalu.nal_unit_type = HEVC_NALU_SPS_NUT;
405 m_latest_sps.nalu.nuh_temporal_id_plus1 = 1;
406
407 m_latest_sps.sps_seq_parameter_set_id = seq_parameter_set_id;
408 m_latest_sps.sps_max_sub_layers_minus1 = parentVPS.vps_max_sub_layers_minus1;
409 m_latest_sps.sps_temporal_id_nesting_flag = parentVPS.vps_temporal_id_nesting_flag;
410
411 // inherit PTL from parentVPS fully
412 m_latest_sps.ptl = parentVPS.ptl;
413
414 m_latest_sps.chroma_format_idc = 1; // 420
415
416 // Codec spec dictates pic_width/height_in_luma_samples must be divisible by minCuSize but HW might have higher req pow 2 multiples
417 assert((picDimensionMultipleRequirement % minCuSize) == 0u);
418
419 // upper layer passes the viewport, can calculate the difference between it and pic_width_in_luma_samples
420 D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC viewport = { };
421 viewport.Width = crop_window_upper_layer.front /* passes height */ - ((crop_window_upper_layer.left + crop_window_upper_layer.right) << 1);
422 viewport.Height = crop_window_upper_layer.back /* passes width */- ((crop_window_upper_layer.top + crop_window_upper_layer.bottom) << 1);
423
424 m_latest_sps.pic_width_in_luma_samples = ALIGN(encodeResolution.Width, picDimensionMultipleRequirement);
425 m_latest_sps.pic_height_in_luma_samples = ALIGN(encodeResolution.Height, picDimensionMultipleRequirement);
426 m_latest_sps.conf_win_right_offset = (m_latest_sps.pic_width_in_luma_samples - viewport.Width) >> 1;
427 m_latest_sps.conf_win_bottom_offset = (m_latest_sps.pic_height_in_luma_samples - viewport.Height) >> 1;
428 m_latest_sps.conformance_window_flag = m_latest_sps.conf_win_left_offset || m_latest_sps.conf_win_right_offset || m_latest_sps.conf_win_top_offset || m_latest_sps.conf_win_bottom_offset;
429
430 m_latest_sps.log2_max_pic_order_cnt_lsb_minus4 = hevcGOP.log2_max_pic_order_cnt_lsb_minus4;
431 m_latest_sps.maxPicOrderCntLsb = 1 << (m_latest_sps.log2_max_pic_order_cnt_lsb_minus4 + 4);
432
433 m_latest_sps.sps_sub_layer_ordering_info_present_flag = parentVPS.vps_sub_layer_ordering_info_present_flag;
434 for (int i = (m_latest_sps.sps_sub_layer_ordering_info_present_flag ? 0 : m_latest_sps.sps_max_sub_layers_minus1); i <= m_latest_sps.sps_max_sub_layers_minus1; i++) {
435 m_latest_sps.sps_max_dec_pic_buffering_minus1[i] = parentVPS.vps_max_dec_pic_buffering_minus1[i];
436 m_latest_sps.sps_max_num_reorder_pics[i] = parentVPS.vps_max_num_reorder_pics[i];
437 m_latest_sps.sps_max_latency_increase_plus1[i] = parentVPS.vps_max_latency_increase_plus1[i];
438 }
439
440 m_latest_sps.log2_min_luma_coding_block_size_minus3 = static_cast<uint8_t>(std::log2(minCuSize) - 3);
441 m_latest_sps.log2_diff_max_min_luma_coding_block_size = static_cast<uint8_t>(std::log2(maxCuSize) - std::log2(minCuSize));
442 m_latest_sps.log2_min_transform_block_size_minus2 = static_cast<uint8_t>(std::log2(minTuSize) - 2);
443 m_latest_sps.log2_diff_max_min_transform_block_size = static_cast<uint8_t>(std::log2(maxTuSize) - std::log2(minTuSize));
444
445 m_latest_sps.max_transform_hierarchy_depth_inter = codecConfig.max_transform_hierarchy_depth_inter;
446 m_latest_sps.max_transform_hierarchy_depth_intra = codecConfig.max_transform_hierarchy_depth_intra;
447
448 m_latest_sps.scaling_list_enabled_flag = 0;
449 m_latest_sps.amp_enabled_flag = ((codecConfig.ConfigurationFlags & D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_ASYMETRIC_MOTION_PARTITION) != 0) ? 1u : 0u;
450 m_latest_sps.sample_adaptive_offset_enabled_flag = ((codecConfig.ConfigurationFlags & D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_SAO_FILTER) != 0) ? 1u : 0u;
451 m_latest_sps.pcm_enabled_flag = 0;
452
453 m_latest_sps.num_short_term_ref_pic_sets = 0;
454
455 m_latest_sps.long_term_ref_pics_present_flag = ((codecConfig.ConfigurationFlags & D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_LONG_TERM_REFERENCES) != 0) ? 1u : 0u;
456 m_latest_sps.num_long_term_ref_pics_sps = 0; // signal through slice header for now
457
458 m_latest_sps.sps_temporal_mvp_enabled_flag = 0;
459 m_latest_sps.strong_intra_smoothing_enabled_flag = 0;
460
461 m_latest_sps.vui_parameters_present_flag = seqData.vui_parameters_present_flag;
462 m_latest_sps.vui.aspect_ratio_idc = seqData.aspect_ratio_idc;
463 m_latest_sps.vui.sar_width = seqData.sar_width;
464 m_latest_sps.vui.sar_height = seqData.sar_height;
465 m_latest_sps.vui.video_format = seqData.video_format;
466 m_latest_sps.vui.video_full_range_flag = seqData.video_full_range_flag;
467 m_latest_sps.vui.colour_primaries = seqData.colour_primaries;
468 m_latest_sps.vui.transfer_characteristics = seqData.transfer_characteristics;
469 m_latest_sps.vui.matrix_coeffs = seqData.matrix_coefficients;
470 m_latest_sps.vui.chroma_sample_loc_type_top_field = seqData.chroma_sample_loc_type_top_field;
471 m_latest_sps.vui.chroma_sample_loc_type_bottom_field = seqData.chroma_sample_loc_type_bottom_field;
472 m_latest_sps.vui.def_disp_win_left_offset = seqData.def_disp_win_left_offset;
473 m_latest_sps.vui.def_disp_win_right_offset = seqData.def_disp_win_right_offset;
474 m_latest_sps.vui.def_disp_win_top_offset = seqData.def_disp_win_top_offset;
475 m_latest_sps.vui.def_disp_win_bottom_offset = seqData.def_disp_win_bottom_offset;
476 m_latest_sps.vui.num_units_in_tick = seqData.num_units_in_tick;
477 m_latest_sps.vui.time_scale = seqData.time_scale;
478 m_latest_sps.vui.num_ticks_poc_diff_one_minus1 = seqData.num_ticks_poc_diff_one_minus1;
479 m_latest_sps.vui.min_spatial_segmentation_idc = seqData.min_spatial_segmentation_idc;
480 m_latest_sps.vui.max_bytes_per_pic_denom = seqData.max_bytes_per_pic_denom;
481 m_latest_sps.vui.max_bits_per_min_cu_denom = seqData.max_bits_per_min_cu_denom;
482 m_latest_sps.vui.log2_max_mv_length_horizontal = seqData.log2_max_mv_length_horizontal;
483 m_latest_sps.vui.log2_max_mv_length_vertical = seqData.log2_max_mv_length_vertical;
484 m_latest_sps.vui.aspect_ratio_info_present_flag = seqData.vui_flags.aspect_ratio_info_present_flag;
485 m_latest_sps.vui.timing_info_present_flag = seqData.vui_flags.timing_info_present_flag;
486 m_latest_sps.vui.video_signal_type_present_flag = seqData.vui_flags.video_signal_type_present_flag;
487 m_latest_sps.vui.colour_description_present_flag = seqData.vui_flags.colour_description_present_flag;
488 m_latest_sps.vui.chroma_loc_info_present_flag = seqData.vui_flags.chroma_loc_info_present_flag;
489 m_latest_sps.vui.overscan_info_present_flag = seqData.vui_flags.overscan_info_present_flag;
490 m_latest_sps.vui.overscan_appropriate_flag = seqData.vui_flags.overscan_appropriate_flag;
491 m_latest_sps.vui.neutral_chroma_indication_flag = seqData.vui_flags.neutral_chroma_indication_flag;
492 m_latest_sps.vui.field_seq_flag = seqData.vui_flags.field_seq_flag;
493 m_latest_sps.vui.frame_field_info_present_flag = seqData.vui_flags.frame_field_info_present_flag;
494 m_latest_sps.vui.default_display_window_flag = seqData.vui_flags.default_display_window_flag;
495 m_latest_sps.vui.poc_proportional_to_timing_flag = seqData.vui_flags.poc_proportional_to_timing_flag;
496 m_latest_sps.vui.hrd_parameters_present_flag = seqData.vui_flags.hrd_parameters_present_flag;
497 m_latest_sps.vui.bitstream_restriction_flag = seqData.vui_flags.bitstream_restriction_flag;
498 m_latest_sps.vui.tiles_fixed_structure_flag = seqData.vui_flags.tiles_fixed_structure_flag;
499 m_latest_sps.vui.motion_vectors_over_pic_boundaries_flag = seqData.vui_flags.motion_vectors_over_pic_boundaries_flag;
500 m_latest_sps.vui.restricted_ref_pic_lists_flag = seqData.vui_flags.restricted_ref_pic_lists_flag;
501
502 m_latest_sps.sps_extension_present_flag = seqData.sps_range_extension.sps_range_extension_flag; // Set sps_extension_present_flag if sps_range_extension_flag present
503 if (m_latest_sps.sps_extension_present_flag)
504 {
505 m_latest_sps.sps_range_extension.sps_range_extension_flag = seqData.sps_range_extension.sps_range_extension_flag;
506 m_latest_sps.sps_range_extension.transform_skip_rotation_enabled_flag = seqData.sps_range_extension.transform_skip_rotation_enabled_flag;
507 m_latest_sps.sps_range_extension.transform_skip_context_enabled_flag = seqData.sps_range_extension.transform_skip_context_enabled_flag;
508 m_latest_sps.sps_range_extension.implicit_rdpcm_enabled_flag = seqData.sps_range_extension.implicit_rdpcm_enabled_flag;
509 m_latest_sps.sps_range_extension.explicit_rdpcm_enabled_flag = seqData.sps_range_extension.explicit_rdpcm_enabled_flag;
510 m_latest_sps.sps_range_extension.extended_precision_processing_flag = seqData.sps_range_extension.extended_precision_processing_flag;
511 m_latest_sps.sps_range_extension.intra_smoothing_disabled_flag = seqData.sps_range_extension.intra_smoothing_disabled_flag;
512 m_latest_sps.sps_range_extension.high_precision_offsets_enabled_flag = seqData.sps_range_extension.high_precision_offsets_enabled_flag;
513 m_latest_sps.sps_range_extension.persistent_rice_adaptation_enabled_flag = seqData.sps_range_extension.persistent_rice_adaptation_enabled_flag;
514 m_latest_sps.sps_range_extension.cabac_bypass_alignment_enabled_flag = seqData.sps_range_extension.cabac_bypass_alignment_enabled_flag;
515 }
516
517 // Print built SPS structure
518 debug_printf("[HEVCBitstreamBuilder] HevcSeqParameterSet Structure generated before writing to bitstream:\n");
519 print_sps(m_latest_sps);
520
521 m_hevcEncoder.sps_to_nalu_bytes(&m_latest_sps, headerBitstream, placingPositionStart, writtenBytes);
522
523 return m_latest_sps;
524 }
525
526 HevcPicParameterSet
build_pps(const struct pipe_h265_enc_pic_param & picData,const HevcSeqParameterSet & parentSPS,uint8_t pic_parameter_set_id,const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC & codecConfig,const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC1 & pictureControl,std::vector<BYTE> & headerBitstream,std::vector<BYTE>::iterator placingPositionStart,size_t & writtenBytes)527 d3d12_video_bitstream_builder_hevc::build_pps(const struct pipe_h265_enc_pic_param & picData,
528 const HevcSeqParameterSet& parentSPS,
529 uint8_t pic_parameter_set_id,
530 const D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC& codecConfig,
531 const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC1& pictureControl,
532 std::vector<BYTE> &headerBitstream,
533 std::vector<BYTE>::iterator placingPositionStart,
534 size_t &writtenBytes)
535 {
536 HevcPicParameterSet m_latest_pps = {};
537
538 m_latest_pps.nalu.nal_unit_type = HEVC_NALU_PPS_NUT;
539 m_latest_pps.nalu.nuh_temporal_id_plus1 = 1;
540
541 m_latest_pps.pps_pic_parameter_set_id = pic_parameter_set_id;
542 m_latest_pps.pps_seq_parameter_set_id = parentSPS.sps_seq_parameter_set_id;
543
544 m_latest_pps.weighted_pred_flag = 0u; // no weighted prediction in D3D12
545
546 m_latest_pps.num_ref_idx_lx_default_active_minus1[0] = static_cast<uint8_t>(std::max(static_cast<INT>(pictureControl.List0ReferenceFramesCount) - 1, 0));
547 m_latest_pps.num_ref_idx_lx_default_active_minus1[1] = static_cast<uint8_t>(std::max(static_cast<INT>(pictureControl.List1ReferenceFramesCount) - 1, 0));
548
549 m_latest_pps.num_tile_columns_minus1 = 0u; // no tiling in D3D12
550 m_latest_pps.num_tile_rows_minus1 = 0u; // no tiling in D3D12
551 m_latest_pps.tiles_enabled_flag = 0u; // no tiling in D3D12
552 m_latest_pps.loop_filter_across_tiles_enabled_flag = 0;
553
554 m_latest_pps.lists_modification_present_flag = 0;
555 m_latest_pps.log2_parallel_merge_level_minus2 = 0;
556
557 m_latest_pps.deblocking_filter_control_present_flag = 1;
558 m_latest_pps.deblocking_filter_override_enabled_flag = 0;
559 m_latest_pps.pps_deblocking_filter_disabled_flag = 0;
560 m_latest_pps.pps_scaling_list_data_present_flag = 0;
561 m_latest_pps.pps_beta_offset_div2 = 0;
562 m_latest_pps.pps_tc_offset_div2 = 0;
563 m_latest_pps.pps_loop_filter_across_slices_enabled_flag = ((codecConfig.ConfigurationFlags & D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_DISABLE_LOOP_FILTER_ACROSS_SLICES) != 0) ? 0 : 1;
564 m_latest_pps.transform_skip_enabled_flag = ((codecConfig.ConfigurationFlags & D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_TRANSFORM_SKIPPING) != 0) ? 1 : 0;
565 m_latest_pps.constrained_intra_pred_flag = ((codecConfig.ConfigurationFlags & D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_CONSTRAINED_INTRAPREDICTION) != 0) ? 1 : 0;
566 m_latest_pps.cabac_init_present_flag = 1;
567 m_latest_pps.pps_slice_chroma_qp_offsets_present_flag = 1;
568 m_latest_pps.cu_qp_delta_enabled_flag = 1;
569
570 m_latest_pps.pps_extension_present_flag = picData.pps_range_extension.pps_range_extension_flag; // Set pps_extension_present_flag if pps_range_extension_flag present
571 if (m_latest_pps.pps_extension_present_flag)
572 {
573 m_latest_pps.pps_range_extension.pps_range_extension_flag = picData.pps_range_extension.pps_range_extension_flag;
574
575 m_latest_pps.pps_range_extension.log2_max_transform_skip_block_size_minus2 = picData.pps_range_extension.log2_max_transform_skip_block_size_minus2;
576 m_latest_pps.pps_range_extension.cross_component_prediction_enabled_flag = picData.pps_range_extension.cross_component_prediction_enabled_flag;
577 m_latest_pps.pps_range_extension.chroma_qp_offset_list_enabled_flag = picData.pps_range_extension.chroma_qp_offset_list_enabled_flag;
578 m_latest_pps.pps_range_extension.diff_cu_chroma_qp_offset_depth = picData.pps_range_extension.diff_cu_chroma_qp_offset_depth;
579 m_latest_pps.pps_range_extension.chroma_qp_offset_list_len_minus1 = picData.pps_range_extension.chroma_qp_offset_list_len_minus1;
580 m_latest_pps.pps_range_extension.log2_sao_offset_scale_luma = picData.pps_range_extension.log2_sao_offset_scale_luma;
581 m_latest_pps.pps_range_extension.log2_sao_offset_scale_chroma = picData.pps_range_extension.log2_sao_offset_scale_chroma;
582 for (unsigned i = 0; i < ARRAY_SIZE(picData.pps_range_extension.cb_qp_offset_list); i++)
583 m_latest_pps.pps_range_extension.cb_qp_offset_list[i] = picData.pps_range_extension.cb_qp_offset_list[i];
584 for (unsigned i = 0; i < ARRAY_SIZE(picData.pps_range_extension.cr_qp_offset_list); i++)
585 m_latest_pps.pps_range_extension.cr_qp_offset_list[i] = picData.pps_range_extension.cr_qp_offset_list[i];
586 }
587
588 // Print built PPS structure
589 debug_printf("[HEVCBitstreamBuilder] HevcPicParameterSet Structure generated before writing to bitstream:\n");
590 print_pps(m_latest_pps);
591
592 m_hevcEncoder.pps_to_nalu_bytes(&m_latest_pps, headerBitstream, placingPositionStart, writtenBytes);
593
594 return m_latest_pps;
595 }
596
597 void
write_end_of_stream_nalu(std::vector<uint8_t> & headerBitstream,std::vector<uint8_t>::iterator placingPositionStart,size_t & writtenBytes)598 d3d12_video_bitstream_builder_hevc::write_end_of_stream_nalu(std::vector<uint8_t> & headerBitstream,
599 std::vector<uint8_t>::iterator placingPositionStart,
600 size_t & writtenBytes)
601 {
602 m_hevcEncoder.write_end_of_stream_nalu(headerBitstream, placingPositionStart, writtenBytes);
603 }
604 void
write_end_of_sequence_nalu(std::vector<uint8_t> & headerBitstream,std::vector<uint8_t>::iterator placingPositionStart,size_t & writtenBytes)605 d3d12_video_bitstream_builder_hevc::write_end_of_sequence_nalu(std::vector<uint8_t> & headerBitstream,
606 std::vector<uint8_t>::iterator placingPositionStart,
607 size_t & writtenBytes)
608 {
609 m_hevcEncoder.write_end_of_sequence_nalu(headerBitstream, placingPositionStart, writtenBytes);
610 }
611
612 void
write_aud(std::vector<uint8_t> & headerBitstream,std::vector<uint8_t>::iterator placingPositionStart,D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC frameType,size_t & writtenBytes)613 d3d12_video_bitstream_builder_hevc::write_aud(std::vector<uint8_t> & headerBitstream,
614 std::vector<uint8_t>::iterator placingPositionStart,
615 D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC frameType,
616 size_t & writtenBytes)
617 {
618 m_hevcEncoder.write_aud(headerBitstream, placingPositionStart, frameType, writtenBytes);
619 }
620
621 void
print_vps(const HevcVideoParameterSet & VPS)622 d3d12_video_bitstream_builder_hevc::print_vps(const HevcVideoParameterSet& VPS)
623 {
624 debug_printf("--------------------------------------\nHevcVideoParameterSet values below:\n");
625
626 debug_printf("vps_video_parameter_set_id: %d\n", VPS.vps_video_parameter_set_id);
627 debug_printf("vps_reserved_three_2bits: %d\n", VPS.vps_reserved_three_2bits);
628 debug_printf("vps_max_layers_minus1: %d\n", VPS.vps_max_layers_minus1);
629 debug_printf("vps_max_sub_layers_minus1: %d\n", VPS.vps_max_sub_layers_minus1);
630 debug_printf("vps_temporal_id_nesting_flag: %d\n", VPS.vps_temporal_id_nesting_flag);
631
632 debug_printf("general_profile_space: %d\n", VPS.ptl.general_profile_space);
633 debug_printf("general_tier_flag: %d\n", VPS.ptl.general_tier_flag);
634 debug_printf("general_profile_idc: %d\n", VPS.ptl.general_profile_idc);
635 debug_printf("general_progressive_source_flag: %d\n", VPS.ptl.general_progressive_source_flag);
636 debug_printf("general_interlaced_source_flag: %d\n", VPS.ptl.general_interlaced_source_flag);
637 debug_printf("general_non_packed_constraint_flag: %d\n", VPS.ptl.general_non_packed_constraint_flag);
638 debug_printf("general_frame_only_constraint_flag: %d\n", VPS.ptl.general_frame_only_constraint_flag);
639 debug_printf("general_level_idc: %d\n", VPS.ptl.general_level_idc);
640
641 debug_printf("vps_sub_layer_ordering_info_present_flag: %d\n", VPS.vps_sub_layer_ordering_info_present_flag);
642 debug_printf("vps_max_dec_pic_buffering_minus1[%d]: %d\n", (0u), VPS.vps_max_dec_pic_buffering_minus1[0u]);
643 debug_printf("vps_max_num_reorder_pics[%d]: %d\n", (0u), VPS.vps_max_num_reorder_pics[0u]);
644 debug_printf("vps_max_latency_increase_plus1[%d]: %d\n", (0u), VPS.vps_max_latency_increase_plus1[0u]);
645 debug_printf("vps_max_layer_id: %d\n", VPS.vps_max_layer_id);
646 debug_printf("vps_num_layer_sets_minus1: %d\n", VPS.vps_num_layer_sets_minus1);
647 debug_printf("vps_timing_info_present_flag: %d\n", VPS.vps_timing_info_present_flag);
648 debug_printf("vps_num_units_in_tick: %d\n", VPS.vps_num_units_in_tick);
649 debug_printf("vps_time_scale: %d\n", VPS.vps_time_scale);
650 debug_printf("vps_poc_proportional_to_timing_flag: %d\n", VPS.vps_poc_proportional_to_timing_flag);
651 debug_printf("vps_num_ticks_poc_diff_one_minus1: %d\n", VPS.vps_num_ticks_poc_diff_one_minus1);
652 debug_printf("vps_num_hrd_parameters: %d\n", VPS.vps_num_hrd_parameters);
653 debug_printf("vps_extension_flag: %d\n", VPS.vps_extension_flag);
654 debug_printf("vps_extension_data_flag: %d\n", VPS.vps_extension_data_flag);
655
656 debug_printf("HevcVideoParameterSet values end\n--------------------------------------\n");
657 }
658 void
print_sps(const HevcSeqParameterSet & SPS)659 d3d12_video_bitstream_builder_hevc::print_sps(const HevcSeqParameterSet& SPS)
660 {
661 debug_printf("--------------------------------------\nHevcSeqParameterSet values below:\n");
662
663 debug_printf("sps_video_parameter_set_id: %d\n", SPS.sps_video_parameter_set_id);
664 debug_printf("sps_max_sub_layers_minus1: %d\n", SPS.sps_max_sub_layers_minus1);
665 debug_printf("sps_temporal_id_nesting_flag: %d\n", SPS.sps_temporal_id_nesting_flag);
666
667 debug_printf("general_profile_space: %d\n", SPS.ptl.general_profile_space);
668 debug_printf("general_tier_flag: %d\n", SPS.ptl.general_tier_flag);
669 debug_printf("general_profile_idc: %d\n", SPS.ptl.general_profile_idc);
670 debug_printf("general_progressive_source_flag: %d\n", SPS.ptl.general_progressive_source_flag);
671 debug_printf("general_interlaced_source_flag: %d\n", SPS.ptl.general_interlaced_source_flag);
672 debug_printf("general_non_packed_constraint_flag: %d\n", SPS.ptl.general_non_packed_constraint_flag);
673 debug_printf("general_frame_only_constraint_flag: %d\n", SPS.ptl.general_frame_only_constraint_flag);
674 debug_printf("general_level_idc: %d\n", SPS.ptl.general_level_idc);
675
676 debug_printf("sps_seq_parameter_set_id: %d\n", SPS.sps_seq_parameter_set_id);
677 debug_printf("chroma_format_idc: %d\n", SPS.chroma_format_idc);
678 debug_printf("separate_colour_plane_flag: %d\n", SPS.separate_colour_plane_flag);
679 debug_printf("pic_width_in_luma_samples: %d\n", SPS.pic_width_in_luma_samples);
680 debug_printf("pic_height_in_luma_samples: %d\n", SPS.pic_height_in_luma_samples);
681 debug_printf("conformance_window_flag: %d\n", SPS.conformance_window_flag);
682 debug_printf("conf_win_left_offset: %d\n", SPS.conf_win_left_offset);
683 debug_printf("conf_win_right_offset: %d\n", SPS.conf_win_right_offset);
684 debug_printf("conf_win_top_offset: %d\n", SPS.conf_win_top_offset);
685 debug_printf("conf_win_bottom_offset: %d\n", SPS.conf_win_bottom_offset);
686 debug_printf("bit_depth_luma_minus8: %d\n", SPS.bit_depth_luma_minus8);
687 debug_printf("bit_depth_chroma_minus8: %d\n", SPS.bit_depth_chroma_minus8);
688 debug_printf("log2_max_pic_order_cnt_lsb_minus4: %d\n", SPS.log2_max_pic_order_cnt_lsb_minus4);
689 debug_printf("maxPicOrderCntLsb: %d\n", SPS.maxPicOrderCntLsb);
690 debug_printf("sps_sub_layer_ordering_info_present_flag: %d\n", SPS.sps_sub_layer_ordering_info_present_flag);
691
692 debug_printf("sps_max_dec_pic_buffering_minus1[%d]: %d\n", (0u), SPS.sps_max_dec_pic_buffering_minus1[0u]);
693 debug_printf("sps_max_num_reorder_pics[%d]: %d\n", (0u), SPS.sps_max_num_reorder_pics[0u]);
694 debug_printf("sps_max_latency_increase_plus1[%d]: %d\n", (0u), SPS.sps_max_latency_increase_plus1[0u]);
695
696 debug_printf("log2_min_luma_coding_block_size_minus3: %d\n", SPS.log2_min_luma_coding_block_size_minus3);
697 debug_printf("log2_diff_max_min_luma_coding_block_size: %d\n", SPS.log2_diff_max_min_luma_coding_block_size);
698 debug_printf("log2_min_transform_block_size_minus2: %d\n", SPS.log2_min_transform_block_size_minus2);
699 debug_printf("log2_diff_max_min_transform_block_size: %d\n", SPS.log2_diff_max_min_transform_block_size);
700 debug_printf("max_transform_hierarchy_depth_inter: %d\n", SPS.max_transform_hierarchy_depth_inter);
701 debug_printf("max_transform_hierarchy_depth_intra: %d\n", SPS.max_transform_hierarchy_depth_intra);
702 debug_printf("scaling_list_enabled_flag: %d\n", SPS.scaling_list_enabled_flag);
703 debug_printf("sps_scaling_list_data_present_flag: %d\n", SPS.sps_scaling_list_data_present_flag);
704 debug_printf("amp_enabled_flag: %d\n", SPS.amp_enabled_flag);
705 debug_printf("sample_adaptive_offset_enabled_flag: %d\n", SPS.sample_adaptive_offset_enabled_flag);
706 debug_printf("pcm_enabled_flag: %d\n", SPS.pcm_enabled_flag);
707 debug_printf("pcm_sample_bit_depth_luma_minus1: %d\n", SPS.pcm_sample_bit_depth_luma_minus1);
708 debug_printf("pcm_sample_bit_depth_chroma_minus1: %d\n", SPS.pcm_sample_bit_depth_chroma_minus1);
709 debug_printf("log2_min_pcm_luma_coding_block_size_minus3: %d\n", SPS.log2_min_pcm_luma_coding_block_size_minus3);
710 debug_printf("log2_diff_max_min_pcm_luma_coding_block_size: %d\n", SPS.log2_diff_max_min_pcm_luma_coding_block_size);
711 debug_printf("pcm_loop_filter_disabled_flag: %d\n", SPS.pcm_loop_filter_disabled_flag);
712 debug_printf("num_short_term_ref_pic_sets: %d\n", SPS.num_short_term_ref_pic_sets);
713
714 for(UINT idx = 0; idx < SPS.num_short_term_ref_pic_sets ; idx++)
715 {
716 print_rps(&SPS, idx);
717 }
718
719 debug_printf("long_term_ref_pics_present_flag: %d\n", SPS.long_term_ref_pics_present_flag);
720 debug_printf("num_long_term_ref_pics_sps: %d\n", SPS.num_long_term_ref_pics_sps);
721
722 for(UINT idx = 0; idx < SPS.num_long_term_ref_pics_sps ; idx++)
723 {
724 debug_printf("lt_ref_pic_poc_lsb_sps[%d]: %d\n", idx, SPS.lt_ref_pic_poc_lsb_sps[idx]);
725 debug_printf("used_by_curr_pic_lt_sps_flag[%d]: %d\n", idx, SPS.used_by_curr_pic_lt_sps_flag[idx]);
726 }
727
728 debug_printf("sps_temporal_mvp_enabled_flag: %d\n", SPS.sps_temporal_mvp_enabled_flag);
729 debug_printf("strong_intra_smoothing_enabled_flag: %d\n", SPS.strong_intra_smoothing_enabled_flag);
730 debug_printf("vui_parameters_present_flag: %d\n", SPS.vui_parameters_present_flag);
731 debug_printf("aspect_ratio_info_present_flag: %d\n", SPS.vui.aspect_ratio_info_present_flag);
732 debug_printf("aspect_ratio_idc: %d\n", SPS.vui.aspect_ratio_idc);
733 debug_printf("sar_width: %d\n", SPS.vui.sar_width);
734 debug_printf("sar_height: %d\n", SPS.vui.sar_height);
735 debug_printf("overscan_info_present_flag: %d\n", SPS.vui.overscan_info_present_flag);
736 debug_printf("overscan_appropriate_flag: %d\n", SPS.vui.overscan_appropriate_flag);
737 debug_printf("video_signal_type_present_flag: %d\n", SPS.vui.video_signal_type_present_flag);
738 debug_printf("video_format: %d\n", SPS.vui.video_format);
739 debug_printf("video_full_range_flag: %d\n", SPS.vui.video_full_range_flag);
740 debug_printf("colour_description_present_flag: %d\n", SPS.vui.colour_description_present_flag);
741 debug_printf("colour_primaries: %d\n", SPS.vui.colour_primaries);
742 debug_printf("transfer_characteristics: %d\n", SPS.vui.transfer_characteristics);
743 debug_printf("matrix_coeffs: %d\n", SPS.vui.matrix_coeffs);
744 debug_printf("chroma_loc_info_present_flag: %d\n", SPS.vui.chroma_loc_info_present_flag);
745 debug_printf("chroma_sample_loc_type_top_field: %d\n", SPS.vui.chroma_sample_loc_type_top_field);
746 debug_printf("chroma_sample_loc_type_bottom_field: %d\n", SPS.vui.chroma_sample_loc_type_bottom_field);
747 debug_printf("neutral_chroma_indication_flag: %d\n", SPS.vui.neutral_chroma_indication_flag);
748 debug_printf("field_seq_flag: %d\n", SPS.vui.field_seq_flag);
749 debug_printf("frame_field_info_present_flag: %d\n", SPS.vui.frame_field_info_present_flag);
750 debug_printf("default_display_window_flag: %d\n", SPS.vui.default_display_window_flag);
751 debug_printf("def_disp_win_left_offset: %d\n", SPS.vui.def_disp_win_left_offset);
752 debug_printf("def_disp_win_right_offset: %d\n", SPS.vui.def_disp_win_right_offset);
753 debug_printf("def_disp_win_top_offset: %d\n", SPS.vui.def_disp_win_top_offset);
754 debug_printf("def_disp_win_bottom_offset: %d\n", SPS.vui.def_disp_win_bottom_offset);
755 debug_printf("timing_info_present_flag: %d\n", SPS.vui.timing_info_present_flag);
756 debug_printf("num_units_in_tick: %d\n", SPS.vui.num_units_in_tick);
757 debug_printf("time_scale: %d\n", SPS.vui.time_scale);
758 debug_printf("poc_proportional_to_timing_flag: %d\n", SPS.vui.poc_proportional_to_timing_flag);
759 debug_printf("num_ticks_poc_diff_one_minus1: %d\n", SPS.vui.num_ticks_poc_diff_one_minus1);
760 debug_printf("hrd_parameters_present_flag: %d\n", SPS.vui.hrd_parameters_present_flag);
761 debug_printf("bitstream_restriction_flag: %d\n", SPS.vui.bitstream_restriction_flag);
762 debug_printf("tiles_fixed_structure_flag: %d\n", SPS.vui.tiles_fixed_structure_flag);
763 debug_printf("motion_vectors_over_pic_boundaries_flag: %d\n", SPS.vui.motion_vectors_over_pic_boundaries_flag);
764 debug_printf("restricted_ref_pic_lists_flag: %d\n", SPS.vui.restricted_ref_pic_lists_flag);
765 debug_printf("min_spatial_segmentation_idc: %d\n", SPS.vui.min_spatial_segmentation_idc);
766 debug_printf("max_bytes_per_pic_denom: %d\n", SPS.vui.max_bytes_per_pic_denom);
767 debug_printf("max_bits_per_min_cu_denom: %d\n", SPS.vui.max_bits_per_min_cu_denom);
768 debug_printf("log2_max_mv_length_horizontal: %d\n", SPS.vui.log2_max_mv_length_horizontal);
769 debug_printf("log2_max_mv_length_vertical: %d\n", SPS.vui.log2_max_mv_length_vertical);
770 debug_printf("sps_extension_present_flag: %d\n", SPS.sps_extension_present_flag);
771 debug_printf("sps_extension_data_flag: %d\n", SPS.sps_extension_data_flag);
772
773 debug_printf("HevcSeqParameterSet values end\n--------------------------------------\n");
774 }
775 void
print_pps(const HevcPicParameterSet & PPS)776 d3d12_video_bitstream_builder_hevc::print_pps(const HevcPicParameterSet& PPS)
777 {
778 debug_printf("--------------------------------------\nHevcPicParameterSet values below:\n");
779 debug_printf("pps_pic_parameter_set_id: %d\n", PPS.pps_pic_parameter_set_id);
780 debug_printf("pps_seq_parameter_set_id: %d\n", PPS.pps_seq_parameter_set_id);
781 debug_printf("dependent_slice_segments_enabled_flag: %d\n", PPS.dependent_slice_segments_enabled_flag);
782 debug_printf("output_flag_present_flag: %d\n", PPS.output_flag_present_flag);
783 debug_printf("num_extra_slice_header_bits: %d\n", PPS.num_extra_slice_header_bits);
784 debug_printf("sign_data_hiding_enabled_flag: %d\n", PPS.sign_data_hiding_enabled_flag);
785 debug_printf("cabac_init_present_flag: %d\n", PPS.cabac_init_present_flag);
786 debug_printf("num_ref_idx_l0_default_active_minus1: %d\n", PPS.num_ref_idx_lx_default_active_minus1[0]);
787 debug_printf("num_ref_idx_l1_default_active_minus1: %d\n", PPS.num_ref_idx_lx_default_active_minus1[1]);
788 debug_printf("init_qp_minus26: %d\n", PPS.init_qp_minus26);
789 debug_printf("constrained_intra_pred_flag: %d\n", PPS.constrained_intra_pred_flag);
790 debug_printf("transform_skip_enabled_flag: %d\n", PPS.transform_skip_enabled_flag);
791 debug_printf("cu_qp_delta_enabled_flag: %d\n", PPS.cu_qp_delta_enabled_flag);
792 debug_printf("diff_cu_qp_delta_depth: %d\n", PPS.diff_cu_qp_delta_depth);
793 debug_printf("pps_cb_qp_offset: %d\n", PPS.pps_cb_qp_offset);
794 debug_printf("pps_cr_qp_offset: %d\n", PPS.pps_cr_qp_offset);
795 debug_printf("pps_slice_chroma_qp_offsets_present_flag: %d\n", PPS.pps_slice_chroma_qp_offsets_present_flag);
796 debug_printf("weighted_pred_flag: %d\n", PPS.weighted_pred_flag);
797 debug_printf("weighted_bipred_flag: %d\n", PPS.weighted_bipred_flag);
798 debug_printf("transquant_bypass_enabled_flag: %d\n", PPS.transquant_bypass_enabled_flag);
799 debug_printf("tiles_enabled_flag: %d\n", PPS.tiles_enabled_flag);
800 debug_printf("entropy_coding_sync_enabled_flag: %d\n", PPS.entropy_coding_sync_enabled_flag);
801 debug_printf("num_tile_columns_minus1: %d\n", PPS.num_tile_columns_minus1);
802 debug_printf("num_tile_rows_minus1: %d\n", PPS.num_tile_rows_minus1);
803 debug_printf("uniform_spacing_flag: %d\n", PPS.uniform_spacing_flag);
804 debug_printf("column_width_minus1[0]: %d\n", PPS.column_width_minus1[0]); // no tiles in D3D12)
805 debug_printf("row_height_minus1[0]: %d\n", PPS.row_height_minus1[0]); // no tiles in D3D12)
806 debug_printf("loop_filter_across_tiles_enabled_flag: %d\n", PPS.loop_filter_across_tiles_enabled_flag);
807 debug_printf("pps_loop_filter_across_slices_enabled_flag: %d\n", PPS.pps_loop_filter_across_slices_enabled_flag);
808 debug_printf("deblocking_filter_control_present_flag: %d\n", PPS.deblocking_filter_control_present_flag);
809 debug_printf("deblocking_filter_override_enabled_flag: %d\n", PPS.deblocking_filter_override_enabled_flag);
810 debug_printf("pps_deblocking_filter_disabled_flag: %d\n", PPS.pps_deblocking_filter_disabled_flag);
811 debug_printf("pps_beta_offset_div2: %d\n", PPS.pps_beta_offset_div2);
812 debug_printf("pps_tc_offset_div2: %d\n", PPS.pps_tc_offset_div2);
813 debug_printf("pps_scaling_list_data_present_flag: %d\n", PPS.pps_scaling_list_data_present_flag);
814 debug_printf("lists_modification_present_flag: %d\n", PPS.lists_modification_present_flag);
815 debug_printf("log2_parallel_merge_level_minus2: %d\n", PPS.log2_parallel_merge_level_minus2);
816 debug_printf("slice_segment_header_extension_present_flag: %d\n", PPS.slice_segment_header_extension_present_flag);
817 debug_printf("pps_extension_present_flag: %d\n", PPS.pps_extension_present_flag);
818 debug_printf("pps_extension_data_flag: %d\n", PPS.pps_extension_data_flag);
819 debug_printf("HevcPicParameterSet values end\n--------------------------------------\n");
820 }
821
822 void
print_rps(const HevcSeqParameterSet * sps,UINT stRpsIdx)823 d3d12_video_bitstream_builder_hevc::print_rps(const HevcSeqParameterSet* sps, UINT stRpsIdx)
824 {
825 const HEVCReferencePictureSet* rps = &(sps->rpsShortTerm[stRpsIdx]);
826
827 debug_printf("--------------------------------------\nHEVCReferencePictureSet[%d] values below:\n", stRpsIdx);
828
829 debug_printf("inter_ref_pic_set_prediction_flag: %d\n", rps->inter_ref_pic_set_prediction_flag);
830
831 if(rps->inter_ref_pic_set_prediction_flag)
832 {
833 debug_printf("delta_idx_minus1: %d\n", rps->delta_idx_minus1);
834 debug_printf("delta_rps_sign: %d\n", rps->delta_rps_sign);
835 debug_printf("abs_delta_rps_minus1: %d\n", rps->abs_delta_rps_minus1);
836 debug_printf("num_negative_pics: %d\n", rps->num_negative_pics);
837 debug_printf("num_positive_pics: %d\n", rps->num_positive_pics);
838
839 int32_t RefRpsIdx = stRpsIdx - 1 - rps->delta_idx_minus1;
840 const HEVCReferencePictureSet* rpsRef = &(sps->rpsShortTerm[RefRpsIdx]);
841 auto numberOfPictures = rpsRef->num_negative_pics + rpsRef->num_positive_pics;
842 for (uint8_t j = 0; j <= numberOfPictures; j++) {
843 debug_printf("used_by_curr_pic_flag[%d]: %d\n", j, rps->used_by_curr_pic_flag[j]);
844 if (!rps->used_by_curr_pic_flag[j]) {
845 debug_printf("use_delta_flag[%d]: %d\n", j, rps->use_delta_flag[j]);
846 }
847 }
848 }
849 else
850 {
851 debug_printf("num_negative_pics: %d\n", rps->num_negative_pics);
852 for (uint8_t i = 0; i < rps->num_negative_pics; i++) {
853 debug_printf("delta_poc_s0_minus1[%d]: %d\n", i, rps->delta_poc_s0_minus1[i]);
854 debug_printf("used_by_curr_pic_s0_flag[%d]: %d\n", i, rps->used_by_curr_pic_s0_flag[i]);
855 }
856
857 debug_printf("num_positive_pics: %d\n", rps->num_positive_pics);
858 for (int32_t i = 0; i < rps->num_positive_pics; i++) {
859 debug_printf("delta_poc_s1_minus1[%d]: %d\n", i, rps->delta_poc_s1_minus1[i]);
860 debug_printf("used_by_curr_pic_s1_flag[%d]: %d\n", i, rps->used_by_curr_pic_s1_flag[i]);
861 }
862 }
863
864 debug_printf("HEVCReferencePictureSet values end\n--------------------------------------\n");
865 }
866