1 /*
2 * Copyright(c) 2018 Intel Corporation
3 * SPDX - License - Identifier: BSD - 2 - Clause - Patent
4 */
5
6 #include <stdlib.h>
7
8 #include "EbDefinitions.h"
9 #include "EbPictureControlSet.h"
10 #include "EbPictureBufferDesc.h"
11
12
ConfigureTileInfo(PictureParentControlSet_t * ppcsPtr,EB_U8 lcuSize,EB_U16 pic_width,EB_U16 pic_height)13 static void ConfigureTileInfo(PictureParentControlSet_t *ppcsPtr, EB_U8 lcuSize, EB_U16 pic_width, EB_U16 pic_height)
14 {
15 // Tiles Initialisation
16 for (EB_U16 r = 0; r < ppcsPtr->tileRowCount; r++) {
17 for (EB_U16 c = 0; c < ppcsPtr->tileColumnCount; c++) {
18 unsigned tileIdx = r * ppcsPtr->tileColumnCount + c;
19 ppcsPtr->tileInfoArray[tileIdx].tileLcuOriginX = ppcsPtr->tileColStartLcu[c];
20 ppcsPtr->tileInfoArray[tileIdx].tileLcuOriginY = ppcsPtr->tileRowStartLcu[r];
21 ppcsPtr->tileInfoArray[tileIdx].tileLcuEndX = ppcsPtr->tileColStartLcu[c + 1];
22 ppcsPtr->tileInfoArray[tileIdx].tileLcuEndY = ppcsPtr->tileRowStartLcu[r + 1];
23
24 ppcsPtr->tileInfoArray[tileIdx].tilePxlOriginX = ppcsPtr->tileColStartLcu[c] * lcuSize;
25 ppcsPtr->tileInfoArray[tileIdx].tilePxlOriginY = ppcsPtr->tileRowStartLcu[r] * lcuSize;
26 ppcsPtr->tileInfoArray[tileIdx].tilePxlEndX = (c < ppcsPtr->tileColumnCount - 1) ?
27 ppcsPtr->tileColStartLcu[c + 1] * lcuSize : pic_width;
28 ppcsPtr->tileInfoArray[tileIdx].tilePxlEndY = (r < ppcsPtr->tileRowCount - 1) ?
29 ppcsPtr->tileRowStartLcu[r + 1] * lcuSize : pic_height;
30 }
31 }
32
33 return;
34 }
35
ConfigureLcuEdgeInfo(PictureParentControlSet_t * ppcsPtr)36 static void ConfigureLcuEdgeInfo(PictureParentControlSet_t *ppcsPtr)
37 {
38 EB_U32 tileCnt = ppcsPtr->tileRowCount * ppcsPtr->tileColumnCount;
39 TileInfo_t *ti = ppcsPtr->tileInfoArray;
40 for (EB_U16 tileIdx = 0; tileIdx < tileCnt; tileIdx++) {
41 for (EB_U16 y = ti[tileIdx].tileLcuOriginY; y < ti[tileIdx].tileLcuEndY; y++) {
42 for (EB_U16 x = ti[tileIdx].tileLcuOriginX; x < ti[tileIdx].tileLcuEndX; x++) {
43
44 unsigned lcuIndex = y * ppcsPtr->pictureWidthInLcu + x;
45 ppcsPtr->lcuEdgeInfoArray[lcuIndex].tileLeftEdgeFlag = (x == ti[tileIdx].tileLcuOriginX);
46 ppcsPtr->lcuEdgeInfoArray[lcuIndex].tileTopEdgeFlag = (y == ti[tileIdx].tileLcuOriginY);
47 ppcsPtr->lcuEdgeInfoArray[lcuIndex].tileRightEdgeFlag = (x == ti[tileIdx].tileLcuEndX - 1);
48 ppcsPtr->lcuEdgeInfoArray[lcuIndex].pictureLeftEdgeFlag = (x == 0) ? EB_TRUE : EB_FALSE;
49 ppcsPtr->lcuEdgeInfoArray[lcuIndex].pictureTopEdgeFlag = (y == 0) ? EB_TRUE : EB_FALSE;
50 ppcsPtr->lcuEdgeInfoArray[lcuIndex].pictureRightEdgeFlag = (x == (ppcsPtr->pictureWidthInLcu - 1)) ? EB_TRUE : EB_FALSE;
51 ppcsPtr->lcuEdgeInfoArray[lcuIndex].tileIndexInRaster = tileIdx;
52 }
53 }
54 }
55 return;
56 }
57
PictureControlSetDctor(EB_PTR p)58 static void PictureControlSetDctor(EB_PTR p)
59 {
60 PictureControlSet_t* obj = (PictureControlSet_t*)p;
61 EB_DELETE(obj->reconPicture16bitPtr);
62 EB_DELETE(obj->reconPicturePtr);
63 EB_FREE(obj->cabacCost);
64 EB_DELETE(obj->bitstreamPtr);
65 EB_DELETE(obj->coeffEstEntropyCoderPtr);
66 EB_DELETE_PTR_ARRAY(obj->lcuPtrArray, obj->lcuTotalCount);
67 EB_FREE_ARRAY(obj->mdcLcuArray);
68
69 EB_FREE_2D(obj->verticalEdgeBSArray);
70 EB_FREE_2D(obj->horizontalEdgeBSArray);
71 EB_FREE_ARRAY(obj->qpArray);
72 EB_FREE_ARRAY(obj->entropyQpArray);
73 EB_FREE_ARRAY(obj->cbfMapArray);
74 EB_DELETE_PTR_ARRAY(obj->epIntraLumaModeNeighborArray, obj->totalTileCountAllocation);
75 EB_DELETE_PTR_ARRAY(obj->epMvNeighborArray, obj->totalTileCountAllocation);
76 EB_DELETE_PTR_ARRAY(obj->epSkipFlagNeighborArray, obj->totalTileCountAllocation);
77 EB_DELETE_PTR_ARRAY(obj->epModeTypeNeighborArray, obj->totalTileCountAllocation);
78 EB_DELETE_PTR_ARRAY(obj->epLeafDepthNeighborArray, obj->totalTileCountAllocation);
79 EB_DELETE_PTR_ARRAY(obj->epLumaReconNeighborArray, obj->totalTileCountAllocation);
80 EB_DELETE_PTR_ARRAY(obj->epCbReconNeighborArray, obj->totalTileCountAllocation);
81 EB_DELETE_PTR_ARRAY(obj->epCrReconNeighborArray, obj->totalTileCountAllocation);
82 EB_DELETE_PTR_ARRAY(obj->epSaoNeighborArray, obj->totalTileCountAllocation);
83 EB_DELETE_PTR_ARRAY(obj->epLumaReconNeighborArray16bit, obj->totalTileCountAllocation);
84 EB_DELETE_PTR_ARRAY(obj->epCbReconNeighborArray16bit, obj->totalTileCountAllocation);
85 EB_DELETE_PTR_ARRAY(obj->epCrReconNeighborArray16bit, obj->totalTileCountAllocation);
86 EB_DELETE_PTR_ARRAY(obj->mdRefinementIntraLumaModeNeighborArray, obj->totalTileCountAllocation);
87 EB_DELETE_PTR_ARRAY(obj->mdRefinementModeTypeNeighborArray, obj->totalTileCountAllocation);
88 EB_DELETE_PTR_ARRAY(obj->mdRefinementLumaReconNeighborArray, obj->totalTileCountAllocation);
89
90 EB_DELETE_PTR_ARRAY(obj->modeTypeNeighborArray, obj->totalTileCountAllocation);
91 EB_DELETE_PTR_ARRAY(obj->leafDepthNeighborArray, obj->totalTileCountAllocation);
92 EB_DELETE_PTR_ARRAY(obj->skipFlagNeighborArray, obj->totalTileCountAllocation);
93 EB_DELETE_PTR_ARRAY(obj->intraLumaModeNeighborArray, obj->totalTileCountAllocation);
94
95 for (EB_U8 depth = 0; depth < NEIGHBOR_ARRAY_TOTAL_COUNT; depth++) {
96 EB_DELETE_PTR_ARRAY(obj->mdIntraLumaModeNeighborArray[depth], obj->totalTileCountAllocation);
97 EB_DELETE_PTR_ARRAY(obj->mdMvNeighborArray[depth], obj->totalTileCountAllocation);
98 EB_DELETE_PTR_ARRAY(obj->mdSkipFlagNeighborArray[depth], obj->totalTileCountAllocation);
99 EB_DELETE_PTR_ARRAY(obj->mdModeTypeNeighborArray[depth], obj->totalTileCountAllocation);
100 EB_DELETE_PTR_ARRAY(obj->mdLeafDepthNeighborArray[depth], obj->totalTileCountAllocation);
101 EB_DELETE_PTR_ARRAY(obj->mdLumaReconNeighborArray[depth], obj->totalTileCountAllocation);
102 EB_DELETE_PTR_ARRAY(obj->mdCbReconNeighborArray[depth], obj->totalTileCountAllocation);
103 EB_DELETE_PTR_ARRAY(obj->mdCrReconNeighborArray[depth], obj->totalTileCountAllocation);
104 }
105
106 EB_DELETE_PTR_ARRAY(obj->encDecSegmentCtrl, obj->tileGroupCntAllocation);
107
108 for (EB_U16 tileIdx = 0; tileIdx < obj->totalTileCountAllocation; tileIdx++) {
109 EB_DELETE(obj->entropyCodingInfo[tileIdx]->entropyCoderPtr);
110 EB_DESTROY_MUTEX(obj->entropyCodingInfo[tileIdx]->entropyCodingMutex);
111 }
112 EB_FREE_PTR_ARRAY(obj->entropyCodingInfo, obj->totalTileCountAllocation);
113
114 EB_DESTROY_MUTEX(obj->entropyCodingPicMutex);
115 EB_DESTROY_MUTEX(obj->intraMutex);
116 }
117
118
PictureControlSetCtor(PictureControlSet_t * objectPtr,EB_PTR objectInitDataPtr)119 EB_ERRORTYPE PictureControlSetCtor(
120 PictureControlSet_t *objectPtr,
121 EB_PTR objectInitDataPtr)
122 {
123 PictureControlSetInitData_t *initDataPtr = (PictureControlSetInitData_t*) objectInitDataPtr;
124
125 EbPictureBufferDescInitData_t inputPictureBufferDescInitData;
126 EbPictureBufferDescInitData_t coeffBufferDescInitData;
127
128 // Max/Min CU Sizes
129 const EB_U32 maxCuSize = initDataPtr->lcuSize;
130 EB_U32 encDecSegRow = initDataPtr->encDecSegmentRow;
131 EB_U32 encDecSegCol = initDataPtr->encDecSegmentCol;
132 EB_U16 pictureWidthInLcu = (EB_U16)((initDataPtr->pictureWidth + initDataPtr->lcuSize - 1) / initDataPtr->lcuSize);
133 EB_U16 pictureHeightInLcu = (EB_U16)((initDataPtr->pictureHeight + initDataPtr->lcuSize - 1) / initDataPtr->lcuSize);
134 EB_U32 tileGroupCnt = initDataPtr->tileGroupRow * initDataPtr->tileGroupCol;
135 objectPtr->tileGroupCntAllocation = tileGroupCnt;
136
137 EB_U16 tileIdx;
138 EB_U16 r, c;
139
140 EB_U32 totalTileCount = initDataPtr->tileRowCount * initDataPtr->tileColumnCount;
141 objectPtr->totalTileCountAllocation = totalTileCount;
142
143 // LCUs
144 EB_U16 lcuIndex;
145 EB_U16 lcuOriginX;
146 EB_U16 lcuOriginY;
147 EB_ERRORTYPE return_error = EB_ErrorNone;
148
149 EB_BOOL is16bit = initDataPtr->is16bit;
150 EB_U16 subWidthCMinus1 = (initDataPtr->colorFormat == EB_YUV444 ? 1 : 2) - 1;
151 EB_U16 subHeightCMinus1 = (initDataPtr->colorFormat >= EB_YUV422 ? 1 : 2) - 1;
152
153 objectPtr->dctor = PictureControlSetDctor;
154
155 // Init Picture Init data
156 inputPictureBufferDescInitData.maxWidth = initDataPtr->pictureWidth;
157 inputPictureBufferDescInitData.maxHeight = initDataPtr->pictureHeight;
158 inputPictureBufferDescInitData.bitDepth = initDataPtr->bitDepth;
159 inputPictureBufferDescInitData.colorFormat = initDataPtr->colorFormat;
160 inputPictureBufferDescInitData.bufferEnableMask = PICTURE_BUFFER_DESC_FULL_MASK;
161 inputPictureBufferDescInitData.leftPadding = 0;
162 inputPictureBufferDescInitData.rightPadding = 0;
163 inputPictureBufferDescInitData.topPadding = 0;
164 inputPictureBufferDescInitData.botPadding = 0;
165 inputPictureBufferDescInitData.splitMode = EB_FALSE;
166
167 coeffBufferDescInitData.maxWidth = initDataPtr->pictureWidth;
168 coeffBufferDescInitData.maxHeight = initDataPtr->pictureHeight;
169 coeffBufferDescInitData.bitDepth = EB_16BIT;
170 coeffBufferDescInitData.colorFormat = initDataPtr->colorFormat;
171 coeffBufferDescInitData.bufferEnableMask = PICTURE_BUFFER_DESC_FULL_MASK;
172 coeffBufferDescInitData.leftPadding = 0;
173 coeffBufferDescInitData.rightPadding = 0;
174 coeffBufferDescInitData.topPadding = 0;
175 coeffBufferDescInitData.botPadding = 0;
176 coeffBufferDescInitData.splitMode = EB_FALSE;
177
178 objectPtr->colorFormat = initDataPtr->colorFormat;
179
180 // Reconstructed Picture Buffer
181 if(initDataPtr->is16bit == EB_TRUE){
182 EB_NEW(
183 objectPtr->reconPicture16bitPtr,
184 EbReconPictureBufferDescCtor,
185 (EB_PTR)&coeffBufferDescInitData);
186 }
187 else
188 {
189 EB_NEW(
190 objectPtr->reconPicturePtr,
191 EbReconPictureBufferDescCtor,
192 (EB_PTR)&inputPictureBufferDescInitData);
193 }
194
195 // Cabaccost
196 EB_MALLOC(objectPtr->cabacCost, sizeof(CabacCost_t));
197
198 // Packetization process Bitstream
199 EB_NEW(
200 objectPtr->bitstreamPtr,
201 BitstreamCtor,
202 PACKETIZATION_PROCESS_BUFFER_SIZE);
203
204 // Rate estimation entropy coder
205 EB_NEW(
206 objectPtr->coeffEstEntropyCoderPtr,
207 EntropyCoderCtor,
208 SEGMENT_ENTROPY_BUFFER_SIZE);
209
210 // GOP
211 objectPtr->pictureNumber = 0;
212 objectPtr->temporalLayerIndex = 0;
213 objectPtr->temporalId = 0;
214
215 // LCU Array
216 objectPtr->lcuMaxDepth = (EB_U8) initDataPtr->maxDepth;
217 objectPtr->lcuTotalCount = pictureWidthInLcu * pictureHeightInLcu;
218 EB_ALLOC_PTR_ARRAY(objectPtr->lcuPtrArray, objectPtr->lcuTotalCount);
219
220 lcuOriginX = 0;
221 lcuOriginY = 0;
222
223 for(lcuIndex=0; lcuIndex < objectPtr->lcuTotalCount; ++lcuIndex) {
224 EB_NEW(
225 objectPtr->lcuPtrArray[lcuIndex],
226 LargestCodingUnitCtor,
227 (EB_U8)initDataPtr->lcuSize,
228 initDataPtr->pictureWidth,
229 initDataPtr->pictureHeight,
230 (EB_U16)(lcuOriginX * maxCuSize),
231 (EB_U16)(lcuOriginY * maxCuSize),
232 (EB_U16)lcuIndex,
233 objectPtr);
234 // Increment the Order in coding order (Raster Scan Order)
235 lcuOriginY = (lcuOriginX == pictureWidthInLcu - 1) ? lcuOriginY + 1: lcuOriginY;
236 lcuOriginX = (lcuOriginX == pictureWidthInLcu - 1) ? 0 : lcuOriginX + 1;
237 }
238
239 //ConfigureEdges(objectPtr, maxCuSize);
240
241 // Mode Decision Control config
242 EB_MALLOC_ARRAY(objectPtr->mdcLcuArray, objectPtr->lcuTotalCount);
243 objectPtr->qpArrayStride = (EB_U16)((initDataPtr->pictureWidth + MIN_CU_SIZE - 1) / MIN_CU_SIZE);
244 objectPtr->qpArraySize = ((initDataPtr->pictureWidth + MIN_CU_SIZE - 1) / MIN_CU_SIZE) *
245 ((initDataPtr->pictureHeight + MIN_CU_SIZE - 1) / MIN_CU_SIZE);
246
247 // Allocate memory for vertical edge bS array
248 EB_MALLOC_2D(objectPtr->verticalEdgeBSArray, objectPtr->lcuTotalCount, VERTICAL_EDGE_BS_ARRAY_SIZE);
249
250 // Allocate memory for horizontal edge bS array
251 EB_MALLOC_2D(objectPtr->horizontalEdgeBSArray, objectPtr->lcuTotalCount, HORIZONTAL_EDGE_BS_ARRAY_SIZE);
252
253 // Allocate memory for qp array (used by DLF)
254 EB_MALLOC_ARRAY(objectPtr->qpArray, objectPtr->qpArraySize);
255 EB_MALLOC_ARRAY(objectPtr->entropyQpArray, objectPtr->qpArraySize);
256 // Allocate memory for cbf array (used by DLF)
257 EB_MALLOC_ARRAY(objectPtr->cbfMapArray, ((initDataPtr->pictureWidth >> 2) * (initDataPtr->pictureHeight >> 2)));
258
259 // Jing: TO enable multi-tile, need to have neighbor per tile for EncodePass
260 EB_ALLOC_PTR_ARRAY(objectPtr->epIntraLumaModeNeighborArray, totalTileCount);
261 EB_ALLOC_PTR_ARRAY(objectPtr->epMvNeighborArray , totalTileCount);
262 EB_ALLOC_PTR_ARRAY(objectPtr->epSkipFlagNeighborArray, totalTileCount);
263 EB_ALLOC_PTR_ARRAY(objectPtr->epModeTypeNeighborArray, totalTileCount);
264 EB_ALLOC_PTR_ARRAY(objectPtr->epLeafDepthNeighborArray, totalTileCount);
265 EB_ALLOC_PTR_ARRAY(objectPtr->epLumaReconNeighborArray, totalTileCount);
266 EB_ALLOC_PTR_ARRAY(objectPtr->epCbReconNeighborArray, totalTileCount);
267 EB_ALLOC_PTR_ARRAY(objectPtr->epCrReconNeighborArray, totalTileCount);
268 EB_ALLOC_PTR_ARRAY(objectPtr->epSaoNeighborArray, totalTileCount);
269 EB_ALLOC_PTR_ARRAY(objectPtr->epLumaReconNeighborArray16bit, totalTileCount);
270 EB_ALLOC_PTR_ARRAY(objectPtr->epCbReconNeighborArray16bit, totalTileCount);
271 EB_ALLOC_PTR_ARRAY(objectPtr->epCrReconNeighborArray16bit, totalTileCount);
272 EB_ALLOC_PTR_ARRAY(objectPtr->mdRefinementIntraLumaModeNeighborArray, totalTileCount);
273 EB_ALLOC_PTR_ARRAY(objectPtr->mdRefinementModeTypeNeighborArray, totalTileCount);
274 EB_ALLOC_PTR_ARRAY(objectPtr->mdRefinementLumaReconNeighborArray, totalTileCount);
275
276 // For entropy
277 EB_ALLOC_PTR_ARRAY(objectPtr->modeTypeNeighborArray, totalTileCount);
278 EB_ALLOC_PTR_ARRAY(objectPtr->leafDepthNeighborArray, totalTileCount);
279 EB_ALLOC_PTR_ARRAY(objectPtr->skipFlagNeighborArray, totalTileCount);
280 EB_ALLOC_PTR_ARRAY(objectPtr->intraLumaModeNeighborArray,totalTileCount);
281
282
283 // Mode Decision Neighbor Arrays
284 for (EB_U8 depth = 0; depth < NEIGHBOR_ARRAY_TOTAL_COUNT; depth++) {
285 EB_ALLOC_PTR_ARRAY(objectPtr->mdIntraLumaModeNeighborArray[depth], totalTileCount);
286 EB_ALLOC_PTR_ARRAY(objectPtr->mdMvNeighborArray[depth], totalTileCount);
287 EB_ALLOC_PTR_ARRAY(objectPtr->mdSkipFlagNeighborArray[depth], totalTileCount);
288 EB_ALLOC_PTR_ARRAY(objectPtr->mdModeTypeNeighborArray[depth], totalTileCount);
289 EB_ALLOC_PTR_ARRAY(objectPtr->mdLeafDepthNeighborArray[depth], totalTileCount);
290 EB_ALLOC_PTR_ARRAY(objectPtr->mdLumaReconNeighborArray[depth], totalTileCount);
291 EB_ALLOC_PTR_ARRAY(objectPtr->mdCbReconNeighborArray[depth], totalTileCount);
292 EB_ALLOC_PTR_ARRAY(objectPtr->mdCrReconNeighborArray[depth], totalTileCount);
293 }
294
295 for (r = 0; r < initDataPtr->tileRowCount; r++) {
296 for (c = 0; c < initDataPtr->tileColumnCount; c++) {
297 tileIdx = r * initDataPtr->tileColumnCount + c;
298 for (EB_U8 depth = 0; depth < NEIGHBOR_ARRAY_TOTAL_COUNT; depth++) {
299 EB_NEW(
300 objectPtr->mdIntraLumaModeNeighborArray[depth][tileIdx],
301 NeighborArrayUnitCtor,
302 MAX_PICTURE_WIDTH_SIZE,
303 MAX_PICTURE_HEIGHT_SIZE,
304 sizeof(EB_U8),
305 PU_NEIGHBOR_ARRAY_GRANULARITY,
306 PU_NEIGHBOR_ARRAY_GRANULARITY,
307 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
308
309 EB_NEW(
310 objectPtr->mdMvNeighborArray[depth][tileIdx],
311 NeighborArrayUnitCtor,
312 MAX_PICTURE_WIDTH_SIZE,
313 MAX_PICTURE_HEIGHT_SIZE,
314 sizeof(MvUnit_t),
315 PU_NEIGHBOR_ARRAY_GRANULARITY,
316 PU_NEIGHBOR_ARRAY_GRANULARITY,
317 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
318
319 EB_NEW(
320 objectPtr->mdSkipFlagNeighborArray[depth][tileIdx],
321 NeighborArrayUnitCtor,
322 MAX_PICTURE_WIDTH_SIZE,
323 MAX_PICTURE_HEIGHT_SIZE,
324 sizeof(EB_U8),
325 CU_NEIGHBOR_ARRAY_GRANULARITY,
326 CU_NEIGHBOR_ARRAY_GRANULARITY,
327 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
328
329 EB_NEW(
330 objectPtr->mdModeTypeNeighborArray[depth][tileIdx],
331 NeighborArrayUnitCtor,
332 MAX_PICTURE_WIDTH_SIZE,
333 MAX_PICTURE_HEIGHT_SIZE,
334 sizeof(EB_U8),
335 PU_NEIGHBOR_ARRAY_GRANULARITY,
336 PU_NEIGHBOR_ARRAY_GRANULARITY,
337 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
338
339 EB_NEW(
340 objectPtr->mdLeafDepthNeighborArray[depth][tileIdx],
341 NeighborArrayUnitCtor,
342 MAX_PICTURE_WIDTH_SIZE,
343 MAX_PICTURE_HEIGHT_SIZE,
344 sizeof(EB_U8),
345 CU_NEIGHBOR_ARRAY_GRANULARITY,
346 CU_NEIGHBOR_ARRAY_GRANULARITY,
347 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
348
349 EB_NEW(
350 objectPtr->mdLumaReconNeighborArray[depth][tileIdx],
351 NeighborArrayUnitCtor,
352 MAX_PICTURE_WIDTH_SIZE,
353 MAX_PICTURE_HEIGHT_SIZE,
354 sizeof(EB_U8),
355 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
356 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
357 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
358
359 EB_NEW(
360 objectPtr->mdCbReconNeighborArray[depth][tileIdx],
361 NeighborArrayUnitCtor,
362 MAX_PICTURE_WIDTH_SIZE >> 1,
363 MAX_PICTURE_HEIGHT_SIZE >> 1,
364 sizeof(EB_U8),
365 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
366 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
367 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
368
369 EB_NEW(
370 objectPtr->mdCrReconNeighborArray[depth][tileIdx],
371 NeighborArrayUnitCtor,
372 MAX_PICTURE_WIDTH_SIZE >> 1,
373 MAX_PICTURE_HEIGHT_SIZE >> 1,
374 sizeof(EB_U8),
375 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
376 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
377 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
378 }
379
380 EB_NEW(
381 objectPtr->mdRefinementIntraLumaModeNeighborArray[tileIdx],
382 NeighborArrayUnitCtor,
383 MAX_PICTURE_WIDTH_SIZE,
384 MAX_PICTURE_HEIGHT_SIZE,
385 sizeof(EB_U8),
386 PU_NEIGHBOR_ARRAY_GRANULARITY,
387 PU_NEIGHBOR_ARRAY_GRANULARITY,
388 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
389
390 EB_NEW(
391 objectPtr->mdRefinementModeTypeNeighborArray[tileIdx],
392 NeighborArrayUnitCtor,
393 MAX_PICTURE_WIDTH_SIZE,
394 MAX_PICTURE_HEIGHT_SIZE,
395 sizeof(EB_U8),
396 PU_NEIGHBOR_ARRAY_GRANULARITY,
397 PU_NEIGHBOR_ARRAY_GRANULARITY,
398 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
399
400 EB_NEW(
401 objectPtr->mdRefinementLumaReconNeighborArray[tileIdx],
402 NeighborArrayUnitCtor,
403 MAX_PICTURE_WIDTH_SIZE,
404 MAX_PICTURE_HEIGHT_SIZE,
405 sizeof(EB_U8),
406 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
407 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
408 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
409
410 // Encode Pass Neighbor Arrays
411 EB_NEW(
412 objectPtr->epIntraLumaModeNeighborArray[tileIdx],
413 NeighborArrayUnitCtor,
414 MAX_PICTURE_WIDTH_SIZE, //Jing: change to tile size
415 MAX_PICTURE_HEIGHT_SIZE,
416 sizeof(EB_U8),
417 PU_NEIGHBOR_ARRAY_GRANULARITY,
418 PU_NEIGHBOR_ARRAY_GRANULARITY,
419 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
420
421 EB_NEW(
422 objectPtr->epMvNeighborArray[tileIdx],
423 NeighborArrayUnitCtor,
424 MAX_PICTURE_WIDTH_SIZE,
425 MAX_PICTURE_HEIGHT_SIZE,
426 sizeof(MvUnit_t),
427 PU_NEIGHBOR_ARRAY_GRANULARITY,
428 PU_NEIGHBOR_ARRAY_GRANULARITY,
429 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
430
431 EB_NEW(
432 objectPtr->epSkipFlagNeighborArray[tileIdx],
433 NeighborArrayUnitCtor,
434 MAX_PICTURE_WIDTH_SIZE,
435 MAX_PICTURE_HEIGHT_SIZE,
436 sizeof(EB_U8),
437 CU_NEIGHBOR_ARRAY_GRANULARITY,
438 CU_NEIGHBOR_ARRAY_GRANULARITY,
439 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
440
441 EB_NEW(
442 objectPtr->epModeTypeNeighborArray[tileIdx],
443 NeighborArrayUnitCtor,
444 MAX_PICTURE_WIDTH_SIZE,
445 MAX_PICTURE_HEIGHT_SIZE,
446 sizeof(EB_U8),
447 PU_NEIGHBOR_ARRAY_GRANULARITY,
448 PU_NEIGHBOR_ARRAY_GRANULARITY,
449 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
450
451 EB_NEW(
452 objectPtr->epLeafDepthNeighborArray[tileIdx],
453 NeighborArrayUnitCtor,
454 MAX_PICTURE_WIDTH_SIZE,
455 MAX_PICTURE_HEIGHT_SIZE,
456 sizeof(EB_U8),
457 CU_NEIGHBOR_ARRAY_GRANULARITY,
458 CU_NEIGHBOR_ARRAY_GRANULARITY,
459 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
460
461 EB_NEW(
462 objectPtr->epLumaReconNeighborArray[tileIdx],
463 NeighborArrayUnitCtor,
464 MAX_PICTURE_WIDTH_SIZE,
465 MAX_PICTURE_HEIGHT_SIZE,
466 sizeof(EB_U8),
467 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
468 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
469 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
470
471 EB_NEW(
472 objectPtr->epCbReconNeighborArray[tileIdx],
473 NeighborArrayUnitCtor,
474 MAX_PICTURE_WIDTH_SIZE >> subWidthCMinus1,
475 MAX_PICTURE_HEIGHT_SIZE >> subHeightCMinus1,
476 sizeof(EB_U8),
477 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
478 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
479 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
480
481 EB_NEW(
482 objectPtr->epCrReconNeighborArray[tileIdx],
483 NeighborArrayUnitCtor,
484 MAX_PICTURE_WIDTH_SIZE >> subWidthCMinus1,
485 MAX_PICTURE_HEIGHT_SIZE >> subHeightCMinus1,
486 sizeof(EB_U8),
487 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
488 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
489 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
490
491 if (is16bit) {
492 EB_NEW(
493 objectPtr->epLumaReconNeighborArray16bit[tileIdx],
494 NeighborArrayUnitCtor,
495 MAX_PICTURE_WIDTH_SIZE,
496 MAX_PICTURE_HEIGHT_SIZE,
497 sizeof(EB_U16),
498 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
499 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
500 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
501
502 EB_NEW(
503 objectPtr->epCbReconNeighborArray16bit[tileIdx],
504 NeighborArrayUnitCtor,
505 MAX_PICTURE_WIDTH_SIZE >> subWidthCMinus1,
506 MAX_PICTURE_HEIGHT_SIZE >> subHeightCMinus1,
507 sizeof(EB_U16),
508 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
509 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
510 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
511
512 EB_NEW(
513 objectPtr->epCrReconNeighborArray16bit[tileIdx],
514 NeighborArrayUnitCtor,
515 MAX_PICTURE_WIDTH_SIZE >> subWidthCMinus1,
516 MAX_PICTURE_HEIGHT_SIZE >> subHeightCMinus1,
517 sizeof(EB_U16),
518 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
519 SAMPLE_NEIGHBOR_ARRAY_GRANULARITY,
520 NEIGHBOR_ARRAY_UNIT_FULL_MASK);
521 }
522
523 EB_NEW(
524 objectPtr->epSaoNeighborArray[tileIdx],
525 NeighborArrayUnitCtor,
526 MAX_PICTURE_WIDTH_SIZE,
527 MAX_PICTURE_HEIGHT_SIZE,
528 sizeof(SaoParameters_t),
529 LCU_NEIGHBOR_ARRAY_GRANULARITY,
530 LCU_NEIGHBOR_ARRAY_GRANULARITY,
531 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
532
533
534 // Entropy Coding Neighbor Arrays
535 EB_NEW(
536 objectPtr->modeTypeNeighborArray[tileIdx],
537 NeighborArrayUnitCtor,
538 MAX_PICTURE_WIDTH_SIZE,
539 MAX_PICTURE_HEIGHT_SIZE,
540 sizeof(EB_U8),
541 PU_NEIGHBOR_ARRAY_GRANULARITY,
542 PU_NEIGHBOR_ARRAY_GRANULARITY,
543 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
544
545 EB_NEW(
546 objectPtr->leafDepthNeighborArray[tileIdx],
547 NeighborArrayUnitCtor,
548 MAX_PICTURE_WIDTH_SIZE,
549 MAX_PICTURE_HEIGHT_SIZE,
550 sizeof(EB_U8),
551 CU_NEIGHBOR_ARRAY_GRANULARITY,
552 CU_NEIGHBOR_ARRAY_GRANULARITY,
553 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
554
555 EB_NEW(
556 objectPtr->skipFlagNeighborArray[tileIdx],
557 NeighborArrayUnitCtor,
558 MAX_PICTURE_WIDTH_SIZE,
559 MAX_PICTURE_HEIGHT_SIZE,
560 sizeof(EB_U8),
561 CU_NEIGHBOR_ARRAY_GRANULARITY,
562 CU_NEIGHBOR_ARRAY_GRANULARITY,
563 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
564
565 EB_NEW(
566 objectPtr->intraLumaModeNeighborArray[tileIdx],
567 NeighborArrayUnitCtor,
568 MAX_PICTURE_WIDTH_SIZE,
569 MAX_PICTURE_HEIGHT_SIZE,
570 sizeof(EB_U8),
571 PU_NEIGHBOR_ARRAY_GRANULARITY,
572 PU_NEIGHBOR_ARRAY_GRANULARITY,
573 NEIGHBOR_ARRAY_UNIT_TOP_AND_LEFT_ONLY_MASK);
574 }
575 }
576
577 // Note - non-zero offsets are not supported (to be fixed later in DLF chroma filtering)
578 objectPtr->cbQpOffset = 0;
579 objectPtr->crQpOffset = 0;
580
581 objectPtr->sliceLevelChromaQpFlag = EB_TRUE;
582 // slice level chroma QP offsets
583 objectPtr->sliceCbQpOffset = 0;
584 objectPtr->sliceCrQpOffset = 0;
585
586 //objectPtr->totalNumBits = 0;
587
588 // Error Resilience
589 objectPtr->constrainedIntraFlag = EB_FALSE;
590
591 //Jing:
592 //Alloc segment per tile group
593 // Segments
594 EB_ALLOC_PTR_ARRAY(objectPtr->encDecSegmentCtrl, tileGroupCnt);
595
596 for (EB_U32 tileGroupIdx = 0; tileGroupIdx < tileGroupCnt; tileGroupIdx++) {
597 //Can reduce encDecSegCol and encDecSegRow a bit to save memory
598 EB_NEW(
599 objectPtr->encDecSegmentCtrl[tileGroupIdx],
600 EncDecSegmentsCtor,
601 encDecSegCol,
602 encDecSegRow);
603 }
604
605 EB_ALLOC_PTR_ARRAY(objectPtr->entropyCodingInfo, totalTileCount);
606 for (tileIdx = 0; tileIdx < totalTileCount; tileIdx++) {
607 // Entropy Rows per tile
608 EB_MALLOC(objectPtr->entropyCodingInfo[tileIdx], sizeof(EntropyTileInfo));
609 EB_CREATE_MUTEX(objectPtr->entropyCodingInfo[tileIdx]->entropyCodingMutex);
610
611 // Entropy Coder
612 EB_NEW(
613 objectPtr->entropyCodingInfo[tileIdx]->entropyCoderPtr,
614 EntropyCoderCtor,
615 SEGMENT_ENTROPY_BUFFER_SIZE);
616 }
617
618 // Entropy picture level mutex
619 EB_CREATE_MUTEX(objectPtr->entropyCodingPicMutex);
620
621 EB_CREATE_MUTEX(objectPtr->intraMutex);
622
623 objectPtr->encDecCodedLcuCount = 0;
624 objectPtr->resetDone = EB_FALSE;
625
626 return EB_ErrorNone;
627 }
628
629
PictureControlSetCreator(EB_PTR * objectDblPtr,EB_PTR objectInitDataPtr)630 EB_ERRORTYPE PictureControlSetCreator(
631 EB_PTR *objectDblPtr,
632 EB_PTR objectInitDataPtr)
633 {
634 PictureControlSet_t *objectPtr;
635
636 *objectDblPtr = NULL;
637 EB_NEW(objectPtr, PictureControlSetCtor, objectInitDataPtr);
638 *objectDblPtr = objectPtr;
639
640 return EB_ErrorNone;
641 }
642
PictureParentControlSetDctor(EB_PTR p)643 static void PictureParentControlSetDctor(EB_PTR p)
644 {
645 PictureParentControlSet_t *obj = (PictureParentControlSet_t*)p;
646
647 EB_FREE_ARRAY(obj->tileInfoArray);
648 EB_FREE_ARRAY(obj->tileGroupInfoArray);
649
650 if(obj->isChromaDownSamplePictureOwner)
651 EB_DELETE(obj->chromaDownSamplePicturePtr);
652
653 EB_FREE_2D(obj->variance);
654 EB_FREE_2D(obj->yMean);
655 EB_FREE_2D(obj->cbMean);
656 EB_FREE_2D(obj->crMean);
657
658 EB_FREE_ARRAY(obj->lcuEdgeInfoArray);
659
660 // Histograms
661 if (obj->pictureHistogram) {
662 for (EB_U32 regionInPictureWidthIndex = 0; regionInPictureWidthIndex < MAX_NUMBER_OF_REGIONS_IN_WIDTH; regionInPictureWidthIndex++) {
663 if (obj->pictureHistogram[regionInPictureWidthIndex]) {
664 for (EB_U32 regionInPictureHeightIndex = 0; regionInPictureHeightIndex < MAX_NUMBER_OF_REGIONS_IN_HEIGHT; regionInPictureHeightIndex++)
665 EB_FREE_2D(obj->pictureHistogram[regionInPictureWidthIndex][regionInPictureHeightIndex]);
666 }
667 }
668 EB_FREE_2D(obj->pictureHistogram);
669 }
670
671 for (EB_U16 lcuIndex = 0; lcuIndex < obj->lcuTotalCount; ++lcuIndex) {
672 EB_FREE_ARRAY(obj->oisCu32Cu16Results[lcuIndex]->sortedOisCandidate[0]);
673 }
674 EB_FREE_2D(obj->oisCu32Cu16Results);
675
676 for (EB_U16 lcuIndex = 0; lcuIndex < obj->lcuTotalCount; ++lcuIndex) {
677 EB_FREE_ARRAY(obj->oisCu8Results[lcuIndex]->sortedOisCandidate[0]);
678 }
679 EB_FREE_2D(obj->oisCu8Results);
680
681 EB_FREE_2D(obj->meResults);
682 EB_FREE_ARRAY(obj->rcMEdistortion);
683 EB_FREE_ARRAY(obj->meDistortionHistogram);
684 EB_FREE_ARRAY(obj->oisDistortionHistogram);
685 EB_FREE_ARRAY(obj->intraSadIntervalIndex);
686 EB_FREE_ARRAY(obj->interSadIntervalIndex);
687 EB_FREE_ARRAY(obj->zzCostArray);
688 EB_FREE_ARRAY(obj->nonMovingIndexArray);
689 EB_FREE_ARRAY(obj->similarColocatedLcuArray);
690
691 // similar Colocated Lcu array
692 EB_FREE_ARRAY(obj->similarColocatedLcuArrayAllLayers);
693
694 // LCU noise variance array
695 EB_FREE_ARRAY(obj->lcuFlatNoiseArray);
696 EB_FREE_ARRAY(obj->lcuVarianceOfVarianceOverTime);
697 EB_FREE_ARRAY(obj->isLcuHomogeneousOverTime);
698 EB_FREE_ARRAY(obj->edgeResultsPtr);
699 EB_FREE_ARRAY(obj->sharpEdgeLcuFlag);
700 EB_FREE_ARRAY(obj->failingMotionLcuFlag);
701 EB_FREE_ARRAY(obj->uncoveredAreaLcuFlag);
702 EB_FREE_ARRAY(obj->lcuHomogeneousAreaArray);
703
704 EB_FREE_2D(obj->varOfVar32x32BasedLcuArray);
705 EB_FREE_ARRAY(obj->cmplxStatusLcu);
706 EB_FREE_ARRAY(obj->lcuIsolatedNonHomogeneousAreaArray);
707 EB_FREE_2D(obj->lcuYSrcEnergyCuArray);
708 EB_FREE_2D(obj->lcuYSrcMeanCuArray);
709 EB_FREE_ARRAY(obj->lcuCmplxContrastArray);
710 EB_FREE_ARRAY(obj->lcuStatArray);
711 EB_FREE_ARRAY(obj->complexLcuArray);
712 EB_FREE_ARRAY(obj->lcuMdModeArray);
713 EB_FREE_ARRAY(obj->segmentOvArray);
714
715 EB_DESTROY_MUTEX(obj->rcDistortionHistogramMutex);
716 }
717
PictureParentControlSetCtor(PictureParentControlSet_t * objectPtr,EB_PTR objectInitDataPtr)718 EB_ERRORTYPE PictureParentControlSetCtor(
719 PictureParentControlSet_t *objectPtr,
720 EB_PTR objectInitDataPtr)
721 {
722 PictureControlSetInitData_t *initDataPtr = (PictureControlSetInitData_t*) objectInitDataPtr;
723
724 const EB_U16 pictureLcuWidth = (EB_U16)((initDataPtr->pictureWidth + initDataPtr->lcuSize - 1) / initDataPtr->lcuSize);
725 const EB_U16 pictureLcuHeight = (EB_U16)((initDataPtr->pictureHeight + initDataPtr->lcuSize - 1) / initDataPtr->lcuSize);
726 EB_U16 lcuIndex;
727
728 objectPtr->dctor = PictureParentControlSetDctor;
729
730 // Jing: Tiles
731 EB_U32 totalTileCount = initDataPtr->tileRowCount * initDataPtr->tileColumnCount;
732
733 EB_MALLOC_ARRAY(objectPtr->tileInfoArray, totalTileCount);
734 EB_MALLOC_ARRAY(objectPtr->tileGroupInfoArray, totalTileCount);
735
736 objectPtr->pictureWidthInLcu = (EB_U16)((initDataPtr->pictureWidth + initDataPtr->lcuSize - 1) / initDataPtr->lcuSize);
737 objectPtr->pictureHeightInLcu = (EB_U16)((initDataPtr->pictureHeight + initDataPtr->lcuSize - 1) / initDataPtr->lcuSize);
738 objectPtr->tileRowCount = initDataPtr->tileRowCount;
739 objectPtr->tileColumnCount = initDataPtr->tileColumnCount;
740 objectPtr->tileUniformSpacing = 1;
741
742 for (EB_U16 c = 0; c <= objectPtr->tileColumnCount; c++) {
743 objectPtr->tileColStartLcu[c] = c * objectPtr->pictureWidthInLcu / objectPtr->tileColumnCount;
744 }
745 for (EB_U16 r = 0; r <= objectPtr->tileRowCount; r++) {
746 objectPtr->tileRowStartLcu[r] = r * objectPtr->pictureHeightInLcu / objectPtr->tileRowCount;
747 }
748 ConfigureTileInfo(objectPtr, initDataPtr->lcuSize, initDataPtr->pictureWidth, initDataPtr->pictureHeight);
749
750 if (initDataPtr->colorFormat >= EB_YUV422) {
751 EbPictureBufferDescInitData_t inputPictureBufferDescInitData;
752 inputPictureBufferDescInitData.maxWidth = initDataPtr->pictureWidth;
753 inputPictureBufferDescInitData.maxHeight = initDataPtr->pictureHeight;
754 inputPictureBufferDescInitData.bitDepth = EB_8BIT; // Should be 8bit
755 inputPictureBufferDescInitData.bufferEnableMask = PICTURE_BUFFER_DESC_CHROMA_MASK;
756 inputPictureBufferDescInitData.leftPadding = initDataPtr->leftPadding;
757 inputPictureBufferDescInitData.rightPadding = initDataPtr->rightPadding;
758 inputPictureBufferDescInitData.topPadding = initDataPtr->topPadding;
759 inputPictureBufferDescInitData.botPadding = initDataPtr->botPadding;
760 inputPictureBufferDescInitData.colorFormat = EB_YUV420;
761 inputPictureBufferDescInitData.splitMode = EB_FALSE;
762 EB_NEW(
763 objectPtr->chromaDownSamplePicturePtr,
764 EbPictureBufferDescCtor,
765 (EB_PTR)&inputPictureBufferDescInitData);
766 objectPtr->isChromaDownSamplePictureOwner = EB_TRUE;
767 } else if(initDataPtr->colorFormat == EB_YUV420) {
768 objectPtr->chromaDownSamplePicturePtr = EB_NULL;
769 } else {
770 return EB_ErrorBadParameter;
771 }
772
773 // GOP
774 objectPtr->lcuTotalCount = pictureLcuWidth * pictureLcuHeight;
775
776 EB_MALLOC_2D(objectPtr->variance, objectPtr->lcuTotalCount, MAX_ME_PU_COUNT);
777 EB_MALLOC_2D(objectPtr->yMean, objectPtr->lcuTotalCount, MAX_ME_PU_COUNT);
778 EB_MALLOC_2D(objectPtr->cbMean, objectPtr->lcuTotalCount, 21);
779 EB_MALLOC_2D(objectPtr->crMean, objectPtr->lcuTotalCount, 21);
780
781 //LCU edge info
782 EB_MALLOC_ARRAY(objectPtr->lcuEdgeInfoArray, objectPtr->lcuTotalCount);
783 ConfigureLcuEdgeInfo(objectPtr);
784
785 // Histograms
786 EB_CALLOC_2D(objectPtr->pictureHistogram, MAX_NUMBER_OF_REGIONS_IN_WIDTH, MAX_NUMBER_OF_REGIONS_IN_HEIGHT);
787 for (EB_U32 regionInPictureWidthIndex = 0; regionInPictureWidthIndex < MAX_NUMBER_OF_REGIONS_IN_WIDTH; regionInPictureWidthIndex++) { // loop over horizontal regions
788 for (EB_U32 regionInPictureHeightIndex = 0; regionInPictureHeightIndex < MAX_NUMBER_OF_REGIONS_IN_HEIGHT; regionInPictureHeightIndex++) { // loop over vertical regions
789 EB_MALLOC_2D(objectPtr->pictureHistogram[regionInPictureWidthIndex][regionInPictureHeightIndex], 3, HISTOGRAM_NUMBER_OF_BINS);
790 }
791 }
792
793 EB_U32 maxOisCand = MAX(MAX_OIS_0, MAX_OIS_2);
794
795 EB_MALLOC_2D(objectPtr->oisCu32Cu16Results, objectPtr->lcuTotalCount, 1);
796 for (lcuIndex = 0; lcuIndex < objectPtr->lcuTotalCount; ++lcuIndex) {
797 OisCandidate_t* contigousCand;
798 EB_MALLOC_ARRAY(contigousCand, maxOisCand * 21);
799 for (EB_U32 cuIdx = 0; cuIdx < 21; ++cuIdx) {
800 objectPtr->oisCu32Cu16Results[lcuIndex]->sortedOisCandidate[cuIdx] = &contigousCand[cuIdx*maxOisCand];
801 }
802 }
803
804 EB_MALLOC_2D(objectPtr->oisCu8Results, objectPtr->lcuTotalCount, 1);
805 for (lcuIndex = 0; lcuIndex < objectPtr->lcuTotalCount; ++lcuIndex) {
806 OisCandidate_t* contigousCand;
807 EB_MALLOC_ARRAY(contigousCand, maxOisCand * 64);
808 for (EB_U32 cuIdx = 0; cuIdx < 64; ++cuIdx) {
809 objectPtr->oisCu8Results[lcuIndex]->sortedOisCandidate[cuIdx] = &contigousCand[cuIdx*maxOisCand];
810 }
811 }
812
813
814 // Motion Estimation Results
815 objectPtr->maxNumberOfPusPerLcu = SQUARE_PU_COUNT;
816 objectPtr->maxNumberOfMeCandidatesPerPU = 3;
817
818 EB_MALLOC_2D(objectPtr->meResults, objectPtr->lcuTotalCount, 85);
819 EB_MALLOC_ARRAY(objectPtr->rcMEdistortion, objectPtr->lcuTotalCount);
820
821
822 // ME and OIS Distortion Histograms
823 EB_MALLOC_ARRAY(objectPtr->meDistortionHistogram, NUMBER_OF_SAD_INTERVALS);
824
825 EB_MALLOC_ARRAY(objectPtr->oisDistortionHistogram, NUMBER_OF_INTRA_SAD_INTERVALS);
826
827 EB_MALLOC_ARRAY(objectPtr->intraSadIntervalIndex, objectPtr->lcuTotalCount);
828 EB_MALLOC_ARRAY(objectPtr->interSadIntervalIndex, objectPtr->lcuTotalCount);
829
830 // Enhance background for base layer frames: zz SAD array
831 EB_MALLOC_ARRAY(objectPtr->zzCostArray, objectPtr->lcuTotalCount * 64);
832
833 // Non moving index array
834
835 EB_MALLOC_ARRAY(objectPtr->nonMovingIndexArray, objectPtr->lcuTotalCount);
836
837 // similar Colocated Lcu array
838 EB_MALLOC_ARRAY(objectPtr->similarColocatedLcuArray, objectPtr->lcuTotalCount);
839
840 // similar Colocated Lcu array
841 EB_MALLOC_ARRAY(objectPtr->similarColocatedLcuArrayAllLayers, objectPtr->lcuTotalCount);
842
843 // LCU noise variance array
844 EB_MALLOC_ARRAY(objectPtr->lcuFlatNoiseArray, objectPtr->lcuTotalCount);
845 EB_MALLOC_ARRAY(objectPtr->lcuVarianceOfVarianceOverTime, objectPtr->lcuTotalCount);
846 EB_MALLOC_ARRAY(objectPtr->isLcuHomogeneousOverTime, objectPtr->lcuTotalCount);
847 EB_MALLOC_ARRAY(objectPtr->edgeResultsPtr, objectPtr->lcuTotalCount);
848 EB_MALLOC_ARRAY(objectPtr->sharpEdgeLcuFlag, objectPtr->lcuTotalCount);
849 EB_MALLOC_ARRAY(objectPtr->failingMotionLcuFlag, objectPtr->lcuTotalCount);
850 EB_MALLOC_ARRAY(objectPtr->uncoveredAreaLcuFlag, objectPtr->lcuTotalCount);
851 EB_MALLOC_ARRAY(objectPtr->lcuHomogeneousAreaArray, objectPtr->lcuTotalCount);
852
853 EB_MALLOC_2D(objectPtr->varOfVar32x32BasedLcuArray, objectPtr->lcuTotalCount, 4);
854
855 EB_MALLOC_ARRAY(objectPtr->cmplxStatusLcu, objectPtr->lcuTotalCount);
856 EB_MALLOC_ARRAY(objectPtr->lcuIsolatedNonHomogeneousAreaArray, objectPtr->lcuTotalCount);
857
858 EB_MALLOC_2D(objectPtr->lcuYSrcEnergyCuArray, objectPtr->lcuTotalCount, 5);
859
860 EB_MALLOC_2D(objectPtr->lcuYSrcMeanCuArray, objectPtr->lcuTotalCount, 5);
861
862 EB_MALLOC_ARRAY(objectPtr->lcuCmplxContrastArray, objectPtr->lcuTotalCount);
863
864 EB_MALLOC_ARRAY(objectPtr->lcuStatArray, objectPtr->lcuTotalCount);
865
866 EB_MALLOC_ARRAY(objectPtr->complexLcuArray, objectPtr->lcuTotalCount);
867
868 EB_CREATE_MUTEX(objectPtr->rcDistortionHistogramMutex);
869
870 EB_MALLOC_ARRAY(objectPtr->lcuMdModeArray, objectPtr->lcuTotalCount);
871
872 if (initDataPtr->segmentOvEnabled) {
873 EB_MALLOC_ARRAY(objectPtr->segmentOvArray, objectPtr->lcuTotalCount);
874 }
875
876 return EB_ErrorNone;
877 }
878
PictureParentControlSetCreator(EB_PTR * objectDblPtr,EB_PTR objectInitDataPtr)879 EB_ERRORTYPE PictureParentControlSetCreator(
880 EB_PTR *objectDblPtr,
881 EB_PTR objectInitDataPtr)
882 {
883 PictureParentControlSet_t* objectPtr;
884
885 *objectDblPtr = NULL;
886 EB_NEW(objectPtr, PictureParentControlSetCtor, objectInitDataPtr);
887 *objectDblPtr = objectPtr;
888
889 return EB_ErrorNone;
890 }
891