1 /*
2 * Copyright(c) 2019 Intel Corporation
3 * SPDX - License - Identifier: BSD - 2 - Clause - Patent
4 */
5
6 #include <stdlib.h>
7 #include <stdint.h>
8
9 #include "EbDefinitions.h"
10 #include "EbPictureControlSet.h"
11 #include "EbPictureBufferDesc.h"
12
13 #include "vp9_encoder.h"
14
eb_vp9_picture_control_set_ctor(EbPtr * object_dbl_ptr,EbPtr object_init_data_ptr)15 EbErrorType eb_vp9_picture_control_set_ctor(
16 EbPtr *object_dbl_ptr,
17 EbPtr object_init_data_ptr)
18 {
19 PictureControlSet *object_ptr;
20 PictureControlSetInitData *init_data_ptr = (PictureControlSetInitData*) object_init_data_ptr;
21
22 EbPictureBufferDescInitData input_picture_buffer_desc_init_data;
23 EbPictureBufferDescInitData coeff_buffer_desc_init_data;
24
25 // LCUs
26 const uint16_t picturesb_width = (uint16_t)((init_data_ptr->picture_width + MAX_SB_SIZE_MINUS_1) / MAX_SB_SIZE);
27 const uint16_t picturesb_height = (uint16_t)((init_data_ptr->picture_height + MAX_SB_SIZE_MINUS_1) / MAX_SB_SIZE);
28 uint16_t sb_index;
29 uint16_t sb_origin_x;
30 uint16_t sb_origin_y;
31 EbErrorType return_error = EB_ErrorNone;
32
33 EB_BOOL is16bit = init_data_ptr->is16bit;
34
35 EB_MALLOC(PictureControlSet*, object_ptr, sizeof(PictureControlSet), EB_N_PTR);
36
37 // Hsan to clean up the constructor
38 const int aligned_width = ALIGN_POWER_OF_TWO(init_data_ptr->picture_width, MI_SIZE_LOG2);
39 const int aligned_height = ALIGN_POWER_OF_TWO(init_data_ptr->picture_height, MI_SIZE_LOG2);
40
41 int mi_cols = aligned_width >> MI_SIZE_LOG2;
42 int mi_rows = aligned_height >> MI_SIZE_LOG2;
43
44 EB_MALLOC(ModeInfo **, object_ptr->mode_info_array, sizeof(ModeInfo*) * mi_cols * mi_rows, EB_N_PTR);
45 for (int mi_index = 0; mi_index < mi_cols * mi_rows; mi_index++) {
46 EB_MALLOC(ModeInfo *, object_ptr->mode_info_array[mi_index], sizeof(ModeInfo), EB_N_PTR);
47 }
48
49 // Init Picture Init data
50 input_picture_buffer_desc_init_data.max_width = init_data_ptr->picture_width;
51 input_picture_buffer_desc_init_data.max_height = init_data_ptr->picture_height;
52 input_picture_buffer_desc_init_data.bit_depth = init_data_ptr->bit_depth;
53 input_picture_buffer_desc_init_data.buffer_enable_mask = PICTURE_BUFFER_DESC_FULL_MASK;
54 input_picture_buffer_desc_init_data.left_padding = 0;
55 input_picture_buffer_desc_init_data.right_padding = 0;
56 input_picture_buffer_desc_init_data.top_padding = 0;
57 input_picture_buffer_desc_init_data.bot_padding = 0;
58 input_picture_buffer_desc_init_data.split_mode = EB_FALSE;
59
60 coeff_buffer_desc_init_data.max_width = init_data_ptr->picture_width;
61 coeff_buffer_desc_init_data.max_height = init_data_ptr->picture_height;
62 coeff_buffer_desc_init_data.bit_depth = EB_16BIT;
63 coeff_buffer_desc_init_data.buffer_enable_mask = PICTURE_BUFFER_DESC_FULL_MASK;
64 coeff_buffer_desc_init_data.left_padding = 0;
65 coeff_buffer_desc_init_data.right_padding = 0;
66 coeff_buffer_desc_init_data.top_padding = 0;
67 coeff_buffer_desc_init_data.bot_padding = 0;
68 coeff_buffer_desc_init_data.split_mode = EB_FALSE;
69
70 *object_dbl_ptr = (EbPtr) object_ptr;
71
72 object_ptr->sequence_control_set_wrapper_ptr = (EbObjectWrapper*)EB_NULL;
73
74 object_ptr->recon_picture_16bit_ptr = (EbPictureBufferDesc*)EB_NULL;
75 object_ptr->recon_picture_ptr = (EbPictureBufferDesc*)EB_NULL;
76
77 // Reconstructed Picture Buffer
78 if(init_data_ptr->is16bit == EB_TRUE){
79 return_error = eb_vp9_recon_picture_buffer_desc_ctor(
80 (EbPtr*) &(object_ptr->recon_picture_16bit_ptr),
81 (EbPtr) &coeff_buffer_desc_init_data);
82 }
83 else
84 {
85
86 return_error = eb_vp9_recon_picture_buffer_desc_ctor(
87 (EbPtr*) &(object_ptr->recon_picture_ptr),
88 (EbPtr) &input_picture_buffer_desc_init_data);
89 }
90
91 if (return_error == EB_ErrorInsufficientResources){
92 return EB_ErrorInsufficientResources;
93 }
94 // Entropy Coder
95 return_error = eb_vp9_entropy_coder_ctor(
96 &object_ptr->entropy_coder_ptr,
97 SEGMENT_ENTROPY_BUFFER_SIZE);
98
99 if (return_error == EB_ErrorInsufficientResources){
100 return EB_ErrorInsufficientResources;
101 }
102
103 // Packetization process Bitstream
104 return_error = eb_vp9_bitstream_ctor(
105 &object_ptr->bitstream_ptr,
106 PACKETIZATION_PROCESS_BUFFER_SIZE);
107
108 if (return_error == EB_ErrorInsufficientResources){
109 return EB_ErrorInsufficientResources;
110 }
111
112 // GOP
113 object_ptr->picture_number = 0;
114 object_ptr->temporal_layer_index = 0;
115
116 // LCU Array
117 object_ptr->sb_max_depth = (uint8_t) init_data_ptr->eb_vp9_max_depth;
118 object_ptr->sb_total_count = picturesb_width * picturesb_height;
119 EB_MALLOC(SbUnit**, object_ptr->sb_ptr_array, sizeof(SbUnit*) * object_ptr->sb_total_count, EB_N_PTR);
120
121 sb_origin_x = 0;
122 sb_origin_y = 0;
123
124 for(sb_index=0; sb_index < object_ptr->sb_total_count; ++sb_index) {
125
126 return_error = sb_unit_ctor(
127 &(object_ptr->sb_ptr_array[sb_index]),
128 init_data_ptr->picture_width,
129 init_data_ptr->picture_height,
130 (uint16_t)(sb_origin_x * MAX_SB_SIZE),
131 (uint16_t)(sb_origin_y * MAX_SB_SIZE),
132 (uint16_t)sb_index,
133 object_ptr);
134 if (return_error == EB_ErrorInsufficientResources){
135 return EB_ErrorInsufficientResources;
136 }
137 // Increment the Order in coding order (Raster Scan Order)
138 sb_origin_y = (sb_origin_x == picturesb_width - 1) ? sb_origin_y + 1: sb_origin_y;
139 sb_origin_x = (sb_origin_x == picturesb_width - 1) ? 0 : sb_origin_x + 1;
140 }
141
142 // Mode Decision Control config
143 EB_MALLOC(MdcSbData*, object_ptr->mdc_sb_data_array, object_ptr->sb_total_count * sizeof(MdcSbData), EB_N_PTR);
144 // Mode Decision Neighbor Arrays
145 uint8_t depth;
146 for (depth = 0; depth < NEIGHBOR_ARRAY_TOTAL_COUNT; depth++) {
147
148 return_error = eb_vp9_neighbor_array_unit_ctor(
149 &object_ptr->md_luma_recon_neighbor_array[depth],
150 MAX_PICTURE_WIDTH_SIZE,
151 MAX_PICTURE_HEIGHT_SIZE,
152 sizeof(uint8_t),
153 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
154 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
155 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
156 if (return_error == EB_ErrorInsufficientResources){
157 return EB_ErrorInsufficientResources;
158 }
159
160 return_error = eb_vp9_neighbor_array_unit_ctor(
161 &object_ptr->md_cb_recon_neighbor_array[depth],
162 MAX_PICTURE_WIDTH_SIZE >> 1,
163 MAX_PICTURE_HEIGHT_SIZE >> 1,
164 sizeof(uint8_t),
165 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
166 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
167 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
168
169 if (return_error == EB_ErrorInsufficientResources){
170 return EB_ErrorInsufficientResources;
171 }
172
173 return_error = eb_vp9_neighbor_array_unit_ctor(
174 &object_ptr->md_cr_recon_neighbor_array[depth],
175 MAX_PICTURE_WIDTH_SIZE >> 1,
176 MAX_PICTURE_HEIGHT_SIZE >> 1,
177 sizeof(uint8_t),
178 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
179 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
180 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
181 if (return_error == EB_ErrorInsufficientResources){
182 return EB_ErrorInsufficientResources;
183 }
184 }
185
186 return_error = eb_vp9_neighbor_array_unit_ctor(
187 &object_ptr->ep_luma_recon_neighbor_array,
188 MAX_PICTURE_WIDTH_SIZE,
189 MAX_PICTURE_HEIGHT_SIZE,
190 sizeof(uint8_t),
191 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
192 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
193 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
194
195 if (return_error == EB_ErrorInsufficientResources){
196 return EB_ErrorInsufficientResources;
197 }
198 return_error = eb_vp9_neighbor_array_unit_ctor(
199 &object_ptr->ep_cb_recon_neighbor_array,
200 MAX_PICTURE_WIDTH_SIZE >> 1,
201 MAX_PICTURE_HEIGHT_SIZE >> 1,
202 sizeof(uint8_t),
203 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
204 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
205 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
206
207 if (return_error == EB_ErrorInsufficientResources){
208 return EB_ErrorInsufficientResources;
209 }
210 return_error = eb_vp9_neighbor_array_unit_ctor(
211 &object_ptr->ep_cr_recon_neighbor_array,
212 MAX_PICTURE_WIDTH_SIZE >> 1,
213 MAX_PICTURE_HEIGHT_SIZE >> 1,
214 sizeof(uint8_t),
215 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
216 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
217 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
218
219 if (return_error == EB_ErrorInsufficientResources){
220 return EB_ErrorInsufficientResources;
221 }
222
223 if(is16bit){
224 return_error = eb_vp9_neighbor_array_unit_ctor(
225 &object_ptr->ep_luma_recon_neighbor_array_16bit,
226 MAX_PICTURE_WIDTH_SIZE,
227 MAX_PICTURE_HEIGHT_SIZE,
228 sizeof(uint16_t),
229 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
230 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
231 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
232
233 if (return_error == EB_ErrorInsufficientResources){
234 return EB_ErrorInsufficientResources;
235 }
236 return_error = eb_vp9_neighbor_array_unit_ctor(
237 &object_ptr->ep_cb_recon_neighbor_array_16bit,
238 MAX_PICTURE_WIDTH_SIZE >> 1,
239 MAX_PICTURE_HEIGHT_SIZE >> 1,
240 sizeof(uint16_t),
241 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
242 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
243 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
244
245 if (return_error == EB_ErrorInsufficientResources){
246 return EB_ErrorInsufficientResources;
247 }
248 return_error = eb_vp9_neighbor_array_unit_ctor(
249 &object_ptr->ep_cr_recon_neighbor_array_16bit,
250 MAX_PICTURE_WIDTH_SIZE >> 1,
251 MAX_PICTURE_HEIGHT_SIZE >> 1,
252 sizeof(uint16_t),
253 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
254 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
255 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
256 if (return_error == EB_ErrorInsufficientResources){
257 return EB_ErrorInsufficientResources;
258 }
259 }
260 else {
261 object_ptr->ep_luma_recon_neighbor_array_16bit = 0;
262 object_ptr->ep_cb_recon_neighbor_array_16bit = 0;
263 object_ptr->ep_cr_recon_neighbor_array_16bit = 0;
264 }
265
266 if (return_error == EB_ErrorInsufficientResources){
267 return EB_ErrorInsufficientResources;
268 }
269
270 #if VP9_RD
271 for (uint8_t depth = 0; depth < NEIGHBOR_ARRAY_TOTAL_COUNT; depth++) {
272 EB_MALLOC(PARTITION_CONTEXT *, object_ptr->md_above_seg_context[depth], sizeof(PARTITION_CONTEXT) * mi_cols_aligned_to_sb(mi_cols), EB_N_PTR);
273 EB_MALLOC(PARTITION_CONTEXT *, object_ptr->md_left_seg_context[depth], sizeof(PARTITION_CONTEXT) * mi_cols_aligned_to_sb(mi_rows), EB_N_PTR);
274 EB_MALLOC(ENTROPY_CONTEXT *, object_ptr->md_above_context[depth], sizeof(ENTROPY_CONTEXT) * MAX_MB_PLANE * 2 * mi_cols_aligned_to_sb(mi_cols), EB_N_PTR);
275 EB_MALLOC(ENTROPY_CONTEXT *, object_ptr->md_left_context[depth], sizeof(ENTROPY_CONTEXT) * MAX_MB_PLANE * 2 * mi_cols_aligned_to_sb(mi_rows), EB_N_PTR);
276 }
277
278 EB_MALLOC(ENTROPY_CONTEXT *, object_ptr->ep_above_context, sizeof(ENTROPY_CONTEXT) * MAX_MB_PLANE * 2 * mi_cols_aligned_to_sb(mi_cols), EB_N_PTR);
279 EB_MALLOC(ENTROPY_CONTEXT *, object_ptr->ep_left_context, sizeof(ENTROPY_CONTEXT) * MAX_MB_PLANE * 2 * mi_cols_aligned_to_sb(mi_rows), EB_N_PTR);
280 #endif
281
282 // Segments
283 return_error = eb_vp9_enc_dec_segments_ctor(
284 &object_ptr->enc_dec_segment_ctrl,
285 init_data_ptr->enc_dec_segment_col,
286 init_data_ptr->enc_dec_segment_row);
287 if (return_error == EB_ErrorInsufficientResources){
288 return EB_ErrorInsufficientResources;
289 }
290 // Entropy Rows
291 EB_CREATEMUTEX(EbHandle, object_ptr->entropy_coding_mutex, sizeof(EbHandle), EB_MUTEX);
292
293 return EB_ErrorNone;
294 }
295
eb_vp9_picture_parent_control_set_ctor(EbPtr * object_dbl_ptr,EbPtr object_init_data_ptr)296 EbErrorType eb_vp9_picture_parent_control_set_ctor(
297 EbPtr *object_dbl_ptr,
298 EbPtr object_init_data_ptr)
299 {
300 PictureParentControlSet *object_ptr;
301 PictureControlSetInitData *init_data_ptr = (PictureControlSetInitData*) object_init_data_ptr;
302
303 EbErrorType return_error = EB_ErrorNone;
304 const uint16_t picturesb_width = (uint16_t)((init_data_ptr->picture_width + MAX_SB_SIZE_MINUS_1) / MAX_SB_SIZE);
305 const uint16_t picturesb_height = (uint16_t)((init_data_ptr->picture_height + MAX_SB_SIZE_MINUS_1) / MAX_SB_SIZE);
306 uint16_t sb_index;
307 uint32_t region_in_picture_width_index;
308 uint32_t region_in_picture_height_index;
309
310 EB_MALLOC(PictureParentControlSet *, object_ptr, sizeof(PictureParentControlSet ), EB_N_PTR);
311
312 EB_MALLOC(VP9_COMP *, object_ptr->cpi, sizeof(VP9_COMP), EB_N_PTR);
313
314 object_ptr->cpi->common.mi_cols = init_data_ptr->picture_width >> MI_SIZE_LOG2;
315 object_ptr->cpi->common.mi_rows = init_data_ptr->picture_height >> MI_SIZE_LOG2;
316
317 EB_MALLOC(FRAME_COUNTS *, object_ptr->cpi->td.counts, sizeof(FRAME_COUNTS), EB_N_PTR);
318
319 EB_MALLOC(FRAME_CONTEXT*, object_ptr->cpi->common.fc, sizeof(FRAME_CONTEXT), EB_N_PTR);
320 EB_MALLOC(FRAME_CONTEXT*, object_ptr->cpi->common.frame_contexts, sizeof(FRAME_CONTEXT), EB_N_PTR);
321
322 EB_MALLOC(uint16_t *, object_ptr->cpi->td.mb.plane[0].eobs , sizeof(uint16_t ) * (MAX_CU_SIZE << 2) * (MAX_CU_SIZE << 2), EB_N_PTR);
323 EB_MALLOC(tran_low_t *, object_ptr->cpi->td.mb.plane[0].qcoeff, sizeof(tran_low_t) * MAX_CU_SIZE * MAX_CU_SIZE, EB_N_PTR);
324
325 EB_MALLOC(uint16_t *, object_ptr->cpi->td.mb.plane[1].eobs , sizeof(uint16_t), EB_N_PTR);
326 EB_MALLOC(tran_low_t *, object_ptr->cpi->td.mb.plane[1].qcoeff, sizeof(tran_low_t) * MAX_CU_SIZE * MAX_CU_SIZE, EB_N_PTR);
327
328 EB_MALLOC(uint16_t *, object_ptr->cpi->td.mb.plane[2].eobs , sizeof(uint16_t), EB_N_PTR);
329 EB_MALLOC(tran_low_t *, object_ptr->cpi->td.mb.plane[2].qcoeff, sizeof(tran_low_t) * MAX_CU_SIZE * MAX_CU_SIZE, EB_N_PTR);
330
331 #if VP9_RD
332 EB_MALLOC(int*, object_ptr->cpi->nmvcosts[0], sizeof(int)* MV_VALS, EB_N_PTR);
333 EB_MALLOC(int*, object_ptr->cpi->nmvcosts[1], sizeof(int)* MV_VALS, EB_N_PTR);
334 EB_MALLOC(int*, object_ptr->cpi->nmvcosts_hp[0], sizeof(int)* MV_VALS, EB_N_PTR);
335 EB_MALLOC(int*, object_ptr->cpi->nmvcosts_hp[1], sizeof(int)* MV_VALS, EB_N_PTR);
336 EB_MALLOC(int*, object_ptr->cpi->nmvsadcosts[0], sizeof(int)* MV_VALS, EB_N_PTR);
337 EB_MALLOC(int*, object_ptr->cpi->nmvsadcosts[1], sizeof(int)* MV_VALS, EB_N_PTR);
338 EB_MALLOC(int*, object_ptr->cpi->nmvsadcosts_hp[0], sizeof(int)* MV_VALS, EB_N_PTR);
339 EB_MALLOC(int*, object_ptr->cpi->nmvsadcosts_hp[1], sizeof(int)* MV_VALS, EB_N_PTR);
340 #endif
341 #if SEG_SUPPORT
342 EB_MALLOC(uint8_t*, object_ptr->cpi->segmentation_map, sizeof(uint8_t)* object_ptr->cpi->common.mi_cols* object_ptr->cpi->common.mi_rows, EB_N_PTR);
343 #endif
344 EB_MALLOC(PARTITION_CONTEXT *, object_ptr->cpi->common.above_seg_context, sizeof(PARTITION_CONTEXT) * mi_cols_aligned_to_sb(object_ptr->cpi->common.mi_cols), EB_N_PTR);
345
346 EB_MALLOC(ENTROPY_CONTEXT *, object_ptr->cpi->common.above_context, sizeof(ENTROPY_CONTEXT) * MAX_MB_PLANE * 2 * mi_cols_aligned_to_sb(object_ptr->cpi->common.mi_cols), EB_N_PTR);
347
348 object_ptr->cpi->common.lf.lfm_stride = (object_ptr->cpi->common.mi_cols + (MI_BLOCK_SIZE - 1)) >> 3;
349
350 EB_MALLOC(LOOP_FILTER_MASK *, object_ptr->cpi->common.lf.lfm, sizeof(LOOP_FILTER_MASK) * ((object_ptr->cpi->common.mi_rows + (MI_BLOCK_SIZE - 1)) >> 3) * object_ptr->cpi->common.lf.lfm_stride, EB_N_PTR);
351
352 *object_dbl_ptr = (EbPtr)object_ptr;
353
354 object_ptr->sequence_control_set_wrapper_ptr = (EbObjectWrapper *)EB_NULL;
355 object_ptr->input_picture_wrapper_ptr = (EbObjectWrapper *)EB_NULL;
356 object_ptr->reference_picture_wrapper_ptr = (EbObjectWrapper *)EB_NULL;
357
358 // GOP
359 object_ptr->pred_struct_index = 0;
360 object_ptr->picture_number = 0;
361 object_ptr->idr_flag = EB_FALSE;
362 object_ptr->temporal_layer_index = 0;
363
364 object_ptr->total_num_bits = 0;
365
366 object_ptr->last_idr_picture = 0;
367
368 object_ptr->sb_total_count = picturesb_width * picturesb_height;
369
370 EB_MALLOC(uint16_t**, object_ptr->variance, sizeof(uint16_t*) * object_ptr->sb_total_count, EB_N_PTR);
371 EB_MALLOC(uint8_t**, object_ptr->y_mean, sizeof(uint8_t*) * object_ptr->sb_total_count, EB_N_PTR);
372 EB_MALLOC(uint8_t**, object_ptr->cb_mean, sizeof(uint8_t*) * object_ptr->sb_total_count, EB_N_PTR);
373 EB_MALLOC(uint8_t**, object_ptr->cr_mean, sizeof(uint8_t*) * object_ptr->sb_total_count, EB_N_PTR);
374 for (sb_index = 0; sb_index < object_ptr->sb_total_count; ++sb_index) {
375 EB_MALLOC(uint16_t*, object_ptr->variance[sb_index], sizeof(uint16_t) * MAX_ME_PU_COUNT, EB_N_PTR);
376 EB_MALLOC(uint8_t*, object_ptr->y_mean[sb_index], sizeof(uint8_t) * MAX_ME_PU_COUNT, EB_N_PTR);
377 EB_MALLOC(uint8_t*, object_ptr->cb_mean[sb_index], sizeof(uint8_t) * 21, EB_N_PTR);
378 EB_MALLOC(uint8_t*, object_ptr->cr_mean[sb_index], sizeof(uint8_t) * 21, EB_N_PTR);
379 }
380 // Histograms
381 uint32_t video_component;
382
383 EB_MALLOC(uint32_t****, object_ptr->picture_histogram, sizeof(uint32_t***) * MAX_NUMBER_OF_REGIONS_IN_WIDTH, EB_N_PTR);
384
385 for (region_in_picture_width_index = 0; region_in_picture_width_index < MAX_NUMBER_OF_REGIONS_IN_WIDTH; region_in_picture_width_index++){ // loop over horizontal regions
386 EB_MALLOC(uint32_t***, object_ptr->picture_histogram[region_in_picture_width_index], sizeof(uint32_t**) * MAX_NUMBER_OF_REGIONS_IN_HEIGHT, EB_N_PTR);
387 }
388
389 for (region_in_picture_width_index = 0; region_in_picture_width_index < MAX_NUMBER_OF_REGIONS_IN_WIDTH; region_in_picture_width_index++){ // loop over horizontal regions
390 for (region_in_picture_height_index = 0; region_in_picture_height_index < MAX_NUMBER_OF_REGIONS_IN_HEIGHT; region_in_picture_height_index++){ // loop over vertical regions
391 EB_MALLOC(uint32_t**, object_ptr->picture_histogram[region_in_picture_width_index][region_in_picture_height_index], sizeof(uint32_t*) * 3, EB_N_PTR);
392 }
393 }
394
395 for (region_in_picture_width_index = 0; region_in_picture_width_index < MAX_NUMBER_OF_REGIONS_IN_WIDTH; region_in_picture_width_index++){ // loop over horizontal regions
396 for (region_in_picture_height_index = 0; region_in_picture_height_index < MAX_NUMBER_OF_REGIONS_IN_HEIGHT; region_in_picture_height_index++){ // loop over vertical regions
397 for (video_component = 0; video_component < 3; ++video_component) {
398 EB_MALLOC(uint32_t*, object_ptr->picture_histogram[region_in_picture_width_index][region_in_picture_height_index][video_component], sizeof(uint32_t) * HISTOGRAM_NUMBER_OF_BINS, EB_N_PTR);
399 }
400 }
401 }
402 #if 0 // Hsan: will be used when adding ois
403 uint32_t maxOisCand;
404 uint32_t maxOisCand = MAX(MAX_OIS_0, MAX_OIS_2);
405
406 EB_MALLOC(OisCu32Cu16Results_t**, object_ptr->oisCu32Cu16Results, sizeof(OisCu32Cu16Results_t*) * object_ptr->sb_total_count, EB_N_PTR);
407
408 for (sb_index = 0; sb_index < object_ptr->sb_total_count; ++sb_index){
409
410 EB_MALLOC(OisCu32Cu16Results_t*, object_ptr->oisCu32Cu16Results[sb_index], sizeof(OisCu32Cu16Results_t), EB_N_PTR);
411
412 OisCandidate_t* contigousCand;
413 EB_MALLOC(OisCandidate_t*, contigousCand, sizeof(OisCandidate_t) * maxOisCand * 21, EB_N_PTR);
414
415 uint32_t cuIdx;
416 for (cuIdx = 0; cuIdx < 21; ++cuIdx){
417 object_ptr->oisCu32Cu16Results[sb_index]->sortedOisCandidate[cuIdx] = &contigousCand[cuIdx*maxOisCand];
418 }
419 }
420
421 EB_MALLOC(OisCu8Results_t**, object_ptr->oisCu8Results, sizeof(OisCu8Results_t*) * object_ptr->sb_total_count, EB_N_PTR);
422 for (sb_index = 0; sb_index < object_ptr->sb_total_count; ++sb_index){
423
424 EB_MALLOC(OisCu8Results_t*, object_ptr->oisCu8Results[sb_index], sizeof(OisCu8Results_t), EB_N_PTR);
425
426 OisCandidate_t* contigousCand;
427 EB_MALLOC(OisCandidate_t*, contigousCand, sizeof(OisCandidate_t) * maxOisCand * 64, EB_N_PTR);
428
429 uint32_t cuIdx;
430 for (cuIdx = 0; cuIdx < 64; ++cuIdx){
431 object_ptr->oisCu8Results[sb_index]->sortedOisCandidate[cuIdx] = &contigousCand[cuIdx*maxOisCand];
432 }
433 }
434 #endif
435
436 // Motion Estimation Results
437 object_ptr->max_number_of_pus_per_sb = SQUARE_PU_COUNT;
438 object_ptr->max_number_of_me_candidates_per_pu = 3;
439
440 EB_MALLOC(MeCuResults**, object_ptr->me_results, sizeof(MeCuResults*) * object_ptr->sb_total_count, EB_N_PTR);
441 for (sb_index = 0; sb_index < object_ptr->sb_total_count; ++sb_index) {
442 EB_MALLOC(MeCuResults*, object_ptr->me_results[sb_index], sizeof(MeCuResults) * 85, EB_N_PTR);
443 }
444
445 EB_MALLOC(uint32_t*, object_ptr->rcme_distortion, sizeof(uint32_t) * object_ptr->sb_total_count, EB_N_PTR);
446
447 // ME and OIS Distortion Histograms
448 EB_MALLOC(uint16_t*, object_ptr->me_distortion_histogram, sizeof(uint16_t) * NUMBER_OF_SAD_INTERVALS, EB_N_PTR);
449
450 EB_MALLOC(uint16_t*, object_ptr->ois_distortion_histogram, sizeof(uint16_t) * NUMBER_OF_INTRA_SAD_INTERVALS, EB_N_PTR);
451
452 EB_MALLOC(uint32_t*, object_ptr->intra_sad_interval_index, sizeof(uint32_t) * object_ptr->sb_total_count, EB_N_PTR);
453 EB_MALLOC(uint32_t*, object_ptr->inter_sad_interval_index, sizeof(uint32_t) * object_ptr->sb_total_count, EB_N_PTR);
454
455 // Non moving index array
456 EB_MALLOC(uint8_t*, object_ptr->non_moving_index_array, sizeof(uint8_t) * object_ptr->sb_total_count, EB_N_PTR);
457
458 // similar Colocated Lcu array
459 EB_MALLOC(EB_BOOL*, object_ptr->similar_colocated_sb_array, sizeof(EB_BOOL) * object_ptr->sb_total_count, EB_N_PTR);
460
461 // similar Colocated Lcu array
462 EB_MALLOC(EB_BOOL*, object_ptr->similar_colocated_sb_array_all_layers, sizeof(EB_BOOL) * object_ptr->sb_total_count, EB_N_PTR);
463
464 // LCU noise variance array
465 EB_MALLOC(uint8_t*, object_ptr->sb_flat_noise_array, sizeof(uint8_t) * object_ptr->sb_total_count, EB_N_PTR);
466 EB_MALLOC(uint64_t*, object_ptr->sb_variance_of_variance_over_time, sizeof(uint64_t) * object_ptr->sb_total_count, EB_N_PTR);
467 EB_MALLOC(EB_BOOL*, object_ptr->is_sb_homogeneous_over_time, sizeof(EB_BOOL) * object_ptr->sb_total_count, EB_N_PTR);
468 EB_MALLOC(EdgeSbResults*, object_ptr->edge_results_ptr, sizeof(EdgeSbResults) * object_ptr->sb_total_count, EB_N_PTR);
469 EB_MALLOC(uint8_t*, object_ptr->sharp_edge_sb_flag, sizeof(EB_BOOL) * object_ptr->sb_total_count, EB_N_PTR);
470 EB_MALLOC(EB_BOOL*, object_ptr->sb_homogeneous_area_array, sizeof(EB_BOOL) * object_ptr->sb_total_count, EB_N_PTR);
471
472 EB_MALLOC(uint64_t**, object_ptr->var_of_var_32x32_based_sb_array, sizeof(uint64_t*) * object_ptr->sb_total_count, EB_N_PTR);
473 for(sb_index = 0; sb_index < object_ptr->sb_total_count; ++sb_index) {
474 EB_MALLOC(uint64_t*, object_ptr->var_of_var_32x32_based_sb_array[sb_index], sizeof(uint64_t) * 4, EB_N_PTR);
475 }
476
477 EB_MALLOC(EB_BOOL*, object_ptr->sb_isolated_non_homogeneous_area_array, sizeof(EB_BOOL) * object_ptr->sb_total_count, EB_N_PTR);
478
479 EB_MALLOC(uint8_t*, object_ptr->sb_cmplx_contrast_array, sizeof(uint8_t) * object_ptr->sb_total_count, EB_N_PTR);
480
481 EB_MALLOC(SbStat*, object_ptr->sb_stat_array, sizeof(SbStat) * object_ptr->sb_total_count, EB_N_PTR);
482
483 EB_MALLOC(EB_SB_COMPLEXITY_STATUS*, object_ptr->complex_sb_array, sizeof(EB_SB_COMPLEXITY_STATUS) * object_ptr->sb_total_count, EB_N_PTR);
484
485 EB_CREATEMUTEX(EbHandle, object_ptr->rc_distortion_histogram_mutex, sizeof(EbHandle), EB_MUTEX);
486
487 EB_MALLOC(EB_SB_DEPTH_MODE*, object_ptr->sb_depth_mode_array, sizeof(EB_SB_DEPTH_MODE) * object_ptr->sb_total_count, EB_N_PTR);
488
489 return return_error;
490 }
491