1 /*
2 *
3 * Copyright 2015 Rockchip Electronics Co. LTD
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 #define MODULE_TAG "H265E_SYNTAX"
19
20 #include <string.h>
21
22 #include "h265e_codec.h"
23 #include "h265e_syntax_new.h"
24
h265e_get_nal_type(H265eSlicParams * sp,RK_S32 frame_type)25 RK_S32 h265e_get_nal_type(H265eSlicParams* sp, RK_S32 frame_type)
26 {
27 RK_U32 nal_type = 0;
28
29 if (sp->temporal_id > 0) {
30 nal_type = sp->non_reference_flag ? NAL_TSA_N : NAL_TSA_R;
31 } else if (frame_type == INTRA_FRAME) {
32 nal_type = NAL_IDR_W_RADL;
33 } else {
34 nal_type = sp->non_reference_flag ? NAL_TRAIL_N : NAL_TRAIL_R;
35 }
36
37 return nal_type;
38 }
39
fill_picture_parameters(const H265eCtx * h,H265ePicParams * pp)40 static void fill_picture_parameters(const H265eCtx *h,
41 H265ePicParams *pp)
42 {
43 const H265ePps *pps = (H265ePps *)&h->pps;
44 const H265eSps *sps = (H265eSps *)&h->sps;
45 MppEncCfgSet *cfg = h->cfg;
46 memset(pp, 0, sizeof(H265ePicParams));
47
48 pp->pic_width = h->cfg->prep.width;
49 pp->pic_height = h->cfg->prep.height;
50 pp->hor_stride = h->cfg->prep.hor_stride;
51 pp->ver_stride = h->cfg->prep.ver_stride;
52 pp->pps_id = h->slice->m_ppsId;
53 pp->sps_id = pps->m_SPSId;
54 pp->vps_id = sps->m_VPSId;
55 pp->mpp_format = cfg->prep.format;
56
57 pp->wFormatAndSequenceInfoFlags = (sps->m_chromaFormatIdc << 0) |
58 (sps->m_colorPlaneFlag << 2) |
59 ((sps->m_bitDepthY - 8) << 3) |
60 ((sps->m_bitDepthC - 8) << 6) |
61 ((sps->m_bitsForPOC - 4) << 9) |
62 (0 << 13) |
63 (0 << 14) |
64 (0 << 15);
65
66
67 pp->sps_max_dec_pic_buffering_minus1 = sps->m_maxDecPicBuffering[sps->m_maxTLayers - 1] - 1;
68 pp->log2_min_luma_coding_block_size_minus3 = sps->m_log2MinCodingBlockSize - 3;
69 pp->log2_diff_max_min_luma_coding_block_size = sps->m_log2DiffMaxMinCodingBlockSize;
70
71 pp->log2_min_transform_block_size_minus2 = sps->m_quadtreeTULog2MinSize - 2;
72 pp->log2_diff_max_min_transform_block_size = sps->m_quadtreeTULog2MaxSize - sps->m_quadtreeTULog2MinSize;
73
74 pp->max_transform_hierarchy_depth_inter = sps->m_quadtreeTUMaxDepthInter;
75 pp->max_transform_hierarchy_depth_intra = sps->m_quadtreeTUMaxDepthIntra;
76
77 pp->num_short_term_ref_pic_sets = sps->m_RPSList.m_numberOfReferencePictureSets;
78 pp->num_long_term_ref_pics_sps = sps->m_numLongTermRefPicSPS;
79
80 pp->sample_adaptive_offset_enabled_flag = sps->m_bUseSAO;
81
82 pp->num_ref_idx_l0_default_active_minus1 = pps->m_numRefIdxL0DefaultActive - 1;
83 pp->num_ref_idx_l1_default_active_minus1 = pps->m_numRefIdxL1DefaultActive - 1;
84 pp->init_qp_minus26 = pps->m_picInitQPMinus26;
85
86
87 pp->CodingParamToolFlags = (sps->m_scalingListEnabledFlag << 0) |
88 (sps->m_useAMP << 1) |
89 (sps->m_bUseSAO << 2) |
90 (sps->m_usePCM << 3) |
91 ((sps->m_usePCM ? (sps->m_pcmBitDepthLuma - 1) : 0) << 4) |
92 ((sps->m_usePCM ? (sps->m_pcmBitDepthChroma - 1) : 0) << 8) |
93 ((sps->m_usePCM ? (sps->m_pcmLog2MinSize - 3) : 0) << 12) |
94 ((sps->m_usePCM ? (sps->m_pcmLog2MaxSize - sps->m_pcmLog2MinSize) : 0) << 14) |
95 (sps->m_bPCMFilterDisableFlag << 16) |
96 (sps->m_bLongTermRefsPresent << 17) |
97 (sps->m_TMVPFlagsPresent << 18) |
98 (sps->m_useStrongIntraSmoothing << 19) |
99 (0 << 20) |
100 (pps->m_outputFlagPresentFlag << 21) |
101 (pps->m_numExtraSliceHeaderBits << 22) |
102 (pps->m_signHideFlag << 25) |
103 (pps->m_cabacInitPresentFlag << 26) |
104 (0 << 27);
105
106 pp->CodingSettingPicturePropertyFlags = (pps->m_bConstrainedIntraPred << 0) |
107 (pps->m_useTransformSkip << 1) |
108 (pps->m_useDQP << 2) |
109 (pps->m_bSliceChromaQpFlag << 3) |
110 (pps->m_bUseWeightPred << 4) |
111 (pps->m_useWeightedBiPred << 5) |
112 (pps->m_transquantBypassEnableFlag << 6) |
113 (pps->m_tiles_enabled_flag << 7) |
114 (pps->m_entropyCodingSyncEnabledFlag << 8) |
115 (pps->m_bTileUniformSpacing << 9) |
116 (pps->m_loopFilterAcrossTilesEnabledFlag << 10) |
117 (pps->m_LFCrossSliceBoundaryFlag << 11) |
118 (pps->m_deblockingFilterOverrideEnabledFlag << 12) |
119 (pps->m_picDisableDeblockingFilterFlag << 13) |
120 (pps->m_listsModificationPresentFlag << 14) |
121 (pps->m_sliceHeaderExtensionPresentFlag << 15);
122
123 pp->pps_cb_qp_offset = pps->m_chromaCbQpOffset;
124 pp->pps_cr_qp_offset = pps->m_chromaCrQpOffset;
125 pp->diff_cu_qp_delta_depth = pps->m_maxCuDQPDepth;
126 pp->pps_beta_offset_div2 = pps->m_deblockingFilterBetaOffsetDiv2;
127 pp->pps_tc_offset_div2 = pps->m_deblockingFilterTcOffsetDiv2;
128 pp->log2_parallel_merge_level_minus2 = pps->m_log2ParallelMergeLevelMinus2 - 2;
129 if (pps->m_tiles_enabled_flag) {
130 RK_U8 i = 0;
131
132 mpp_assert(pps->m_nNumTileColumnsMinus1 <= 19);
133 mpp_assert(pps->m_nNumTileRowsMinus1 <= 21);
134
135 pp->num_tile_columns_minus1 = pps->m_nNumTileColumnsMinus1;
136 pp->num_tile_rows_minus1 = pps->m_nNumTileRowsMinus1;
137
138 for (i = 0; i <= pp->num_tile_columns_minus1; i++)
139 pp->column_width_minus1[i] = pps->m_nTileColumnWidthArray[i] - 1;
140
141 for (i = 0; i <= pp->num_tile_rows_minus1; i++)
142 pp->row_height_minus1[i] = pps->m_nTileRowHeightArray[i] - 1;
143 }
144 }
145
fill_slice_parameters(const H265eCtx * h,H265eSlicParams * sp)146 static void fill_slice_parameters( const H265eCtx *h,
147 H265eSlicParams *sp)
148 {
149 MppEncH265Cfg *codec = &h->cfg->h265;
150 H265eSlice *slice = h->slice;
151 memset(sp, 0, sizeof(H265eSlicParams));
152 if (codec->slice_cfg.split_enable) {
153 sp->sli_splt_cpst = 1;
154 sp->sli_splt = 1;
155 sp->sli_splt_mode = codec->slice_cfg.split_mode;
156 if (codec->slice_cfg.split_mode) {
157 sp->sli_splt_cnum_m1 = codec->slice_cfg.slice_size - 1;
158 } else {
159 sp->sli_splt_byte = codec->slice_cfg.slice_size;
160 }
161 sp->sli_max_num_m1 = 50;
162 sp->sli_flsh = 1;
163 }
164
165 sp->cbc_init_flg = slice->m_cabacInitFlag;
166 sp->mvd_l1_zero_flg = slice->m_bLMvdL1Zero;
167 sp->merge_up_flag = codec->merge_cfg.merge_up_flag;
168 sp->merge_left_flag = codec->merge_cfg.merge_left_flag;
169 sp->ref_pic_lst_mdf_l0 = slice->ref_pic_list_modification_flag_l0;
170
171 sp->num_refidx_l1_act = 0;
172 sp->num_refidx_l0_act = 0;
173
174 sp->num_refidx_act_ovrd = (((RK_U32)slice->m_numRefIdx[0] != slice->m_pps->m_numRefIdxL0DefaultActive)
175 || (slice->m_sliceType == B_SLICE &&
176 (RK_U32)slice->m_numRefIdx[1] != slice->m_pps->m_numRefIdxL1DefaultActive));
177
178 sp->sli_sao_chrm_flg = slice->m_sps->m_bUseSAO && slice->m_saoEnabledFlagChroma;
179 sp->sli_sao_luma_flg = slice->m_sps->m_bUseSAO && slice->m_saoEnabledFlag;
180 sp->sli_tmprl_mvp_en = slice->m_enableTMVPFlag;
181
182 sp->pic_out_flg = slice->m_picOutputFlag;
183 sp->slice_type = slice->m_sliceType;
184 sp->slice_rsrv_flg = 0;
185 sp->dpdnt_sli_seg_flg = 0;
186 sp->sli_pps_id = slice->m_pps->m_PPSId;
187 sp->no_out_pri_pic = slice->no_output_of_prior_pics_flag;
188
189 sp->sli_tc_ofst_div2 = slice->m_deblockingFilterTcOffsetDiv2;
190 sp->sli_beta_ofst_div2 = slice->m_deblockingFilterBetaOffsetDiv2;
191 sp->sli_lp_fltr_acrs_sli = slice->m_LFCrossSliceBoundaryFlag;
192 sp->sli_dblk_fltr_dis = slice->m_deblockingFilterDisable;
193 sp->dblk_fltr_ovrd_flg = slice->m_deblockingFilterOverrideFlag;
194 sp->sli_cb_qp_ofst = slice->m_sliceQpDeltaCb;
195 sp->sli_qp = slice->m_sliceQp;
196 sp->max_mrg_cnd = slice->m_maxNumMergeCand;
197 sp->temporal_id = slice->temporal_id;
198 sp->non_reference_flag = slice->m_temporalLayerNonReferenceFlag;
199 sp->col_ref_idx = 0;
200 sp->col_frm_l0_flg = slice->m_colFromL0Flag;
201 sp->sli_poc_lsb = (slice->poc - slice->last_idr + (1 << slice->m_sps->m_bitsForPOC)) %
202 (1 << slice->m_sps->m_bitsForPOC);
203 sp->sli_hdr_ext_len = slice->slice_header_extension_length;
204 }
205
fill_ref_parameters(const H265eCtx * h,H265eSlicParams * sp)206 RK_S32 fill_ref_parameters(const H265eCtx *h, H265eSlicParams *sp)
207 {
208 H265eSlice *slice = h->slice;
209 H265eReferencePictureSet* rps = slice->m_rps;
210 RK_U32 numRpsCurrTempList = 0;
211 RK_S32 ref_num = 0;
212 H265eDpbFrm *ref_frame;
213 RK_S32 i, j, k;
214 sp->dlt_poc_msb_prsnt0 = 0;
215 sp->dlt_poc_msb_cycl0 = 0;
216 sp->tot_poc_num = 0;
217 if (slice->m_bdIdx < 0) {
218 RK_S32 prev = 0;
219 sp->st_ref_pic_flg = 0;
220 sp->num_neg_pic = rps->num_negative_pic;
221 sp->num_pos_pic = rps->num_positive_pic;
222 for (j = 0; j < rps->num_negative_pic; j++) {
223 if (0 == j) {
224 sp->dlt_poc_s0_m10 = prev - rps->delta_poc[j] - 1;
225 sp->used_by_s0_flg = rps->m_ref[j];
226 } else if (1 == j) {
227 sp->dlt_poc_s0_m11 = prev - rps->delta_poc[j] - 1;
228 sp->used_by_s0_flg |= rps->m_ref[j] << 1;
229 } else if (2 == j) {
230 sp->dlt_poc_s0_m12 = prev - rps->delta_poc[j] - 1;
231 sp->used_by_s0_flg |= rps->m_ref[j] << 2;
232 } else if (3 == j) {
233 sp->dlt_poc_s0_m13 = prev - rps->delta_poc[j] - 1;
234 sp->used_by_s0_flg |= rps->m_ref[j] << 3;
235 }
236 prev = rps->delta_poc[j];
237 }
238 }
239
240 for (i = 0; i < rps->m_numberOfPictures; i++) {
241 if (rps->m_ref[i]) {
242 sp->tot_poc_num++;
243 }
244 }
245
246 if (slice->m_sps->m_bLongTermRefsPresent) {
247 RK_S32 numLtrpInSH = rps->num_long_term_pic;
248 RK_S32 numLtrpInSPS = 0;
249 RK_U32 poc_lsb_lt[3] = { 0, 0, 0 };
250 RK_U32 used_by_lt_flg[3] = { 0, 0, 0 };
251 RK_U32 dlt_poc_msb_prsnt[3] = { 0, 0, 0 };
252 RK_U32 dlt_poc_msb_cycl[3] = { 0, 0, 0 };
253 RK_S32 prevDeltaMSB = 0;
254 RK_S32 offset = rps->num_negative_pic + rps->num_positive_pic;
255 RK_S32 numLongTerm = rps->m_numberOfPictures - offset;
256 RK_S32 bitsForLtrpInSPS = 0;
257 for (k = rps->m_numberOfPictures - 1; k > rps->m_numberOfPictures - rps->num_long_term_pic - 1; k--) {
258 RK_U32 lsb = rps->poc[k] % (1 << slice->m_sps->m_bitsForPOC);
259 RK_U32 find_flag = 0;
260 for (i = 0; i < (RK_S32)slice->m_sps->m_numLongTermRefPicSPS; i++) {
261 if ((lsb == slice->m_sps->m_ltRefPicPocLsbSps[i]) && (rps->m_used[k] == slice->m_sps->m_usedByCurrPicLtSPSFlag[i])) {
262 find_flag = 1;
263 break;
264 }
265 }
266
267 if (find_flag)
268 numLtrpInSPS++;
269 }
270
271 numLtrpInSH -= numLtrpInSPS;
272
273 while (slice->m_sps->m_numLongTermRefPicSPS > (RK_U32)(1 << bitsForLtrpInSPS)) {
274 bitsForLtrpInSPS++;
275 }
276
277 if (slice->m_sps->m_numLongTermRefPicSPS > 0) {
278 sp->num_lt_sps = numLtrpInSPS;
279 }
280 sp->num_lt_pic = numLtrpInSH;
281 // Note that the LSBs of the LT ref. pic. POCs must be sorted before.
282 // Not sorted here because LT ref indices will be used in setRefPicList()
283 sp->poc_lsb_lt0 = 0;
284 sp->used_by_lt_flg0 = 0;
285 sp->dlt_poc_msb_prsnt0 = 0;
286 sp->dlt_poc_msb_cycl0 = 0;
287 sp->poc_lsb_lt1 = 0;
288 sp->used_by_lt_flg1 = 0;
289 sp->dlt_poc_msb_prsnt1 = 0;
290 sp->dlt_poc_msb_cycl1 = 0;
291 sp->poc_lsb_lt2 = 0;
292 sp->used_by_lt_flg2 = 0;
293 sp->dlt_poc_msb_prsnt2 = 0;
294 sp->dlt_poc_msb_cycl2 = 0;
295
296 for ( i = rps->m_numberOfPictures - 1; i > offset - 1; i--) {
297 RK_U32 deltaFlag = 0;
298 if ((i == rps->m_numberOfPictures - 1) || (i == rps->m_numberOfPictures - 1 - numLtrpInSPS)) {
299 deltaFlag = 1;
300 }
301 poc_lsb_lt[numLongTerm - 1 - (i - offset)] = rps->m_pocLSBLT[i];
302 used_by_lt_flg[numLongTerm - 1 - (i - offset)] = rps->m_ref[i];
303 dlt_poc_msb_prsnt[numLongTerm - 1 - (i - offset)] = rps->m_deltaPocMSBPresentFlag[i];
304
305 if (rps->m_deltaPocMSBPresentFlag[i]) {
306 if (deltaFlag) {
307 dlt_poc_msb_cycl[numLongTerm - 1 - (i - offset)] = rps->m_deltaPOCMSBCycleLT[i];
308 } else {
309 RK_S32 differenceInDeltaMSB = rps->m_deltaPOCMSBCycleLT[i] - prevDeltaMSB;
310 mpp_assert(differenceInDeltaMSB >= 0);
311 dlt_poc_msb_cycl[numLongTerm - 1 - (i - offset)] = differenceInDeltaMSB;
312 }
313 }
314 prevDeltaMSB = rps->m_deltaPOCMSBCycleLT[i];
315 }
316
317 sp->poc_lsb_lt0 = poc_lsb_lt[0];
318 sp->used_by_lt_flg0 = used_by_lt_flg[0];
319 sp->dlt_poc_msb_prsnt0 = dlt_poc_msb_prsnt[0];
320 sp->dlt_poc_msb_cycl0 = dlt_poc_msb_cycl[0];
321 sp->poc_lsb_lt1 = poc_lsb_lt[1];
322 sp->used_by_lt_flg1 = used_by_lt_flg[1];
323 sp->dlt_poc_msb_prsnt1 = dlt_poc_msb_prsnt[1];
324 sp->dlt_poc_msb_cycl1 = dlt_poc_msb_cycl[1];
325 sp->poc_lsb_lt2 = poc_lsb_lt[2];
326 sp->used_by_lt_flg2 = used_by_lt_flg[2];
327 sp->dlt_poc_msb_prsnt2 = dlt_poc_msb_prsnt[2];
328 sp->dlt_poc_msb_cycl2 = dlt_poc_msb_cycl[2];
329 }
330
331 sp->lst_entry_l0 = 0;
332 sp->ref_pic_lst_mdf_l0 = 0;
333
334 if (slice->m_sliceType == I_SLICE) {
335 numRpsCurrTempList = 0;
336 } else {
337 ref_num = rps->num_negative_pic + rps->num_positive_pic + rps->num_long_term_pic;
338 for (i = 0; i < ref_num; i++) {
339 if (rps->m_used[i]) {
340 numRpsCurrTempList++;
341 }
342 }
343 }
344
345 if (slice->m_pps->m_listsModificationPresentFlag && numRpsCurrTempList > 1) {
346 H265eRefPicListModification* refPicListModification = &slice->m_RefPicListModification;
347 if (slice->m_sliceType != I_SLICE) {
348 sp->ref_pic_lst_mdf_l0 = refPicListModification->m_refPicListModificationFlagL0 ? 1 : 0;
349 if (sp->ref_pic_lst_mdf_l0) {
350 sp->lst_entry_l0 = refPicListModification->m_RefPicSetIdxL0[0];
351 }
352 }
353 }
354
355 sp->recon_pic.slot_idx = h->dpb->curr->slot_idx;
356 ref_frame = slice->m_refPicList[0][0];
357
358 if (ref_frame) {
359 if (ref_frame->status.force_pskip_is_ref)
360 sp->ref_pic.slot_idx = slice->m_refPicList[0][0]->prev_ref_idx;
361 else
362 sp->ref_pic.slot_idx = ref_frame->slot_idx;
363 } else {
364 sp->ref_pic.slot_idx = h->dpb->curr->slot_idx;
365 }
366 return 0;
367 }
368
h265e_syntax_fill(void * ctx)369 RK_S32 h265e_syntax_fill(void *ctx)
370 {
371 H265eCtx *h = (H265eCtx *)ctx;
372 H265eSyntax_new *syn = (H265eSyntax_new*)&h->syntax;
373
374 fill_picture_parameters(h, &syn->pp);
375 fill_slice_parameters(h, &syn->sp);
376 fill_ref_parameters(h, &syn->sp);
377 syn->dpb = h->dpb;
378 return 0;
379 }
380