History

Initial Commit

Ethan Hugg committed 12 years ago

Commit 70e5e621 parent bd509b2308 files · +97095 −-5Browse files

Showing the changes to codec/encoder/core/src/mv_pred.cpp (1 of 308 files). Show all

Unified · Split

codec/encoder/core/src/mv_pred.cpp+389−0
@@ -0,0 +1,389 @@
1/*!
2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 *
32 * \file mv_pred.c
33 *
34 * \brief Get MV predictor and update motion vector of mb cache
35 *
36 * \date 05/22/2009 Created
37 *
38 *************************************************************************************
39 */
40
41#include "mv_pred.h"
42#include "ls_defines.h"
43namespace WelsSVCEnc {
44//basic pMv prediction unit for pMv width (4, 2, 1)
45void PredMv(const SMVComponentUnit* kpMvComp, int8_t iPartIdx, int8_t iPartW, int32_t iRef, SMVUnitXY* sMvp)
46{
47 const uint8_t kuiLeftIdx = g_kuiCache30ScanIdx[iPartIdx] - 1;
48 const uint8_t kuiTopIdx = g_kuiCache30ScanIdx[iPartIdx] - 6;
49
50 int32_t iMatchRef;
51 int32_t iLeftRef = kpMvComp->iRefIndexCache[kuiLeftIdx];
52 int32_t iTopRef = kpMvComp->iRefIndexCache[ kuiTopIdx];
53 int32_t iRightTopRef = kpMvComp->iRefIndexCache[kuiTopIdx + iPartW];
54 int32_t iDiagonalRef;
55 SMVUnitXY sMvA(kpMvComp->sMotionVectorCache[kuiLeftIdx]);
56 SMVUnitXY sMvB(kpMvComp->sMotionVectorCache[kuiTopIdx]);
57 SMVUnitXY sMvC;
58
59 if (REF_NOT_AVAIL == iRightTopRef)
60 {
61 iDiagonalRef = kpMvComp->iRefIndexCache[ kuiTopIdx - 1];// left_top;
62 sMvC = kpMvComp->sMotionVectorCache[kuiTopIdx - 1];
63 }
64 else
65 {
66 iDiagonalRef = iRightTopRef;// right_top;
67 sMvC = kpMvComp->sMotionVectorCache[kuiTopIdx + iPartW];
68 }
69
70 if ((REF_NOT_AVAIL == iTopRef) && (REF_NOT_AVAIL == iDiagonalRef) && iLeftRef != REF_NOT_AVAIL)
71 {
72 *sMvp = sMvA;
73 return;
74 }
75
76 // b2[diag] b1[top] b0[left] is available!
77 iMatchRef = (iRef == iLeftRef) <<MB_LEFT_BIT;
78 iMatchRef |= (iRef == iTopRef) <<MB_TOP_BIT;
79 iMatchRef |= (iRef == iDiagonalRef)<<MB_TOPRIGHT_BIT;
80 switch(iMatchRef)
81 {
82 case LEFT_MB_POS:// A
83 *sMvp = sMvA;
84 break;
85 case TOP_MB_POS:// B
86 *sMvp = sMvB;
87 break;
88 case TOPRIGHT_MB_POS:// C or D
89 *sMvp = sMvC;
90 break;
91 default:
92 sMvp->iMvX = WELS_MEDIAN(sMvA.iMvX, sMvB.iMvX, sMvC.iMvX);
93 sMvp->iMvY = WELS_MEDIAN(sMvA.iMvY, sMvB.iMvY, sMvC.iMvY);
94 break;
95 }
96}
97void PredInter8x16Mv(SMbCache* pMbCache, int32_t iPartIdx, int8_t iRef, SMVUnitXY* sMvp)
98{
99 const SMVComponentUnit *kpMvComp = &pMbCache->sMvComponents;
100 if (0 == iPartIdx)
101 {
102 const int8_t kiLeftRef = kpMvComp->iRefIndexCache[6];
103 if (iRef == kiLeftRef)
104 {
105 *sMvp = kpMvComp->sMotionVectorCache[6];
106 return;
107 }
108 }
109 else // 1 == iPartIdx
110 {
111 int8_t iDiagonalRef = kpMvComp->iRefIndexCache[5]; //top-right
112 int8_t iIndex = 5;
113 if (REF_NOT_AVAIL == iDiagonalRef)
114 {
115 iDiagonalRef = kpMvComp->iRefIndexCache[2]; //top-left for 8*8 block(iIndex 1)
116 iIndex = 2;
117 }
118 if (iRef == iDiagonalRef)
119 {
120 *sMvp = kpMvComp->sMotionVectorCache[iIndex];
121 return;
122 }
123 }
124
125 PredMv(kpMvComp, iPartIdx, 2, iRef, sMvp);
126}
127void PredInter16x8Mv(SMbCache* pMbCache, int32_t iPartIdx, int8_t iRef, SMVUnitXY* sMvp)
128{
129 const SMVComponentUnit *kpMvComp = &pMbCache->sMvComponents;
130 if (0 == iPartIdx)
131 {
132 const int8_t kiTopRef = kpMvComp->iRefIndexCache[1];
133 if (iRef == kiTopRef)
134 {
135 *sMvp = kpMvComp->sMotionVectorCache[1];
136 return;
137 }
138 }
139 else // 8 == iPartIdx
140 {
141 const int8_t kiLeftRef = kpMvComp->iRefIndexCache[18];
142 if (iRef == kiLeftRef)
143 {
144 *sMvp = kpMvComp->sMotionVectorCache[18];
145 return;
146 }
147 }
148
149 PredMv(kpMvComp, iPartIdx, 4, iRef, sMvp);
150}
151void PredSkipMv(SMbCache* pMbCache, SMVUnitXY* sMvp)
152{
153 const SMVComponentUnit *kpMvComp = &pMbCache->sMvComponents;
154 const int8_t kiLeftRef = kpMvComp->iRefIndexCache[6]; //A
155 const int8_t kiTopRef = kpMvComp->iRefIndexCache[1]; //B
156
157 if (REF_NOT_AVAIL == kiLeftRef || REF_NOT_AVAIL == kiTopRef ||
158 (0 == kiLeftRef && 0 == *(int32_t*)(&kpMvComp->sMotionVectorCache[6])) ||
159 (0 == kiTopRef && 0 == *(int32_t*)(&kpMvComp->sMotionVectorCache[1])) )
160 {
161 ST32( sMvp, 0 );
162 return;
163 }
164
165 PredMv(kpMvComp, 0, 4, 0, sMvp);
166}
167
168//update pMv and uiRefIndex cache for current MB, only for P_16*16 (SKIP inclusive)
169void UpdateP16x16MotionInfo(SMbCache* pMbCache, SMB* pCurMb, const int8_t kiRef, SMVUnitXY* pMv)
170{
171 // optimized 11/25/2011
172 SMVComponentUnit *pMvComp = &pMbCache->sMvComponents;
173 const uint32_t kuiMv32 = LD32(pMv);
174 const uint64_t kuiMv64 = BUTTERFLY4x8(kuiMv32);
175 uint64_t uiMvBuf[8] = { kuiMv64, kuiMv64, kuiMv64, kuiMv64, kuiMv64, kuiMv64, kuiMv64, kuiMv64 };
176 const uint16_t kuiRef16 = BUTTERFLY1x2(kiRef);
177 const uint32_t kuiRef32 = BUTTERFLY2x4(kuiRef16);
178
179 ST32( pCurMb->pRefIndex, kuiRef32 );
180 // update pMv range from 0~15
181 memcpy( pCurMb->sMv, uiMvBuf, sizeof(uiMvBuf) ); // confirmed_safe_unsafe_usage
182
183 /*
184 * blocks 0: 7~10, 1: 13~16, 2: 19~22, 3: 25~28
185 */
186 pMvComp->iRefIndexCache[7] = kiRef;
187 ST16(&pMvComp->iRefIndexCache[8], kuiRef16);
188 pMvComp->iRefIndexCache[10] = kiRef;
189 pMvComp->iRefIndexCache[13] = kiRef;
190 ST16(&pMvComp->iRefIndexCache[14], kuiRef16);
191 pMvComp->iRefIndexCache[16] = kiRef;
192 pMvComp->iRefIndexCache[19] = kiRef;
193 ST16(&pMvComp->iRefIndexCache[20], kuiRef16);
194 pMvComp->iRefIndexCache[22] = kiRef;
195 pMvComp->iRefIndexCache[25] = kiRef;
196 ST16(&pMvComp->iRefIndexCache[26], kuiRef16);
197 pMvComp->iRefIndexCache[28] = kiRef;
198
199 /*
200 * blocks 0: 7~10, 1: 13~16, 2: 19~22, 3: 25~28
201 */
202 pMvComp->sMotionVectorCache[7] = *pMv;
203 ST64( &pMvComp->sMotionVectorCache[8], kuiMv64 );
204 pMvComp->sMotionVectorCache[10] = *pMv;
205 pMvComp->sMotionVectorCache[13] = *pMv;
206 ST64( &pMvComp->sMotionVectorCache[14], kuiMv64 );
207 pMvComp->sMotionVectorCache[16] = *pMv;
208 pMvComp->sMotionVectorCache[19] = *pMv;
209 ST64( &pMvComp->sMotionVectorCache[20], kuiMv64 );
210 pMvComp->sMotionVectorCache[22] = *pMv;
211 pMvComp->sMotionVectorCache[25] = *pMv;
212 ST64( &pMvComp->sMotionVectorCache[26], kuiMv64 );
213 pMvComp->sMotionVectorCache[28] = *pMv;
214}
215
216//update uiRefIndex and pMv of both SMB and Mb_cache, only for P16x8
217void UpdateP16x8MotionInfo(SMbCache* pMbCache, SMB* pCurMb, const int32_t kiPartIdx, const int8_t kiRef, SMVUnitXY* pMv)
218{
219 // optimized 11/25/2011
220 SMVComponentUnit *pMvComp = &pMbCache->sMvComponents;
221 const uint32_t kuiMv32 = LD32(pMv);
222 const uint64_t kuiMv64 = BUTTERFLY4x8(kuiMv32);
223 uint64_t uiMvBuf[4] = { kuiMv64, kuiMv64, kuiMv64, kuiMv64 };
224 const int16_t kiScan4Idx = g_kuiMbCountScan4Idx[kiPartIdx];
225 const int16_t kiCacheIdx = g_kuiCache30ScanIdx[kiPartIdx];
226 const int16_t kiCacheIdx1 = 1+kiCacheIdx;
227 const int16_t kiCacheIdx3 = 3+kiCacheIdx;
228 const int16_t kiCacheIdx6 = 6+kiCacheIdx;
229 const int16_t kiCacheIdx7 = 7+kiCacheIdx;
230 const int16_t kiCacheIdx9 = 9+kiCacheIdx;
231 const uint16_t kuiRef16 = BUTTERFLY1x2(kiRef);
232
233 ST16( &pCurMb->pRefIndex[(kiPartIdx>>2)], kuiRef16 );
234 memcpy( &pCurMb->sMv[kiScan4Idx], uiMvBuf, sizeof(uiMvBuf) ); // confirmed_safe_unsafe_usage
235
236 /*
237 * blocks 0: g_kuiCache30ScanIdx[iPartIdx]~g_kuiCache30ScanIdx[iPartIdx]+3, 1: g_kuiCache30ScanIdx[iPartIdx]+6~g_kuiCache30ScanIdx[iPartIdx]+9
238 */
239 pMvComp->iRefIndexCache[kiCacheIdx] = kiRef;
240 ST16(&pMvComp->iRefIndexCache[kiCacheIdx1], kuiRef16);
241 pMvComp->iRefIndexCache[kiCacheIdx3] = kiRef;
242 pMvComp->iRefIndexCache[kiCacheIdx6] = kiRef;
243 ST16(&pMvComp->iRefIndexCache[kiCacheIdx7], kuiRef16);
244 pMvComp->iRefIndexCache[kiCacheIdx9] = kiRef;
245
246 /*
247 * blocks 0: g_kuiCache30ScanIdx[iPartIdx]~g_kuiCache30ScanIdx[iPartIdx]+3, 1: g_kuiCache30ScanIdx[iPartIdx]+6~g_kuiCache30ScanIdx[iPartIdx]+9
248 */
249 pMvComp->sMotionVectorCache[kiCacheIdx] = *pMv;
250 ST64( &pMvComp->sMotionVectorCache[kiCacheIdx1], kuiMv64 );
251 pMvComp->sMotionVectorCache[kiCacheIdx3]= *pMv;
252 pMvComp->sMotionVectorCache[kiCacheIdx6]= *pMv;
253 ST64( &pMvComp->sMotionVectorCache[kiCacheIdx7], kuiMv64 );
254 pMvComp->sMotionVectorCache[kiCacheIdx9]= *pMv;
255}
256//update uiRefIndex and pMv of both SMB and Mb_cache, only for P8x16
257void update_P8x16_motion_info(SMbCache* pMbCache, SMB* pCurMb, const int32_t kiPartIdx, const int8_t kiRef, SMVUnitXY* pMv)
258{
259 // optimized 11/25/2011
260 SMVComponentUnit *pMvComp = &pMbCache->sMvComponents;
261 const uint32_t kuiMv32 = LD32(pMv);
262 const uint64_t kuiMv64 = BUTTERFLY4x8(kuiMv32);
263 const int16_t kiScan4Idx = g_kuiMbCountScan4Idx[kiPartIdx];
264 const int16_t kiCacheIdx = g_kuiCache30ScanIdx[kiPartIdx];
265 const int16_t kiCacheIdx1 = 1+kiCacheIdx;
266 const int16_t kiCacheIdx3 = 3+kiCacheIdx;
267 const int16_t kiCacheIdx12 = 12+kiCacheIdx;
268 const int16_t kiCacheIdx13 = 13+kiCacheIdx;
269 const int16_t kiCacheIdx15 = 15+kiCacheIdx;
270 const int16_t kiBlkIdx = kiPartIdx>>2;
271 const uint16_t kuiRef16 = BUTTERFLY1x2(kiRef);
272
273 pCurMb->pRefIndex[kiBlkIdx] = kiRef;
274 pCurMb->pRefIndex[2+kiBlkIdx]= kiRef;
275 ST64( &pCurMb->sMv[kiScan4Idx], kuiMv64 );
276 ST64( &pCurMb->sMv[4+kiScan4Idx], kuiMv64 );
277 ST64( &pCurMb->sMv[8+kiScan4Idx], kuiMv64 );
278 ST64( &pCurMb->sMv[12+kiScan4Idx], kuiMv64 );
279
280 /*
281 * blocks 0: g_kuiCache30ScanIdx[iPartIdx]~g_kuiCache30ScanIdx[iPartIdx]+3, 1: g_kuiCache30ScanIdx[iPartIdx]+6~g_kuiCache30ScanIdx[iPartIdx]+9
282 */
283 pMvComp->iRefIndexCache[kiCacheIdx] = kiRef;
284 ST16(&pMvComp->iRefIndexCache[kiCacheIdx1], kuiRef16);
285 pMvComp->iRefIndexCache[kiCacheIdx3] = kiRef;
286 pMvComp->iRefIndexCache[kiCacheIdx12] = kiRef;
287 ST16(&pMvComp->iRefIndexCache[kiCacheIdx13], kuiRef16);
288 pMvComp->iRefIndexCache[kiCacheIdx15] = kiRef;
289
290 /*
291 * blocks 0: g_kuiCache30ScanIdx[iPartIdx]~g_kuiCache30ScanIdx[iPartIdx]+3, 1: g_kuiCache30ScanIdx[iPartIdx]+6~g_kuiCache30ScanIdx[iPartIdx]+9
292 */
293 pMvComp->sMotionVectorCache[kiCacheIdx] = *pMv;
294 ST64( &pMvComp->sMotionVectorCache[kiCacheIdx1], kuiMv64 );
295 pMvComp->sMotionVectorCache[kiCacheIdx3] = *pMv;
296 pMvComp->sMotionVectorCache[kiCacheIdx12] = *pMv;
297 ST64( &pMvComp->sMotionVectorCache[kiCacheIdx13], kuiMv64 );
298 pMvComp->sMotionVectorCache[kiCacheIdx15] = *pMv;
299}
300//update uiRefIndex and pMv of both SMB and Mb_cache, only for P8x8
301void UpdateP8x8MotionInfo(SMbCache* pMbCache, SMB* pCurMb, const int32_t kiPartIdx, const int8_t kiRef, SMVUnitXY* pMv)
302{
303 SMVComponentUnit *pMvComp = &pMbCache->sMvComponents;
304 const uint32_t kuiMv32 = LD32(pMv);
305 const uint64_t kuiMv64 = BUTTERFLY4x8(kuiMv32);
306 const int16_t kiScan4Idx = g_kuiMbCountScan4Idx[kiPartIdx];
307 const int16_t kiCacheIdx = g_kuiCache30ScanIdx[kiPartIdx];
308 const int16_t kiCacheIdx1 = 1+kiCacheIdx;
309 const int16_t kiCacheIdx6 = 6+kiCacheIdx;
310 const int16_t kiCacheIdx7 = 7+kiCacheIdx;
311
312 //mb
313 ST64( &pCurMb->sMv[ kiScan4Idx], kuiMv64 );
314 ST64( &pCurMb->sMv[4+kiScan4Idx], kuiMv64 );
315
316 //cache
317 pMvComp->iRefIndexCache[kiCacheIdx ] =
318 pMvComp->iRefIndexCache[kiCacheIdx1] =
319 pMvComp->iRefIndexCache[kiCacheIdx6] =
320 pMvComp->iRefIndexCache[kiCacheIdx7] = kiRef;
321 pMvComp->sMotionVectorCache[kiCacheIdx ] =
322 pMvComp->sMotionVectorCache[kiCacheIdx1] =
323 pMvComp->sMotionVectorCache[kiCacheIdx6] =
324 pMvComp->sMotionVectorCache[kiCacheIdx7] = *pMv;
325}
326
327//=========================update motion info(MV and ref_idx) into Mb_cache==========================
328//update pMv and uiRefIndex cache only for Mb_cache, only for P_16*16 (SKIP inclusive)
329
330//update uiRefIndex and pMv of only Mb_cache, only for P16x8
331void UpdateP16x8Motion2Cache(SMbCache* pMbCache, int32_t iPartIdx, int8_t iRef, SMVUnitXY* pMv)
332{
333 SMVComponentUnit *pMvComp = &pMbCache->sMvComponents;
334 int32_t i;
335
336 for (i = 0; i < 2; i++, iPartIdx+=4)
337 {
338 //cache
339 const uint8_t kuiCacheIdx = g_kuiCache30ScanIdx[iPartIdx];
340
341 pMvComp->iRefIndexCache[ kuiCacheIdx] =
342 pMvComp->iRefIndexCache[1+kuiCacheIdx] =
343 pMvComp->iRefIndexCache[6+kuiCacheIdx] =
344 pMvComp->iRefIndexCache[7+kuiCacheIdx] = iRef;
345 pMvComp->sMotionVectorCache[ kuiCacheIdx] =
346 pMvComp->sMotionVectorCache[1+kuiCacheIdx] =
347 pMvComp->sMotionVectorCache[6+kuiCacheIdx] =
348 pMvComp->sMotionVectorCache[7+kuiCacheIdx] = *pMv;
349 }
350}
351//update uiRefIndex and pMv of only Mb_cache, only for P8x16
352void UpdateP8x16Motion2Cache(SMbCache* pMbCache, int32_t iPartIdx, int8_t iRef, SMVUnitXY* pMv)
353{
354 SMVComponentUnit *pMvComp = &pMbCache->sMvComponents;
355 int32_t i;
356
357 for (i = 0; i < 2; i++, iPartIdx+=8)
358 {
359 //cache
360 const uint8_t kuiCacheIdx = g_kuiCache30ScanIdx[iPartIdx];
361
362 pMvComp->iRefIndexCache[ kuiCacheIdx] =
363 pMvComp->iRefIndexCache[1+kuiCacheIdx] =
364 pMvComp->iRefIndexCache[6+kuiCacheIdx] =
365 pMvComp->iRefIndexCache[7+kuiCacheIdx] = iRef;
366 pMvComp->sMotionVectorCache[ kuiCacheIdx] =
367 pMvComp->sMotionVectorCache[1+kuiCacheIdx] =
368 pMvComp->sMotionVectorCache[6+kuiCacheIdx] =
369 pMvComp->sMotionVectorCache[7+kuiCacheIdx] = *pMv;
370 }
371}
372
373//update uiRefIndex and pMv of only Mb_cache, only for P8x8
374void UpdateP8x8Motion2Cache(SMbCache* pMbCache, int32_t iPartIdx, int8_t pRef, SMVUnitXY* pMv)
375{
376 SMVComponentUnit *pMvComp = &pMbCache->sMvComponents;
377 const uint8_t kuiCacheIdx = g_kuiCache30ScanIdx[iPartIdx];
378
379 pMvComp->iRefIndexCache[ kuiCacheIdx] =
380 pMvComp->iRefIndexCache[1+kuiCacheIdx] =
381 pMvComp->iRefIndexCache[6+kuiCacheIdx] =
382 pMvComp->iRefIndexCache[7+kuiCacheIdx] = pRef;
383 pMvComp->sMotionVectorCache[ kuiCacheIdx] =
384 pMvComp->sMotionVectorCache[1+kuiCacheIdx] =
385 pMvComp->sMotionVectorCache[6+kuiCacheIdx] =
386 pMvComp->sMotionVectorCache[7+kuiCacheIdx] = *pMv;
387}
388
389} // namespace WelsSVCEnc

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t