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"
43+namespace WelsSVCEnc {
44+//basic pMv prediction unit for pMv width (4, 2, 1)
45+void 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+}
97+void 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+}
127+void 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+}
151+void 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)
169+void 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
217+void 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
257+void 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
301+void 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
331+void 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
352+void 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
374+void 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