1 /*
2 * Copyright(c) 2018 Intel Corporation
3 * SPDX - License - Identifier: BSD - 2 - Clause - Patent
4 */
5
6 #include <stdlib.h>
7
8 #include "EbPictureControlSet.h"
9 #include "EbReferenceObject.h"
10
11 #include "EbInterPrediction.h"
12 #include "EbMcp.h"
13 #include "EbAvcStyleMcp.h"
14 #include "EbAdaptiveMotionVectorPrediction.h"
15
16 #include "EbModeDecisionProcess.h"
17 #include "EbErrorCodes.h"
18 #include "EbErrorHandling.h"
19
InterPredictionContextDtor(EB_PTR p)20 static void InterPredictionContextDtor(EB_PTR p)
21 {
22 InterPredictionContext_t *obj = (InterPredictionContext_t*)p;
23 EB_DELETE(obj->mcpContext);
24 }
25
InterPredictionContextCtor(InterPredictionContext_t * contextPtr,EB_U16 maxCUWidth,EB_U16 maxCUHeight,EB_BOOL is16bit)26 EB_ERRORTYPE InterPredictionContextCtor(
27 InterPredictionContext_t *contextPtr,
28 EB_U16 maxCUWidth,
29 EB_U16 maxCUHeight,
30 EB_BOOL is16bit)
31
32 {
33 contextPtr->dctor = InterPredictionContextDtor;
34
35 EB_NEW(
36 contextPtr->mcpContext,
37 MotionCompensationPredictionContextCtor,
38 maxCUWidth,
39 maxCUHeight,
40 is16bit);
41
42 return EB_ErrorNone;
43 }
44
45
RoundMvOnTheFly(EB_S16 * motionVector_x,EB_S16 * motionVector_y)46 void RoundMvOnTheFly(
47 EB_S16 *motionVector_x,
48 EB_S16 *motionVector_y)
49 {
50 *motionVector_x = (*motionVector_x + 2)&~0x03;
51 *motionVector_y = (*motionVector_y + 2)&~0x03;
52
53 return;
54 }
55
56
Inter2Nx2NPuPredictionInterpolationFree(ModeDecisionContext_t * mdContextPtr,EB_U32 componentMask,PictureControlSet_t * pictureControlSetPtr,ModeDecisionCandidateBuffer_t * candidateBufferPtr)57 EB_ERRORTYPE Inter2Nx2NPuPredictionInterpolationFree(
58 ModeDecisionContext_t *mdContextPtr,
59 EB_U32 componentMask,
60 PictureControlSet_t *pictureControlSetPtr,
61 ModeDecisionCandidateBuffer_t *candidateBufferPtr)
62 {
63 EB_ERRORTYPE return_error = EB_ErrorNone;
64 EbPictureBufferDesc_t *refPicList0;
65 EbPictureBufferDesc_t *refPicList1;
66 EbReferenceObject_t *referenceObject;
67
68 EB_U32 refList0PosX;
69 EB_U32 refList0PosY;
70 EB_U32 refList1PosX;
71 EB_U32 refList1PosY;
72 const EB_U32 puOriginX = mdContextPtr->cuOriginX;
73 const EB_U32 puOriginY = mdContextPtr->cuOriginY;
74 const EB_U32 puWidth = mdContextPtr->cuStats->size;
75 const EB_U32 puHeight = mdContextPtr->cuStats->size;
76 const EB_U32 puIndex = mdContextPtr->puItr;
77
78 InterPredictionContext_t *contextPtr = (InterPredictionContext_t*)(mdContextPtr->interPredictionContext);
79 EB_U32 puOriginIndex;
80 EB_U32 puChromaOriginIndex;
81 EncodeContext_t *encodeContextPtr = ((SequenceControlSet_t*)(pictureControlSetPtr->sequenceControlSetWrapperPtr->objectPtr))->encodeContextPtr;
82
83 SequenceControlSet_t* sequenceControlSetPtr = ((SequenceControlSet_t*)(pictureControlSetPtr->sequenceControlSetWrapperPtr->objectPtr));
84 EB_BOOL is16bit = (EB_BOOL)(sequenceControlSetPtr->staticConfig.encoderBitDepth > EB_8BIT);
85
86 EB_S16 motionVector_x;
87 EB_S16 motionVector_y;
88
89 if (mdContextPtr->cuUseRefSrcFlag)
90 is16bit = EB_FALSE;
91 switch (candidateBufferPtr->candidatePtr->predictionDirection[puIndex]) {
92 case UNI_PRED_LIST_0:
93
94 if (is16bit) {
95
96 puOriginIndex = ((puOriginY & (63)) * 64) + (puOriginX & (63));
97 puChromaOriginIndex = (((puOriginY & (63)) * 32) + (puOriginX & (63))) >> 1;
98 referenceObject = (EbReferenceObject_t*)pictureControlSetPtr->refPicPtrArray[REF_LIST_0]->objectPtr;
99 refPicList0 = (EbPictureBufferDesc_t*)referenceObject->referencePicture16bit;
100
101 motionVector_x = candidateBufferPtr->candidatePtr->motionVector_x_L0;
102 motionVector_y = candidateBufferPtr->candidatePtr->motionVector_y_L0;
103 if (mdContextPtr->roundMvToInteger) {
104 RoundMvOnTheFly(
105 &motionVector_x,
106 &motionVector_y);
107 }
108
109 refList0PosX = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
110 (EB_S32)(((refPicList0->width) << 2) + MVBOUNDHIGH),
111 (EB_S32)(((puOriginX << 2) + REFPADD_QPEL + motionVector_x))
112 );
113
114 refList0PosY = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
115 (EB_S32)(((refPicList0->height) << 2) + MVBOUNDHIGH),
116 (EB_S32)(((puOriginY << 2) + REFPADD_QPEL + motionVector_y))
117 );
118
119 UnpackUniPredRef10Bit(
120 refPicList0,
121 refList0PosX,
122 refList0PosY,
123 puWidth,
124 puHeight,
125 candidateBufferPtr->predictionPtr,
126 puOriginIndex,
127 puChromaOriginIndex,
128 componentMask,
129 contextPtr->mcpContext->avcStyleMcpIntermediateResultBuf0);
130
131
132 }
133 else {
134 puOriginIndex = ((puOriginY & (63)) * 64) + (puOriginX & (63));
135 puChromaOriginIndex = (((puOriginY & (63)) * 32) + (puOriginX & (63))) >> 1;
136 referenceObject = (EbReferenceObject_t*)pictureControlSetPtr->refPicPtrArray[REF_LIST_0]->objectPtr;
137 refPicList0 = (EbPictureBufferDesc_t*)referenceObject->referencePicture;
138
139 if (mdContextPtr->cuUseRefSrcFlag)
140 refPicList0 = referenceObject->refDenSrcPicture;
141 else
142 refPicList0 = referenceObject->referencePicture;
143
144 motionVector_x = candidateBufferPtr->candidatePtr->motionVector_x_L0;
145 motionVector_y = candidateBufferPtr->candidatePtr->motionVector_y_L0;
146 if (mdContextPtr->roundMvToInteger) {
147 RoundMvOnTheFly(
148 &motionVector_x,
149 &motionVector_y);
150 }
151
152 refList0PosX = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
153 (EB_S32)(((refPicList0->width) << 2) + MVBOUNDHIGH),
154 (EB_S32)(((puOriginX << 2) + REFPADD_QPEL + motionVector_x))
155 );
156
157 refList0PosY = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
158 (EB_S32)(((refPicList0->height) << 2) + MVBOUNDHIGH),
159 (EB_S32)(((puOriginY << 2) + REFPADD_QPEL + motionVector_y))
160 );
161
162 UniPredIFreeRef8Bit(
163 refPicList0,
164 refList0PosX,
165 refList0PosY,
166 puWidth,
167 puHeight,
168 candidateBufferPtr->predictionPtr,
169 puOriginIndex,
170 puChromaOriginIndex,
171 componentMask,
172 contextPtr->mcpContext->avcStyleMcpIntermediateResultBuf0); // temp until mismatch fixed
173 }
174
175 break;
176
177 case UNI_PRED_LIST_1:
178 puOriginIndex = ((puOriginY & (63)) * 64) + (puOriginX & (63));
179 puChromaOriginIndex = (((puOriginY & (63)) * 32) + (puOriginX & (63))) >> 1;
180 referenceObject = (EbReferenceObject_t*)pictureControlSetPtr->refPicPtrArray[REF_LIST_1]->objectPtr;
181
182 if (is16bit) {
183
184 refPicList1 = (EbPictureBufferDesc_t*)referenceObject->referencePicture16bit;
185
186 motionVector_x = candidateBufferPtr->candidatePtr->motionVector_x_L1;
187 motionVector_y = candidateBufferPtr->candidatePtr->motionVector_y_L1;
188 if (mdContextPtr->roundMvToInteger) {
189 RoundMvOnTheFly(
190 &motionVector_x,
191 &motionVector_y);
192 }
193 refList1PosX = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
194 (EB_S32)(((refPicList1->width) << 2) + MVBOUNDHIGH),
195 (EB_S32)(((puOriginX << 2) + REFPADD_QPEL + motionVector_x))
196 );
197 refList1PosY = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
198 (EB_S32)(((refPicList1->height) << 2) + MVBOUNDHIGH),
199 (EB_S32)(((puOriginY << 2) + REFPADD_QPEL + motionVector_y))
200 );
201
202 UnpackUniPredRef10Bit(
203 refPicList1,
204 refList1PosX,
205 refList1PosY,
206 puWidth,
207 puHeight,
208 candidateBufferPtr->predictionPtr,
209 puOriginIndex,
210 puChromaOriginIndex,
211 componentMask,
212 contextPtr->mcpContext->avcStyleMcpIntermediateResultBuf0);
213
214
215
216 }
217 else {
218 refPicList1 = (EbPictureBufferDesc_t*)referenceObject->referencePicture;
219
220 if (mdContextPtr->cuUseRefSrcFlag)
221 refPicList1 = referenceObject->refDenSrcPicture;
222 else
223 refPicList1 = referenceObject->referencePicture;
224
225 motionVector_x = candidateBufferPtr->candidatePtr->motionVector_x_L1;
226 motionVector_y = candidateBufferPtr->candidatePtr->motionVector_y_L1;
227 if (mdContextPtr->roundMvToInteger) {
228 RoundMvOnTheFly(
229 &motionVector_x,
230 &motionVector_y);
231 }
232
233 refList1PosX = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
234 (EB_S32)(((refPicList1->width) << 2) + MVBOUNDHIGH),
235 (EB_S32)(((puOriginX << 2) + REFPADD_QPEL + motionVector_x))
236 );
237 refList1PosY = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
238 (EB_S32)(((refPicList1->height) << 2) + MVBOUNDHIGH),
239 (EB_S32)(((puOriginY << 2) + REFPADD_QPEL + motionVector_y))
240 );
241
242 UniPredIFreeRef8Bit(
243 refPicList1,
244 refList1PosX,
245 refList1PosY,
246 puWidth,
247 puHeight,
248 candidateBufferPtr->predictionPtr,
249 puOriginIndex,
250 puChromaOriginIndex,
251 componentMask,
252 contextPtr->mcpContext->avcStyleMcpIntermediateResultBuf0);
253
254 }
255
256 break;
257
258 case BI_PRED:
259 puOriginIndex = ((puOriginY & (63)) * 64) + (puOriginX & (63));
260 puChromaOriginIndex = (((puOriginY & (63)) * 32) + (puOriginX & (63))) >> 1;
261
262 // List0
263 referenceObject = (EbReferenceObject_t*)pictureControlSetPtr->refPicPtrArray[REF_LIST_0]->objectPtr;
264
265 if (is16bit) {
266
267 refPicList0 = (EbPictureBufferDesc_t*)referenceObject->referencePicture16bit;
268
269 motionVector_x = candidateBufferPtr->candidatePtr->motionVector_x_L0;
270 motionVector_y = candidateBufferPtr->candidatePtr->motionVector_y_L0;
271 if (mdContextPtr->roundMvToInteger) {
272 RoundMvOnTheFly(
273 &motionVector_x,
274 &motionVector_y);
275 }
276
277 refList0PosX = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
278 (EB_S32)(((refPicList0->width) << 2) + MVBOUNDHIGH),
279 (EB_S32)(((puOriginX << 2) + REFPADD_QPEL + motionVector_x))
280 );
281 refList0PosY = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
282 (EB_S32)(((refPicList0->height) << 2) + MVBOUNDHIGH),
283 (EB_S32)(((puOriginY << 2) + REFPADD_QPEL + motionVector_y))
284 );
285
286 // List1
287 referenceObject = (EbReferenceObject_t *)pictureControlSetPtr->refPicPtrArray[REF_LIST_1]->objectPtr;
288 refPicList1 = (EbPictureBufferDesc_t*)referenceObject->referencePicture16bit;
289
290 motionVector_x = candidateBufferPtr->candidatePtr->motionVector_x_L1;
291 motionVector_y = candidateBufferPtr->candidatePtr->motionVector_y_L1;
292 if (mdContextPtr->roundMvToInteger) {
293 RoundMvOnTheFly(
294 &motionVector_x,
295 &motionVector_y);
296 }
297
298 refList1PosX = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
299 (EB_S32)(((refPicList1->width) << 2) + MVBOUNDHIGH),
300 (EB_S32)(((puOriginX << 2) + REFPADD_QPEL + motionVector_x))
301 );
302 refList1PosY = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
303 (EB_S32)(((refPicList1->height) << 2) + MVBOUNDHIGH),
304 (EB_S32)(((puOriginY << 2) + REFPADD_QPEL + motionVector_y))
305 );
306
307 UnpackBiPredRef10Bit(
308 refPicList0,
309 refPicList1,
310 refList0PosX,
311 refList0PosY,
312 refList1PosX,
313 refList1PosY,
314 puWidth,
315 puHeight,
316 candidateBufferPtr->predictionPtr,
317 puOriginIndex,
318 puChromaOriginIndex,
319 componentMask,
320 contextPtr->mcpContext->avcStyleMcpIntermediateResultBuf0,
321 contextPtr->mcpContext->avcStyleMcpIntermediateResultBuf1,
322 contextPtr->mcpContext->avcStyleMcpTwoDInterpolationFirstPassFilterResultBuf);
323
324
325
326 }
327 else {
328 refPicList0 = (EbPictureBufferDesc_t*)referenceObject->referencePicture;
329
330 if (mdContextPtr->cuUseRefSrcFlag)
331 refPicList0 = referenceObject->refDenSrcPicture;
332 else
333 refPicList0 = referenceObject->referencePicture;
334
335
336 motionVector_x = candidateBufferPtr->candidatePtr->motionVector_x_L0;
337 motionVector_y = candidateBufferPtr->candidatePtr->motionVector_y_L0;
338 if (mdContextPtr->roundMvToInteger) {
339 RoundMvOnTheFly(
340 &motionVector_x,
341 &motionVector_y);
342 }
343
344 refList0PosX = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
345 (EB_S32)(((refPicList0->width) << 2) + MVBOUNDHIGH),
346 (EB_S32)(((puOriginX << 2) + REFPADD_QPEL + motionVector_x))
347 );
348 refList0PosY = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
349 (EB_S32)(((refPicList0->height) << 2) + MVBOUNDHIGH),
350 (EB_S32)(((puOriginY << 2) + REFPADD_QPEL + motionVector_y))
351 );
352
353 // List1
354 referenceObject = (EbReferenceObject_t *)pictureControlSetPtr->refPicPtrArray[REF_LIST_1]->objectPtr;
355 refPicList1 = (EbPictureBufferDesc_t*)referenceObject->referencePicture;
356
357 if (mdContextPtr->cuUseRefSrcFlag)
358 refPicList1 = referenceObject->refDenSrcPicture;
359 else
360 refPicList1 = referenceObject->referencePicture;
361
362 motionVector_x = candidateBufferPtr->candidatePtr->motionVector_x_L1;
363 motionVector_y = candidateBufferPtr->candidatePtr->motionVector_y_L1;
364 if (mdContextPtr->roundMvToInteger) {
365 RoundMvOnTheFly(
366 &motionVector_x,
367 &motionVector_y);
368 }
369
370 refList1PosX = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
371 (EB_S32)(((refPicList1->width) << 2) + MVBOUNDHIGH),
372 (EB_S32)(((puOriginX << 2) + REFPADD_QPEL + motionVector_x))
373 );
374 refList1PosY = (EB_U32)CLIP3((EB_S32)MVBOUNDLOW,
375 (EB_S32)(((refPicList1->height) << 2) + MVBOUNDHIGH),
376 (EB_S32)(((puOriginY << 2) + REFPADD_QPEL + motionVector_y))
377 );
378
379 BiPredIFreeRef8Bit(
380 refPicList0,
381 refPicList1,
382 refList0PosX,
383 refList0PosY,
384 refList1PosX,
385 refList1PosY,
386 puWidth,
387 puHeight,
388 candidateBufferPtr->predictionPtr,
389 puOriginIndex,
390 puChromaOriginIndex,
391 componentMask,
392 contextPtr->mcpContext->avcStyleMcpIntermediateResultBuf0,
393 contextPtr->mcpContext->avcStyleMcpIntermediateResultBuf1,
394 contextPtr->mcpContext->avcStyleMcpTwoDInterpolationFirstPassFilterResultBuf);
395 }
396
397 break;
398
399 default:
400 CHECK_REPORT_ERROR_NC(
401 encodeContextPtr->appCallbackPtr,
402 EB_ENC_INTER_PRED_ERROR0);
403 break;
404 }
405
406 return return_error;
407 }
408
409
410
411 /***************************************************
412 * PreLoad Reference Block for 16bit mode
413 ***************************************************/
UnPackReferenceBlock(EbPictureBufferDesc_t * refFramePic,EB_U32 posX,EB_U32 posY,EB_U32 puWidth,EB_U32 puHeight,EbPictureBufferDesc_t * dst,EB_U32 componentMask)414 void UnPackReferenceBlock(
415 EbPictureBufferDesc_t *refFramePic,
416 EB_U32 posX,
417 EB_U32 posY,
418 EB_U32 puWidth,
419 EB_U32 puHeight,
420 EbPictureBufferDesc_t *dst,
421 EB_U32 componentMask)
422 {
423
424 puWidth += 8; // 4 + PU_WIDTH + 4 to account for 8-tap interpolation
425 puHeight += 8; // 4 + PU_WIDTH + 4 to account for 8-tap interpolation
426 EB_U32 inPosx = (posX >> 2) - 4; // -4 to account for 8-tap interpolation
427 EB_U32 inPosy = (posY >> 2) - 4; // -4 to account for 8-tap interpolation
428 EB_U16 *ptr16;
429
430 if (componentMask & PICTURE_BUFFER_DESC_LUMA_MASK) {
431 ptr16 = (EB_U16 *)refFramePic->bufferY + inPosx + inPosy*refFramePic->strideY;
432
433 Extract8BitdataSafeSub(
434 ptr16,
435 refFramePic->strideY,
436 dst->bufferY,
437 dst->strideY,
438 puWidth,
439 puHeight
440 );
441 }
442
443 if (componentMask & PICTURE_BUFFER_DESC_CHROMA_MASK) {
444 ptr16 = (EB_U16 *)refFramePic->bufferCb + (inPosx >> 1) + (inPosy >> 1) * refFramePic->strideCb;
445
446 Extract8BitdataSafeSub(
447 ptr16,
448 refFramePic->strideCb,
449 dst->bufferCb,
450 dst->strideCb,
451 puWidth >> 1,
452 puHeight >> 1
453 );
454
455 ptr16 = (EB_U16 *)refFramePic->bufferCr + (inPosx >> 1) + (inPosy >> 1) *refFramePic->strideCr;
456
457 Extract8BitdataSafeSub(
458 ptr16,
459 refFramePic->strideCr,
460 dst->bufferCr,
461 dst->strideCr,
462 puWidth >> 1,
463 puHeight >> 1
464 );
465 }
466
467 }
468
Inter2Nx2NPuPredictionHevc(ModeDecisionContext_t * mdContextPtr,EB_U32 componentMask,PictureControlSet_t * pictureControlSetPtr,ModeDecisionCandidateBuffer_t * candidateBufferPtr)469 EB_ERRORTYPE Inter2Nx2NPuPredictionHevc(
470 ModeDecisionContext_t *mdContextPtr,
471 EB_U32 componentMask,
472 PictureControlSet_t *pictureControlSetPtr,
473 ModeDecisionCandidateBuffer_t *candidateBufferPtr)
474 {
475
476 EB_ERRORTYPE return_error = EB_ErrorNone;
477 EbPictureBufferDesc_t *refPicList0 = 0;
478 EbPictureBufferDesc_t *refPicList1 = 0;
479 EbReferenceObject_t *referenceObject;
480 EB_U16 refList0PosX = 0;
481 EB_U16 refList0PosY = 0;
482 EB_U16 refList1PosX = 0;
483 EB_U16 refList1PosY = 0;
484
485
486 const EB_U32 puOriginX = mdContextPtr->cuOriginX;
487 const EB_U32 puOriginY = mdContextPtr->cuOriginY;
488 const EB_U32 puWidth = mdContextPtr->cuStats->size;
489 const EB_U32 puHeight = mdContextPtr->cuStats->size;
490 const EB_U32 puIndex = mdContextPtr->puItr;
491
492 EB_U32 puOriginIndex = ((puOriginY & (63)) * 64) + (puOriginX & (63));
493 EB_U32 puChromaOriginIndex = ((((puOriginY & (63)) * 32) + (puOriginX & (63))) >> 1);
494
495
496 SequenceControlSet_t *sequenceControlSetPtr = (SequenceControlSet_t*)pictureControlSetPtr->sequenceControlSetWrapperPtr->objectPtr;
497 EncodeContext_t *encodeContextPtr = sequenceControlSetPtr->encodeContextPtr;
498 InterPredictionContext_t *contextPtr = (InterPredictionContext_t*)(mdContextPtr->interPredictionContext);
499
500 EB_BOOL is16bit = (EB_BOOL)(sequenceControlSetPtr->staticConfig.encoderBitDepth > EB_8BIT);
501
502 EB_S16 motionVector_x;
503 EB_S16 motionVector_y;
504
505 if (mdContextPtr->cuUseRefSrcFlag)
506 is16bit = EB_FALSE;
507
508
509 // Setup List 0
510 if (candidateBufferPtr->candidatePtr->predictionDirection[puIndex] == UNI_PRED_LIST_0 || candidateBufferPtr->candidatePtr->predictionDirection[puIndex] == BI_PRED) {
511
512 referenceObject = (EbReferenceObject_t*)pictureControlSetPtr->refPicPtrArray[REF_LIST_0]->objectPtr;
513
514 if (mdContextPtr->cuUseRefSrcFlag)
515 refPicList0 = referenceObject->refDenSrcPicture;
516 else
517 refPicList0 = is16bit ? referenceObject->referencePicture16bit : referenceObject->referencePicture ;
518
519
520 motionVector_x = candidateBufferPtr->candidatePtr->motionVector_x_L0;
521 motionVector_y = candidateBufferPtr->candidatePtr->motionVector_y_L0;
522
523 // minus 71 is derived from the expression -64 + 1 - 8, and plus 7 is derived from expression -1 + 8
524 refList0PosX = (EB_U16)CLIP3(
525 (EB_S32)((refPicList0->originX - 71) << 2),
526 (EB_S32)((refPicList0->width + refPicList0->originX + 7) << 2),
527 (EB_S32)((puOriginX + refPicList0->originX) << 2) + motionVector_x);
528
529 refList0PosY = (EB_U16)CLIP3(
530 (EB_S32)((refPicList0->originY - 71) << 2),
531 (EB_S32)((refPicList0->height + refPicList0->originY + 7) << 2),
532 (EB_S32)((puOriginY + refPicList0->originY) << 2) + motionVector_y);
533
534 CHECK_REPORT_ERROR(
535 (refList0PosX < ((refPicList0->width + (refPicList0->originX << 1)) << 2)),
536 encodeContextPtr->appCallbackPtr,
537 EB_ENC_INTER_INVLD_MCP_ERROR);
538
539 CHECK_REPORT_ERROR(
540 (refList0PosY < ((refPicList0->height + (refPicList0->originY << 1)) << 2)),
541 encodeContextPtr->appCallbackPtr,
542 EB_ENC_INTER_INVLD_MCP_ERROR);
543
544 }
545
546 // Setup List 1
547 if (candidateBufferPtr->candidatePtr->predictionDirection[puIndex] == UNI_PRED_LIST_1 || candidateBufferPtr->candidatePtr->predictionDirection[puIndex] == BI_PRED) {
548
549 referenceObject = (EbReferenceObject_t*)pictureControlSetPtr->refPicPtrArray[REF_LIST_1]->objectPtr;
550
551 if (mdContextPtr->cuUseRefSrcFlag)
552 refPicList1 = referenceObject->refDenSrcPicture;
553 else
554 refPicList1 = is16bit ? referenceObject->referencePicture16bit : referenceObject->referencePicture;
555
556
557 motionVector_x = candidateBufferPtr->candidatePtr->motionVector_x_L1;
558 motionVector_y = candidateBufferPtr->candidatePtr->motionVector_y_L1;
559
560 // minus 71 is derived from the expression -64 + 1 - 8, and plus 7 is derived from expression -1 + 8
561 refList1PosX = (EB_U16)CLIP3(
562 (EB_S32)((refPicList1->originX - 71) << 2),
563 (EB_S32)((refPicList1->width + refPicList1->originX + 7) << 2),
564 (EB_S32)((puOriginX + refPicList1->originX) << 2) + motionVector_x);
565
566 refList1PosY = (EB_U16)CLIP3(
567 (EB_S32)((refPicList1->originY - 71) << 2),
568 (EB_S32)((refPicList1->height + refPicList1->originY + 7) << 2),
569 (EB_S32)((puOriginY + refPicList1->originY) << 2) + motionVector_y);
570
571 CHECK_REPORT_ERROR(
572 (refList1PosX < ((refPicList1->width + (refPicList1->originX << 1)) << 2)),
573 encodeContextPtr->appCallbackPtr,
574 EB_ENC_INTER_INVLD_MCP_ERROR);
575
576 CHECK_REPORT_ERROR(
577 (refList1PosY < ((refPicList1->height + (refPicList1->originY << 1)) << 2)),
578 encodeContextPtr->appCallbackPtr,
579 EB_ENC_INTER_INVLD_MCP_ERROR);
580
581 }
582
583 switch (candidateBufferPtr->candidatePtr->predictionDirection[puIndex]) {
584
585 case UNI_PRED_LIST_0:
586
587 if (is16bit && mdContextPtr->cuUseRefSrcFlag == EB_FALSE) {
588 if (refPicList0)
589 UnPackReferenceBlock(
590 refPicList0,
591 refList0PosX,
592 refList0PosY,
593 puWidth,
594 puHeight,
595 contextPtr->mcpContext->localReferenceBlock8BITL0,
596 componentMask);
597
598 UniPredHevcInterpolationMd(
599 contextPtr->mcpContext->localReferenceBlock8BITL0,
600 refList0PosX,
601 refList0PosY,
602 puWidth,
603 puHeight,
604 candidateBufferPtr->predictionPtr,
605 puOriginIndex,
606 puChromaOriginIndex,
607 contextPtr->mcpContext->motionCompensationIntermediateResultBuf0,
608 contextPtr->mcpContext->TwoDInterpolationFirstPassFilterResultBuf,
609 EB_TRUE,
610 componentMask);
611
612 }
613 else {
614 if (refPicList0) {
615 UniPredHevcInterpolationMd(
616 refPicList0,
617 refList0PosX,
618 refList0PosY,
619 puWidth,
620 puHeight,
621 candidateBufferPtr->predictionPtr,
622 puOriginIndex,
623 puChromaOriginIndex,
624 contextPtr->mcpContext->motionCompensationIntermediateResultBuf0,
625 contextPtr->mcpContext->TwoDInterpolationFirstPassFilterResultBuf,
626 EB_FALSE,
627 componentMask);
628 }
629 }
630
631 break;
632
633 case UNI_PRED_LIST_1:
634
635 if (is16bit && mdContextPtr->cuUseRefSrcFlag == EB_FALSE) {
636 if (refPicList1)
637 UnPackReferenceBlock(
638 refPicList1,
639 refList1PosX,
640 refList1PosY,
641 puWidth,
642 puHeight,
643 contextPtr->mcpContext->localReferenceBlock8BITL1,
644 componentMask);
645
646 UniPredHevcInterpolationMd(
647 contextPtr->mcpContext->localReferenceBlock8BITL1,
648 refList1PosX,
649 refList1PosY,
650 puWidth,
651 puHeight,
652 candidateBufferPtr->predictionPtr,
653 puOriginIndex,
654 puChromaOriginIndex,
655 contextPtr->mcpContext->motionCompensationIntermediateResultBuf0,
656 contextPtr->mcpContext->TwoDInterpolationFirstPassFilterResultBuf,
657 EB_TRUE,
658 componentMask);
659
660 }
661 else {
662 if (refPicList1) {
663 UniPredHevcInterpolationMd(
664 refPicList1,
665 refList1PosX,
666 refList1PosY,
667 puWidth,
668 puHeight,
669 candidateBufferPtr->predictionPtr,
670 puOriginIndex,
671 puChromaOriginIndex,
672 contextPtr->mcpContext->motionCompensationIntermediateResultBuf0,
673 contextPtr->mcpContext->TwoDInterpolationFirstPassFilterResultBuf,
674 EB_FALSE,
675 componentMask);
676 }
677 }
678
679 break;
680
681 case BI_PRED:
682
683 if (is16bit && mdContextPtr->cuUseRefSrcFlag == EB_FALSE) {
684 if (refPicList0)
685 UnPackReferenceBlock(
686 refPicList0,
687 refList0PosX,
688 refList0PosY,
689 puWidth,
690 puHeight,
691 contextPtr->mcpContext->localReferenceBlock8BITL0,
692 componentMask);
693
694 if (refPicList1)
695 UnPackReferenceBlock(
696 refPicList1,
697 refList1PosX,
698 refList1PosY,
699 puWidth,
700 puHeight,
701 contextPtr->mcpContext->localReferenceBlock8BITL1,
702 componentMask);
703
704 BiPredHevcInterpolationMd(
705 contextPtr->mcpContext->localReferenceBlock8BITL0,
706 contextPtr->mcpContext->localReferenceBlock8BITL1,
707 refList0PosX,
708 refList0PosY,
709 refList1PosX,
710 refList1PosY,
711 puWidth,
712 puHeight,
713 candidateBufferPtr->predictionPtr,
714 puOriginIndex,
715 puChromaOriginIndex,
716 contextPtr->mcpContext->motionCompensationIntermediateResultBuf0,
717 contextPtr->mcpContext->motionCompensationIntermediateResultBuf1,
718 contextPtr->mcpContext->TwoDInterpolationFirstPassFilterResultBuf,
719 EB_TRUE,
720 componentMask);
721
722
723 }
724 else {
725 if (refPicList0 && refPicList1) {
726 BiPredHevcInterpolationMd(
727 refPicList0,
728 refPicList1,
729 refList0PosX,
730 refList0PosY,
731 refList1PosX,
732 refList1PosY,
733 puWidth,
734 puHeight,
735 candidateBufferPtr->predictionPtr,
736 puOriginIndex,
737 puChromaOriginIndex,
738 contextPtr->mcpContext->motionCompensationIntermediateResultBuf0,
739 contextPtr->mcpContext->motionCompensationIntermediateResultBuf1,
740 contextPtr->mcpContext->TwoDInterpolationFirstPassFilterResultBuf,
741 EB_FALSE,
742 componentMask);
743 }
744 }
745
746 break;
747
748 default:
749 CHECK_REPORT_ERROR_NC(
750 encodeContextPtr->appCallbackPtr,
751 EB_ENC_INTER_PRED_ERROR0);
752 break;
753 }
754
755 return return_error;
756 }
757
758 /***************************************************
759 * Inter Prediction used in the Encode Pass
760 ***************************************************/
EncodePassInterPrediction(MvUnit_t * mvUnit,EB_U16 puOriginX,EB_U16 puOriginY,EB_U8 puWidth,EB_U8 puHeight,PictureControlSet_t * pictureControlSetPtr,EbPictureBufferDesc_t * predictionPtr,MotionCompensationPredictionContext_t * mcpContext)761 EB_ERRORTYPE EncodePassInterPrediction(
762 MvUnit_t *mvUnit,
763 EB_U16 puOriginX,
764 EB_U16 puOriginY,
765 EB_U8 puWidth,
766 EB_U8 puHeight,
767
768 PictureControlSet_t *pictureControlSetPtr,
769 EbPictureBufferDesc_t *predictionPtr,
770 MotionCompensationPredictionContext_t *mcpContext)
771 {
772 EB_ERRORTYPE return_error = EB_ErrorNone;
773 EbPictureBufferDesc_t *refPicList0 = 0;
774 EbPictureBufferDesc_t *refPicList1 = 0;
775 EbReferenceObject_t *referenceObject;
776 EB_U16 refList0PosX = 0;
777 EB_U16 refList0PosY = 0;
778 EB_U16 refList1PosX = 0;
779 EB_U16 refList1PosY = 0;
780
781 EB_COLOR_FORMAT colorFormat=predictionPtr->colorFormat;
782 EB_U16 subWidthCMinus1 = (colorFormat == EB_YUV444 ? 1 : 2) - 1;
783 EB_U16 subHeightCMinus1 = (colorFormat >= EB_YUV422 ? 1 : 2) - 1;
784
785 EB_U32 puOriginIndex = ((predictionPtr->originY +puOriginY) * predictionPtr->strideY) + (predictionPtr->originX+puOriginX);
786 EB_U32 puChromaOriginIndex = (((predictionPtr->originY+puOriginY) * predictionPtr->strideCb) >> subHeightCMinus1) + ((predictionPtr->originX+puOriginX) >> subWidthCMinus1);
787 SequenceControlSet_t *sequenceControlSetPtr = (SequenceControlSet_t*)pictureControlSetPtr->sequenceControlSetWrapperPtr->objectPtr;
788 EncodeContext_t *encodeContextPtr = sequenceControlSetPtr->encodeContextPtr;
789
790 // Setup List 0
791 if(mvUnit->predDirection == UNI_PRED_LIST_0 || mvUnit->predDirection == BI_PRED) {
792
793 //refPicList0Idx = candidateBufferPtr->candidatePtr->motionVectorIdx[REF_LIST_0][puIndex];
794 referenceObject = (EbReferenceObject_t*)pictureControlSetPtr->refPicPtrArray[REF_LIST_0]->objectPtr;
795 refPicList0 = (EbPictureBufferDesc_t*) referenceObject->referencePicture;
796
797 // minus 71 is derived from the expression -64 + 1 - 8, and plus 7 is derived from expression -1 + 8
798 //refList0PosX = (EB_U32) CLIP3((EB_S32)((refPicList0->originX-71) << 2), (EB_S32)((refPicList0->width + refPicList0->originX + 7)<<2) , (EB_S32) ((puOriginX + tbOriginX + refPicList0->originX)<<2) + candidateBufferPtr->candidatePtr->motionVector_x[REF_LIST_0][puIndex]);
799 refList0PosX = (EB_U32) CLIP3(
800 (EB_S32)((refPicList0->originX-71) << 2),
801 (EB_S32)((refPicList0->width + refPicList0->originX + 7)<<2) ,
802 (EB_S32) ((puOriginX+ refPicList0->originX)<<2) + mvUnit->mv[REF_LIST_0].x);
803 //refList0PosY = (EB_U32) CLIP3((EB_S32)((refPicList0->originY-71) << 2),(EB_S32)((refPicList0->height + refPicList0->originY + 7)<<2) , (EB_S32) ((puOriginY + tbOriginY + refPicList0->originY)<<2) + candidateBufferPtr->candidatePtr->motionVector_y[REF_LIST_0][puIndex]);
804 refList0PosY = (EB_U32) CLIP3(
805 (EB_S32)((refPicList0->originY-71) << 2),
806 (EB_S32)((refPicList0->height + refPicList0->originY + 7)<<2) ,
807 (EB_S32) ((puOriginY + refPicList0->originY)<<2) + mvUnit->mv[REF_LIST_0].y);
808
809 CHECK_REPORT_ERROR(
810 (refList0PosX < ((refPicList0->width + (refPicList0->originX << 1)) << 2)),
811 encodeContextPtr->appCallbackPtr,
812 EB_ENC_INTER_INVLD_MCP_ERROR);
813
814 CHECK_REPORT_ERROR(
815 (refList0PosY < ((refPicList0->height + (refPicList0->originY << 1)) << 2)),
816 encodeContextPtr->appCallbackPtr,
817 EB_ENC_INTER_INVLD_MCP_ERROR);
818
819 }
820
821 // Setup List 1
822 if(mvUnit->predDirection == UNI_PRED_LIST_1 || mvUnit->predDirection == BI_PRED) {
823
824 //refPicList1Idx = candidateBufferPtr->candidatePtr->motionVectorIdx[REF_LIST_1][puIndex];
825 referenceObject = (EbReferenceObject_t*)pictureControlSetPtr->refPicPtrArray[REF_LIST_1]->objectPtr;
826 refPicList1 = (EbPictureBufferDesc_t*) referenceObject->referencePicture;
827
828 //refList1PosX = ((puOriginX + tbOriginX + refPicList1->originX)<<2) + candidateBufferPtr->candidatePtr->motionVector_x[REF_LIST_1][puIndex];
829 //refList1PosX = ((puOriginX + refPicList1->originX)<<2) + mvUnit->xMv[REF_LIST_1];
830 //refList1PosY = ((puOriginY + tbOriginY + refPicList1->originY)<<2) + candidateBufferPtr->candidatePtr->motionVector_y[REF_LIST_1][puIndex];
831 //refList1PosY = ((puOriginY + refPicList1->originY)<<2) + mvUnit->yMv[REF_LIST_1];
832
833 // minus 71 is derived from the expression -64 + 1 - 8, and plus 7 is derived from expression -1 + 8
834 //refList1PosX = (EB_U32) CLIP3((EB_S32)((refPicList1->originX-71) << 2), (EB_S32)((refPicList1->width + refPicList1->originX + 7)<<2) , (EB_S32) ((puOriginX + tbOriginX + refPicList1->originX)<<2) + candidateBufferPtr->candidatePtr->motionVector_x[REF_LIST_1][puIndex]);
835 refList1PosX = (EB_U32) CLIP3(
836 (EB_S32)((refPicList1->originX-71) << 2),
837 (EB_S32)((refPicList1->width + refPicList1->originX + 7)<<2) ,
838 (EB_S32) ((puOriginX + refPicList1->originX)<<2) + mvUnit->mv[REF_LIST_1].x);
839 //refList1PosY = (EB_U32) CLIP3((EB_S32)((refPicList1->originY-71) << 2), (EB_S32)((refPicList1->height + refPicList1->originY + 7)<<2) , (EB_S32) ((puOriginY + tbOriginY + refPicList1->originY)<<2) + candidateBufferPtr->candidatePtr->motionVector_y[REF_LIST_1][puIndex]);
840 refList1PosY = (EB_U32) CLIP3(
841 (EB_S32)((refPicList1->originY-71) << 2),
842 (EB_S32)((refPicList1->height + refPicList1->originY + 7)<<2) ,
843 (EB_S32) ((puOriginY + refPicList1->originY)<<2) + mvUnit->mv[REF_LIST_1].y);
844
845 CHECK_REPORT_ERROR(
846 (refList1PosX < ((refPicList1->width + (refPicList1->originX << 1)) << 2)),
847 encodeContextPtr->appCallbackPtr,
848 EB_ENC_INTER_INVLD_MCP_ERROR);
849
850 CHECK_REPORT_ERROR(
851 (refList1PosY < ((refPicList1->height + (refPicList1->originY << 1)) << 2)),
852 encodeContextPtr->appCallbackPtr,
853 EB_ENC_INTER_INVLD_MCP_ERROR);
854
855 }
856
857
858 //switch(candidateBufferPtr->candidatePtr->predictionDirection[puIndex]) {
859 switch(mvUnit->predDirection)
860 {
861
862 case UNI_PRED_LIST_0:
863
864 EncodeUniPredInterpolation(
865 refPicList0,
866 refList0PosX,
867 refList0PosY,
868 puWidth,
869 puHeight,
870 predictionPtr,
871 puOriginIndex,
872 puChromaOriginIndex,
873 mcpContext->motionCompensationIntermediateResultBuf0,
874 mcpContext->TwoDInterpolationFirstPassFilterResultBuf);
875
876 break;
877
878 case UNI_PRED_LIST_1:
879
880 EncodeUniPredInterpolation(
881 refPicList1,
882 refList1PosX,
883 refList1PosY,
884 puWidth,
885 puHeight,
886 predictionPtr,
887 puOriginIndex,
888 puChromaOriginIndex,
889 mcpContext->motionCompensationIntermediateResultBuf0,
890 mcpContext->TwoDInterpolationFirstPassFilterResultBuf);
891
892 break;
893
894 case BI_PRED:
895
896 EncodeBiPredInterpolation(
897 refPicList0,
898 refPicList1,
899 refList0PosX,
900 refList0PosY,
901 refList1PosX,
902 refList1PosY,
903 puWidth,
904 puHeight,
905 predictionPtr,
906 puOriginIndex,
907 puChromaOriginIndex,
908 mcpContext->motionCompensationIntermediateResultBuf0,
909 mcpContext->motionCompensationIntermediateResultBuf1,
910 mcpContext->TwoDInterpolationFirstPassFilterResultBuf);
911
912 break;
913
914 default:
915 CHECK_REPORT_ERROR_NC(
916 encodeContextPtr->appCallbackPtr,
917 EB_ENC_INTER_PRED_ERROR0);
918 break;
919 }
920
921 return return_error;
922 }
923
924
925 /***************************************************
926 * Inter Prediction used in the Encode Pass 16bit
927 ***************************************************/
EncodePassInterPrediction16bit(MvUnit_t * mvUnit,EB_U16 puOriginX,EB_U16 puOriginY,EB_U8 puWidth,EB_U8 puHeight,PictureControlSet_t * pictureControlSetPtr,EbPictureBufferDesc_t * predictionPtr,MotionCompensationPredictionContext_t * mcpContext)928 EB_ERRORTYPE EncodePassInterPrediction16bit(
929 MvUnit_t *mvUnit,
930 EB_U16 puOriginX,
931 EB_U16 puOriginY,
932 EB_U8 puWidth,
933 EB_U8 puHeight,
934 PictureControlSet_t *pictureControlSetPtr,
935 EbPictureBufferDesc_t *predictionPtr,
936 MotionCompensationPredictionContext_t *mcpContext)
937 {
938
939 EB_ERRORTYPE return_error = EB_ErrorNone;
940 EbPictureBufferDesc_t *refPicList0 = 0;
941 EbPictureBufferDesc_t *refPicList1 = 0;
942 EbReferenceObject_t *referenceObject;
943 EB_U16 refList0PosX = 0;
944 EB_U16 refList0PosY = 0;
945 EB_U16 refList1PosX = 0;
946 EB_U16 refList1PosY = 0;
947 const EB_COLOR_FORMAT colorFormat = predictionPtr->colorFormat;
948 const EB_U16 subWidthCMinus1 = (colorFormat == EB_YUV444 ? 1 : 2) - 1;
949 const EB_U16 subHeightCMinus1 = (colorFormat >= EB_YUV422 ? 1 : 2) - 1;
950
951
952 EB_U32 puOriginIndex = (predictionPtr->originX + puOriginX) +
953 ((predictionPtr->originY+puOriginY) * predictionPtr->strideY);
954 EB_U32 puChromaOriginIndex = ((predictionPtr->originX + puOriginX) >> subWidthCMinus1) +
955 (((predictionPtr->originY+puOriginY) * predictionPtr->strideCb) >> subHeightCMinus1);
956 SequenceControlSet_t *sequenceControlSetPtr = (SequenceControlSet_t*)pictureControlSetPtr->sequenceControlSetWrapperPtr->objectPtr;
957 EncodeContext_t *encodeContextPtr = sequenceControlSetPtr->encodeContextPtr;
958
959 // Setup List 0
960 if (mvUnit->predDirection == UNI_PRED_LIST_0 || mvUnit->predDirection == BI_PRED) {
961 referenceObject = (EbReferenceObject_t*)pictureControlSetPtr->refPicPtrArray[REF_LIST_0]->objectPtr;
962 refPicList0 = (EbPictureBufferDesc_t*)referenceObject->referencePicture16bit;
963
964 // minus 71 is derived from the expression -64 + 1 - 8, and plus 7 is derived from expression -1 + 8
965 //refList0PosX = (EB_U32) CLIP3((EB_S32)((refPicList0->originX-71) << 2), (EB_S32)((refPicList0->width + refPicList0->originX + 7)<<2) , (EB_S32) ((puOriginX + tbOriginX + refPicList0->originX)<<2) + candidateBufferPtr->candidatePtr->motionVector_x[REF_LIST_0][puIndex]);
966 refList0PosX = (EB_U32)CLIP3(
967 (EB_S32)((refPicList0->originX - 71) << 2),
968 (EB_S32)((refPicList0->width + refPicList0->originX + 7) << 2),
969 (EB_S32)((puOriginX + refPicList0->originX) << 2) + mvUnit->mv[REF_LIST_0].x);
970 //refList0PosY = (EB_U32) CLIP3((EB_S32)((refPicList0->originY-71) << 2),(EB_S32)((refPicList0->height + refPicList0->originY + 7)<<2) , (EB_S32) ((puOriginY + tbOriginY + refPicList0->originY)<<2) + candidateBufferPtr->candidatePtr->motionVector_y[REF_LIST_0][puIndex]);
971 refList0PosY = (EB_U32)CLIP3(
972 (EB_S32)((refPicList0->originY - 71) << 2),
973 (EB_S32)((refPicList0->height + refPicList0->originY + 7) << 2),
974 (EB_S32)((puOriginY + refPicList0->originY) << 2) + mvUnit->mv[REF_LIST_0].y);
975
976
977 CHECK_REPORT_ERROR(
978 (refList0PosX < ((refPicList0->width + (refPicList0->originX << 1)) << 2)),
979 encodeContextPtr->appCallbackPtr,
980 EB_ENC_INTER_INVLD_MCP_ERROR);
981
982 CHECK_REPORT_ERROR(
983 (refList0PosY < ((refPicList0->height + (refPicList0->originY << 1)) << 2)),
984 encodeContextPtr->appCallbackPtr,
985 EB_ENC_INTER_INVLD_MCP_ERROR);
986
987 EB_U32 lumaOffSet = ((refList0PosX >> 2) - 4) * 2 + ((refList0PosY >> 2) - 4) * 2 * refPicList0->strideY; //refPicList0->originX + refPicList0->originY*refPicList0->strideY; //
988 EB_U32 cbOffset = ((refList0PosX >> (2 + subWidthCMinus1)) - 2) * 2 + ((refList0PosY >> (2 + subHeightCMinus1)) - 2) * 2 * refPicList0->strideCb; //Jing:double check for 444
989 EB_U32 crOffset = ((refList0PosX >> (2 + subWidthCMinus1)) - 2) * 2 + ((refList0PosY >> (2 + subHeightCMinus1)) - 2) * 2 * refPicList0->strideCr;
990 //EB_U8 verticalIdx;
991
992 mcpContext->localReferenceBlockL0->bufferY = refPicList0->bufferY + lumaOffSet;
993 mcpContext->localReferenceBlockL0->bufferCb = refPicList0->bufferCb + cbOffset;
994 mcpContext->localReferenceBlockL0->bufferCr = refPicList0->bufferCr + crOffset;
995 mcpContext->localReferenceBlockL0->strideY = refPicList0->strideY;
996 mcpContext->localReferenceBlockL0->strideCb = refPicList0->strideCb;
997 mcpContext->localReferenceBlockL0->strideCr = refPicList0->strideCr;
998 }
999
1000 // Setup List 1
1001 if (mvUnit->predDirection == UNI_PRED_LIST_1 || mvUnit->predDirection == BI_PRED) {
1002
1003 referenceObject = (EbReferenceObject_t*)pictureControlSetPtr->refPicPtrArray[REF_LIST_1]->objectPtr;
1004 refPicList1 = (EbPictureBufferDesc_t*)referenceObject->referencePicture16bit;
1005
1006 // minus 71 is derived from the expression -64 + 1 - 8, and plus 7 is derived from expression -1 + 8
1007 //refList1PosX = (EB_U32) CLIP3((EB_S32)((refPicList1->originX-71) << 2), (EB_S32)((refPicList1->width + refPicList1->originX + 7)<<2) , (EB_S32) ((puOriginX + tbOriginX + refPicList1->originX)<<2) + candidateBufferPtr->candidatePtr->motionVector_x[REF_LIST_1][puIndex]);
1008 refList1PosX = (EB_U32)CLIP3(
1009 (EB_S32)((refPicList1->originX - 71) << 2),
1010 (EB_S32)((refPicList1->width + refPicList1->originX + 7) << 2),
1011 (EB_S32)((puOriginX + refPicList1->originX) << 2) + mvUnit->mv[REF_LIST_1].x);
1012 //refList1PosY = (EB_U32) CLIP3((EB_S32)((refPicList1->originY-71) << 2), (EB_S32)((refPicList1->height + refPicList1->originY + 7)<<2) , (EB_S32) ((puOriginY + tbOriginY + refPicList1->originY)<<2) + candidateBufferPtr->candidatePtr->motionVector_y[REF_LIST_1][puIndex]);
1013 refList1PosY = (EB_U32)CLIP3(
1014 (EB_S32)((refPicList1->originY - 71) << 2),
1015 (EB_S32)((refPicList1->height + refPicList1->originY + 7) << 2),
1016 (EB_S32)((puOriginY + refPicList1->originY) << 2) + mvUnit->mv[REF_LIST_1].y);
1017
1018 CHECK_REPORT_ERROR(
1019 (refList1PosX < ((refPicList1->width + (refPicList1->originX << 1)) << 2)),
1020 encodeContextPtr->appCallbackPtr,
1021 EB_ENC_INTER_INVLD_MCP_ERROR);
1022
1023 CHECK_REPORT_ERROR(
1024 (refList1PosY < ((refPicList1->height + (refPicList1->originY << 1)) << 2)),
1025 encodeContextPtr->appCallbackPtr,
1026 EB_ENC_INTER_INVLD_MCP_ERROR);
1027
1028 //mcpContext->localReferenceBlockL1->bufferY = refPicList1->bufferY + ((refList1PosX >> 2) - 4) * 2 + ((refList1PosY >> 2) - 4) * 2 * refPicList1->strideY;
1029 //mcpContext->localReferenceBlockL1->bufferCb = refPicList1->bufferCb + ((refList1PosX >> 3) - 2) * 2 + ((refList1PosY >> 3) - 2) * 2 * refPicList1->strideCb;
1030 //mcpContext->localReferenceBlockL1->bufferCr = refPicList1->bufferCr + ((refList1PosX >> 3) - 2) * 2 + ((refList1PosY >> 3) - 2) * 2 * refPicList1->strideCr;
1031 EB_U32 lumaOffSet = ((refList1PosX >> 2) - 4) * 2 + ((refList1PosY >> 2) - 4) * 2 * refPicList1->strideY; //refPicList0->originX + refPicList0->originY*refPicList0->strideY; //
1032 EB_U32 cbOffset = ((refList1PosX >> (2 + subWidthCMinus1)) - 2) * 2 + ((refList1PosY >> (2 + subHeightCMinus1)) - 2) * 2 * refPicList1->strideCb;
1033 EB_U32 crOffset = ((refList1PosX >> (2 + subWidthCMinus1)) - 2) * 2 + ((refList1PosY >> (2 + subHeightCMinus1)) - 2) * 2 * refPicList1->strideCr;
1034 //EB_U8 verticalIdx;
1035
1036 mcpContext->localReferenceBlockL1->bufferY = refPicList1->bufferY + lumaOffSet;
1037 mcpContext->localReferenceBlockL1->bufferCb = refPicList1->bufferCb + cbOffset;
1038 mcpContext->localReferenceBlockL1->bufferCr = refPicList1->bufferCr + crOffset;
1039
1040 mcpContext->localReferenceBlockL1->strideY = refPicList1->strideY;
1041 mcpContext->localReferenceBlockL1->strideCb = refPicList1->strideCb;
1042 mcpContext->localReferenceBlockL1->strideCr = refPicList1->strideCr;
1043 }
1044
1045 switch(mvUnit->predDirection)
1046 {
1047
1048 case UNI_PRED_LIST_0:
1049 //CHKN load the needed FP block from reference frame in a local buffer, we load 4 pixel more in each direction to be used for interpolation.
1050 //TODO: the max area needed for interpolation is 4, we could optimize this later on a case by case basis
1051 //size of the buffer would be (64+4+4)x(64+4+4)
1052
1053 UniPredInterpolation16bit(
1054 mcpContext->localReferenceBlockL0,
1055 refPicList0,
1056 refList0PosX,
1057 refList0PosY,
1058 puWidth,
1059 puHeight,
1060 predictionPtr,
1061 puOriginIndex,
1062 puChromaOriginIndex,
1063 mcpContext->motionCompensationIntermediateResultBuf0);
1064
1065 break;
1066
1067 case UNI_PRED_LIST_1:
1068
1069 UniPredInterpolation16bit(
1070 mcpContext->localReferenceBlockL1,
1071 refPicList1,
1072 refList1PosX,
1073 refList1PosY,
1074 puWidth,
1075 puHeight,
1076 predictionPtr,
1077 puOriginIndex,
1078 puChromaOriginIndex,
1079 mcpContext->motionCompensationIntermediateResultBuf0);
1080
1081
1082 break;
1083
1084 case BI_PRED:
1085
1086 BiPredInterpolation16bit(
1087 mcpContext->localReferenceBlockL0,
1088 mcpContext->localReferenceBlockL1,
1089 refList0PosX,
1090 refList0PosY,
1091 refList1PosX,
1092 refList1PosY,
1093 puWidth,
1094 puHeight,
1095 predictionPtr,
1096 puOriginIndex,
1097 puChromaOriginIndex,
1098 mcpContext->motionCompensationIntermediateResultBuf0,
1099 mcpContext->motionCompensationIntermediateResultBuf1,
1100 mcpContext->TwoDInterpolationFirstPassFilterResultBuf);
1101
1102 break;
1103
1104 default:
1105 CHECK_REPORT_ERROR_NC(
1106 encodeContextPtr->appCallbackPtr,
1107 EB_ENC_INTER_PRED_ERROR0);
1108 break;
1109 }
1110
1111 return return_error;
1112 }
1113
1114 /** ChooseMVPIdx_V2 function is used to choose the best AMVP candidate.
1115 @param *candidatePtr(output)
1116 candidatePtr points to the prediction result.
1117 @param cuPtr(input)
1118 pointer to the CU where the target PU belongs to.
1119 @param *puIndex(input)
1120 the index of the PU inside a CU
1121 @param ref0AMVPCandArray(input)
1122 @param ref0NumAvailableAMVPCand(input)
1123 @param ref1AMVPCandArray(input)
1124 @param ref1NumAvailableAMVPCand(input)
1125 */
ChooseMVPIdx_V2(ModeDecisionCandidate_t * candidatePtr,EB_U32 cuOriginX,EB_U32 cuOriginY,EB_U32 puIndex,EB_U32 tbSize,EB_S16 * ref0AMVPCandArray_x,EB_S16 * ref0AMVPCandArray_y,EB_U32 ref0NumAvailableAMVPCand,EB_S16 * ref1AMVPCandArray_x,EB_S16 * ref1AMVPCandArray_y,EB_U32 ref1NumAvailableAMVPCand,PictureControlSet_t * pictureControlSetPtr)1126 EB_ERRORTYPE ChooseMVPIdx_V2(
1127 ModeDecisionCandidate_t *candidatePtr,
1128 EB_U32 cuOriginX,
1129 EB_U32 cuOriginY,
1130 EB_U32 puIndex,
1131 EB_U32 tbSize,
1132 EB_S16 *ref0AMVPCandArray_x,
1133 EB_S16 *ref0AMVPCandArray_y,
1134 EB_U32 ref0NumAvailableAMVPCand,
1135 EB_S16 *ref1AMVPCandArray_x,
1136 EB_S16 *ref1AMVPCandArray_y,
1137 EB_U32 ref1NumAvailableAMVPCand,
1138 PictureControlSet_t *pictureControlSetPtr)
1139 {
1140 EB_ERRORTYPE return_error = EB_ErrorNone;
1141 EB_U8 mvpRef0Idx;
1142 EB_U8 mvpRef1Idx;
1143
1144
1145 EB_U32 pictureWidth = ((SequenceControlSet_t*)pictureControlSetPtr->sequenceControlSetWrapperPtr->objectPtr)->lumaWidth;
1146 EB_U32 pictureHeight = ((SequenceControlSet_t*)pictureControlSetPtr->sequenceControlSetWrapperPtr->objectPtr)->lumaHeight;
1147
1148 EB_U32 mvd0, mvd1;
1149
1150 switch (candidatePtr->predictionDirection[puIndex]) {
1151 case UNI_PRED_LIST_0:
1152 // Clip the input MV
1153 ClipMV(
1154 cuOriginX,
1155 cuOriginY,
1156 &candidatePtr->motionVector_x_L0,
1157 &candidatePtr->motionVector_y_L0,
1158 pictureWidth,
1159 pictureHeight,
1160 tbSize);
1161
1162 // Choose the AMVP candidate
1163 switch (ref0NumAvailableAMVPCand) {
1164 case 0:
1165 case 1:
1166 //mvpRef0Idx = 0;
1167 candidatePtr->motionVectorPredIdx[REF_LIST_0] = 0;
1168 candidatePtr->motionVectorPred_x[REF_LIST_0] = ref0AMVPCandArray_x[0];
1169 candidatePtr->motionVectorPred_y[REF_LIST_0] = ref0AMVPCandArray_y[0];
1170 break;
1171 case 2:
1172
1173 mvd0 = EB_ABS_DIFF(ref0AMVPCandArray_x[0], candidatePtr->motionVector_x_L0) +
1174 EB_ABS_DIFF(ref0AMVPCandArray_y[0], candidatePtr->motionVector_y_L0);
1175
1176 mvd1 = EB_ABS_DIFF(ref0AMVPCandArray_x[1], candidatePtr->motionVector_x_L0) +
1177 EB_ABS_DIFF(ref0AMVPCandArray_y[1], candidatePtr->motionVector_y_L0);
1178
1179 mvpRef0Idx = ((mvd0) <= (mvd1)) ? 0 : 1;
1180
1181 candidatePtr->motionVectorPredIdx[REF_LIST_0] = mvpRef0Idx;
1182 candidatePtr->motionVectorPred_x[REF_LIST_0] = ref0AMVPCandArray_x[mvpRef0Idx];
1183 candidatePtr->motionVectorPred_y[REF_LIST_0] = ref0AMVPCandArray_y[mvpRef0Idx];
1184 break;
1185 default:
1186 break;
1187 }
1188
1189 break;
1190
1191 case UNI_PRED_LIST_1:
1192
1193 // Clip the input MV
1194 ClipMV(
1195 cuOriginX,
1196 cuOriginY,
1197 &candidatePtr->motionVector_x_L1,
1198 &candidatePtr->motionVector_y_L1,
1199 pictureWidth,
1200 pictureHeight,
1201 tbSize);
1202
1203 // Choose the AMVP candidate
1204 switch (ref1NumAvailableAMVPCand) {
1205 case 0:
1206 case 1:
1207 //mvpRef1Idx = 0;
1208 candidatePtr->motionVectorPredIdx[REF_LIST_1] = 0;
1209 candidatePtr->motionVectorPred_x[REF_LIST_1] = ref1AMVPCandArray_x[0];
1210 candidatePtr->motionVectorPred_y[REF_LIST_1] = ref1AMVPCandArray_y[0];
1211 break;
1212 case 2:
1213
1214 mvd0 = EB_ABS_DIFF(ref1AMVPCandArray_x[0], candidatePtr->motionVector_x_L1) +
1215 EB_ABS_DIFF(ref1AMVPCandArray_y[0], candidatePtr->motionVector_y_L1);
1216
1217 mvd1 = EB_ABS_DIFF(ref1AMVPCandArray_x[1], candidatePtr->motionVector_x_L1) +
1218 EB_ABS_DIFF(ref1AMVPCandArray_y[1], candidatePtr->motionVector_y_L1);
1219
1220 mvpRef1Idx = ((mvd0) <= (mvd1)) ? 0 : 1;
1221
1222
1223
1224 candidatePtr->motionVectorPredIdx[REF_LIST_1] = mvpRef1Idx;
1225 candidatePtr->motionVectorPred_x[REF_LIST_1] = ref1AMVPCandArray_x[mvpRef1Idx];
1226 candidatePtr->motionVectorPred_y[REF_LIST_1] = ref1AMVPCandArray_y[mvpRef1Idx];
1227 break;
1228 default:
1229 break;
1230 }
1231
1232 // MVP in refPicList0
1233 //mvpRef0Idx = 0;
1234 //candidatePtr->motionVectorPredIdx[REF_LIST_0][puIndex] = mvpRef0Idx;
1235 //candidatePtr->motionVectorPred_x[REF_LIST_0][puIndex] = 0;
1236 //candidatePtr->motionVectorPred_y[REF_LIST_0][puIndex] = 0;
1237
1238 break;
1239
1240 case BI_PRED:
1241
1242 // Choose the MVP in list0
1243 // Clip the input MV
1244 ClipMV(
1245 cuOriginX,
1246 cuOriginY,
1247 &candidatePtr->motionVector_x_L0,
1248 &candidatePtr->motionVector_y_L0,
1249 pictureWidth,
1250 pictureHeight,
1251 tbSize);
1252
1253 // Choose the AMVP candidate
1254 switch (ref0NumAvailableAMVPCand) {
1255 case 0:
1256 case 1:
1257 //mvpRef0Idx = 0;
1258 candidatePtr->motionVectorPredIdx[REF_LIST_0] = 0;
1259 candidatePtr->motionVectorPred_x[REF_LIST_0] = ref0AMVPCandArray_x[0];
1260 candidatePtr->motionVectorPred_y[REF_LIST_0] = ref0AMVPCandArray_y[0];
1261 break;
1262 case 2:
1263
1264 mvd0 = EB_ABS_DIFF(ref0AMVPCandArray_x[0], candidatePtr->motionVector_x_L0) +
1265 EB_ABS_DIFF(ref0AMVPCandArray_y[0], candidatePtr->motionVector_y_L0);
1266
1267 mvd1 = EB_ABS_DIFF(ref0AMVPCandArray_x[1], candidatePtr->motionVector_x_L0) +
1268 EB_ABS_DIFF(ref0AMVPCandArray_y[1], candidatePtr->motionVector_y_L0);
1269
1270 mvpRef0Idx = ((mvd0) <= (mvd1)) ? 0 : 1;
1271
1272
1273
1274 candidatePtr->motionVectorPredIdx[REF_LIST_0] = mvpRef0Idx;
1275 candidatePtr->motionVectorPred_x[REF_LIST_0] = ref0AMVPCandArray_x[mvpRef0Idx];
1276 candidatePtr->motionVectorPred_y[REF_LIST_0] = ref0AMVPCandArray_y[mvpRef0Idx];
1277 break;
1278 default:
1279 break;
1280 }
1281
1282 // Choose the MVP in list1
1283 // Clip the input MV
1284 ClipMV(
1285 cuOriginX,
1286 cuOriginY,
1287 &candidatePtr->motionVector_x_L1,
1288 &candidatePtr->motionVector_y_L1,
1289 pictureWidth,
1290 pictureHeight,
1291 tbSize);
1292
1293 // Choose the AMVP candidate
1294 switch (ref1NumAvailableAMVPCand) {
1295 case 0:
1296 case 1:
1297 //mvpRef1Idx = 0;
1298 candidatePtr->motionVectorPredIdx[REF_LIST_1] = 0;
1299 candidatePtr->motionVectorPred_x[REF_LIST_1] = ref1AMVPCandArray_x[0];
1300 candidatePtr->motionVectorPred_y[REF_LIST_1] = ref1AMVPCandArray_y[0];
1301 break;
1302 case 2:
1303
1304 mvd0 = EB_ABS_DIFF(ref1AMVPCandArray_x[0], candidatePtr->motionVector_x_L1) +
1305 EB_ABS_DIFF(ref1AMVPCandArray_y[0], candidatePtr->motionVector_y_L1);
1306
1307 mvd1 = EB_ABS_DIFF(ref1AMVPCandArray_x[1], candidatePtr->motionVector_x_L1) +
1308 EB_ABS_DIFF(ref1AMVPCandArray_y[1], candidatePtr->motionVector_y_L1);
1309
1310 mvpRef1Idx = ((mvd0) <= (mvd1)) ? 0 : 1;
1311
1312 candidatePtr->motionVectorPredIdx[REF_LIST_1] = mvpRef1Idx;
1313 candidatePtr->motionVectorPred_x[REF_LIST_1] = ref1AMVPCandArray_x[mvpRef1Idx];
1314 candidatePtr->motionVectorPred_y[REF_LIST_1] = ref1AMVPCandArray_y[mvpRef1Idx];
1315 break;
1316 default:
1317 break;
1318 }
1319
1320 break;
1321
1322 default:
1323 break;
1324 }
1325
1326 return return_error;
1327 }
1328