1 /*
2 * Copyright © 2014 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
14 * of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Zhao Yakui <yakui.zhao@intel.com>
26 *
27 */
28
29 /*
30 * Copyright (c) 2010, The WebM Project authors. All rights reserved.
31 *
32 * An additional intellectual property rights grant can be found
33 * in the file LIBVPX_PATENTS. All contributing project authors may
34 * be found in the LIBVPX_AUTHORS file.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions are met:
38
39 * Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 *
42 * Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the distribution.
45
46 * Neither the name of Google, nor the WebM Project, nor the names
47 * of its contributors may be used to endorse or promote products
48 * derived from this software without specific prior written permission.
49 *
50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61 *
62 */
63
64 #include "intel_hybrid_hostvld_vp9_context.h"
65 #include "intel_hybrid_hostvld_vp9_context_tables.h"
66 #include "intel_hybrid_hostvld_vp9_engine.h"
67
68 #define VP9_DIFF_UPDATE_PROB 252
69 #define VP9_NMV_UPDATE_PROB 252
70 #define VP9_SUBEXP_PARAM 4 /* Subexponential code parameter */
71
72 #define VP9_COEFF_COUNT_SAT 24
73 #define VP9_COEFF_MAX_UPDATE_FACTOR 112
74 #define VP9_COEFF_COUNT_SAT_KEY 24
75 #define VP9_COEFF_MAX_UPDATE_FACTOR_KEY 112
76 #define VP9_COEFF_COUNT_SAT_AFTER_KEY 24
77 #define VP9_COEFF_MAX_UPDATE_FACTOR_AFTER_KEY 128
78
79 #define VP9_NODE_LEFT 0
80 #define VP9_NODE_RIGHT 1
81
82 #define VP9_COUNT_SAT 20
83 #define VP9_MAX_UPDATE_FACTOR 128
84
85 #define INTEL_VP9_RECENTER(v, m) (((v) > ((m) << 1)) ? (v) : ((v) % 2 ? (m) - (((v) + 1) >> 1) : (m) + ((v) >> 1)))
86 #define INTEL_VP9_GET_PROB(num, den) (((den) == 0) ? 128u : INTEL_VP9_CLAMP(((num) * 256 + ((den) >> 1)) / (den), 1, 255))
87 #define INTEL_VP9_GET_BINARY_PROB(n0, n1) INTEL_VP9_GET_PROB(n0, n0 + n1)
88
89 #define INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(pProbs, Count) \
90 Intel_HostvldVp9_MergeProb(pProbs, Count, VP9_COUNT_SAT, VP9_MAX_UPDATE_FACTOR)
91
92
93 static const INT g_Vp9InterModeLookup[INTER_MODE_COUNT] =
94 {
95 PRED_MD_ZEROMV - PRED_MD_NEARESTMV,
96 PRED_MD_NEARESTMV - PRED_MD_NEARESTMV,
97 PRED_MD_NEARMV - PRED_MD_NEARESTMV,
98 PRED_MD_NEWMV - PRED_MD_NEARESTMV
99 };
100
101 /********************************************************************/
102 /*********************** INTERNAL FUNCTIONS *************************/
103 /********************************************************************/
104
Intel_HostvldVp9_GetUnsignedBits(UINT uiNumValues)105 static INT Intel_HostvldVp9_GetUnsignedBits(UINT uiNumValues)
106 {
107 INT cat = 0;
108
109 if (uiNumValues <= 1)
110 {
111 return 0;
112 }
113
114 uiNumValues--;
115 while (uiNumValues > 0)
116 {
117 cat++;
118 uiNumValues >>= 1;
119 }
120
121 return cat;
122 }
123
Intel_HostvldVp9_InverseMap(INT v,INT m)124 static PROBABILITY Intel_HostvldVp9_InverseMap(INT v, INT m) {
125 // The clamp is not necessary for conforming VP9 stream, it is added to
126 // prevent out of bound access for bad input data
127 v = INTEL_VP9_CLAMP(v, 0, 253);
128 v = g_Vp9InverseMapTable[v];
129 m--;
130
131 if ((m << 1) <= VP9_MAX_PROB)
132 {
133 return 1 + INTEL_VP9_RECENTER(v, m);
134 }
135 else
136 {
137 return VP9_MAX_PROB - INTEL_VP9_RECENTER(v, VP9_MAX_PROB - 1 - m);
138 }
139 }
140
Intel_HostvldVp9_DecodeUniform(PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine,INT n)141 static INT Intel_HostvldVp9_DecodeUniform(
142 PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine,
143 INT n)
144 {
145 INT v;
146 const INT l = Intel_HostvldVp9_GetUnsignedBits(n);
147 const INT m = (1 << l) - n;
148
149 if (!l)
150 {
151 return 0;
152 }
153
154 v = INTEL_HOSTVLD_VP9_READ_BITS(l - 1);
155
156 return v < m ? v : (v << 1) - m + INTEL_HOSTVLD_VP9_READ_ONE_BIT;
157 }
158
Intel_HostvldVp9_DecodeSubExponential(PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine)159 static INT Intel_HostvldVp9_DecodeSubExponential(
160 PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine)
161 {
162 INT i = 0, mk = 0, iSubExp, iBits, a;
163
164 while (1)
165 {
166 iBits = i ? VP9_SUBEXP_PARAM + i - 1 : VP9_SUBEXP_PARAM;
167 a = 1 << iBits;
168
169 if (255 <= mk + (3 << iBits))
170 {
171 iSubExp = Intel_HostvldVp9_DecodeUniform(pBacEngine, 255 - mk) + mk;
172 break;
173 } else {
174 if (INTEL_HOSTVLD_VP9_READ_ONE_BIT)
175 {
176 i++;
177 mk += a;
178 }
179 else
180 {
181 iSubExp = INTEL_HOSTVLD_VP9_READ_BITS(iBits) + mk;
182 break;
183 }
184 }
185 }
186
187 return iSubExp;
188 }
189
Intel_HostvldVp9_UpdateProb(PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine,PPROBABILITY pProb)190 VOID Intel_HostvldVp9_UpdateProb(
191 PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine,
192 PPROBABILITY pProb)
193 {
194 BOOL bUpdate = INTEL_HOSTVLD_VP9_READ_BIT(VP9_DIFF_UPDATE_PROB);
195
196 if (bUpdate)
197 {
198 const int delp = Intel_HostvldVp9_DecodeSubExponential(pBacEngine);
199 *pProb = (PROBABILITY)Intel_HostvldVp9_InverseMap(delp, *pProb);
200 }
201 }
202
Intel_HostvldVp9_UpdateMvProb(PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine,PPROBABILITY pProb,DWORD n)203 VOID Intel_HostvldVp9_UpdateMvProb(
204 PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine,
205 PPROBABILITY pProb,
206 DWORD n)
207 {
208 DWORD i;
209
210 for (i = 0; i < n; i++)
211 {
212 if (INTEL_HOSTVLD_VP9_READ_BIT(VP9_NMV_UPDATE_PROB))
213 {
214 pProb[i] = (INTEL_HOSTVLD_VP9_READ_BITS(7) << 1) | 1;
215 }
216 }
217 }
218
Intel_HostvldVp9_GetBranchCount(UINT BranchCount[VP9_UNCONSTRAINED_NODES][2],UINT CoeffCounts[VP9_UNCONSTRAINED_NODES+1])219 static VOID Intel_HostvldVp9_GetBranchCount(
220 UINT BranchCount[VP9_UNCONSTRAINED_NODES][2],
221 UINT CoeffCounts[VP9_UNCONSTRAINED_NODES+1])
222 {
223 BranchCount[2][VP9_NODE_LEFT] = CoeffCounts[VP9_ONE_TOKEN];
224 BranchCount[2][VP9_NODE_RIGHT] = CoeffCounts[VP9_TWO_TOKEN];
225 BranchCount[1][VP9_NODE_LEFT] = CoeffCounts[VP9_ZERO_TOKEN];
226 BranchCount[1][VP9_NODE_RIGHT] = BranchCount[2][VP9_NODE_LEFT] + BranchCount[2][VP9_NODE_RIGHT];
227 BranchCount[0][VP9_NODE_LEFT] = CoeffCounts[VP9_DCT_EOB_MODEL_TOKEN];
228 BranchCount[0][VP9_NODE_RIGHT] = BranchCount[1][VP9_NODE_LEFT] + BranchCount[1][VP9_NODE_RIGHT];
229 }
230
Intel_HostvldVp9_MergeProb(PROBABILITY PrevProb,UINT Count[2],UINT uiCountSat,UINT uiUpdateFactor)231 static PROBABILITY Intel_HostvldVp9_MergeProb(
232 PROBABILITY PrevProb,
233 UINT Count[2],
234 UINT uiCountSat,
235 UINT uiUpdateFactor)
236 {
237 PROBABILITY Prob = INTEL_VP9_GET_BINARY_PROB(Count[VP9_NODE_LEFT], Count[VP9_NODE_RIGHT]);
238 UINT uiCount = MIN(Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT], uiCountSat);
239 UINT uiFactor = uiUpdateFactor * uiCount / uiCountSat;
240 return INTEL_VP9_ROUND_POWER_OF_TWO(PrevProb * (256 - uiFactor) + Prob * uiFactor, 8);;
241 }
242
Intel_HostvldVp9_AdaptProbsIntraMode(INTEL_HOSTVLD_VP9_TKN_TREE CurrTree,INTEL_HOSTVLD_VP9_TKN_TREE PrevTree,UINT CurrCounts[INTRA_MODE_COUNT])243 static VOID Intel_HostvldVp9_AdaptProbsIntraMode(
244 INTEL_HOSTVLD_VP9_TKN_TREE CurrTree,
245 INTEL_HOSTVLD_VP9_TKN_TREE PrevTree,
246 UINT CurrCounts[INTRA_MODE_COUNT])
247 {
248 UINT Count[2], RightNodeCount;
249
250 Count[VP9_NODE_RIGHT] = CurrCounts[PRED_MD_D207];
251 Count[VP9_NODE_LEFT] = CurrCounts[PRED_MD_D153];
252 CurrTree[16].ui8Prob = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevTree[16].ui8Prob, Count);
253
254 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
255 Count[VP9_NODE_LEFT] = CurrCounts[PRED_MD_D63];
256 CurrTree[14].ui8Prob = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevTree[14].ui8Prob, Count);
257
258 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
259 Count[VP9_NODE_LEFT] = CurrCounts[PRED_MD_D45];
260 CurrTree[8].ui8Prob = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevTree[8].ui8Prob, Count);
261 RightNodeCount = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
262
263 Count[VP9_NODE_RIGHT] = CurrCounts[PRED_MD_D117];
264 Count[VP9_NODE_LEFT] = CurrCounts[PRED_MD_D135];
265 CurrTree[10].ui8Prob = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevTree[10].ui8Prob, Count);
266
267 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
268 Count[VP9_NODE_LEFT] = CurrCounts[PRED_MD_H];
269 CurrTree[7].ui8Prob = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevTree[7].ui8Prob, Count);
270
271 Count[VP9_NODE_LEFT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
272 Count[VP9_NODE_RIGHT] = RightNodeCount;
273 CurrTree[6].ui8Prob = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevTree[6].ui8Prob, Count);
274
275 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
276 Count[VP9_NODE_LEFT] = CurrCounts[PRED_MD_V];
277 CurrTree[4].ui8Prob = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevTree[4].ui8Prob, Count);
278
279 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
280 Count[VP9_NODE_LEFT] = CurrCounts[PRED_MD_TM];
281 CurrTree[2].ui8Prob = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevTree[2].ui8Prob, Count);
282
283 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
284 Count[VP9_NODE_LEFT] = CurrCounts[PRED_MD_DC];
285 CurrTree[0].ui8Prob = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevTree[0].ui8Prob, Count);
286 }
287
Intel_HostvldVp9_AdaptProbsMvClass(UINT8 CurrProbs[VP9_MV_CLASSES-1],UINT8 PrevProbs[VP9_MV_CLASSES-1],UINT CurrCounts[VP9_MV_CLASSES])288 static VOID Intel_HostvldVp9_AdaptProbsMvClass(
289 UINT8 CurrProbs[VP9_MV_CLASSES - 1],
290 UINT8 PrevProbs[VP9_MV_CLASSES - 1],
291 UINT CurrCounts[VP9_MV_CLASSES])
292 {
293 UINT Count[2], RightNodeCount;
294
295 Count[VP9_NODE_RIGHT] = CurrCounts[VP9_MV_CLASS_10];
296 Count[VP9_NODE_LEFT] = CurrCounts[VP9_MV_CLASS_9];
297 CurrProbs[9] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[9], Count);
298 RightNodeCount = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
299
300 Count[VP9_NODE_RIGHT] = CurrCounts[VP9_MV_CLASS_8];
301 Count[VP9_NODE_LEFT] = CurrCounts[VP9_MV_CLASS_7];
302 CurrProbs[8] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[8], Count);
303
304 Count[VP9_NODE_LEFT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
305 Count[VP9_NODE_RIGHT] = RightNodeCount;
306 CurrProbs[7] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[7], Count);
307
308 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
309 Count[VP9_NODE_LEFT] = CurrCounts[VP9_MV_CLASS_6];
310 CurrProbs[6] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[6], Count);
311 RightNodeCount = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
312
313 Count[VP9_NODE_RIGHT] = CurrCounts[VP9_MV_CLASS_5];
314 Count[VP9_NODE_LEFT] = CurrCounts[VP9_MV_CLASS_4];
315 CurrProbs[5] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[5], Count);
316
317 Count[VP9_NODE_LEFT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
318 Count[VP9_NODE_RIGHT] = RightNodeCount;
319 CurrProbs[4] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[4], Count);
320 RightNodeCount = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
321
322 Count[VP9_NODE_RIGHT] = CurrCounts[VP9_MV_CLASS_3];
323 Count[VP9_NODE_LEFT] = CurrCounts[VP9_MV_CLASS_2];
324 CurrProbs[3] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[3], Count);
325
326 Count[VP9_NODE_LEFT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
327 Count[VP9_NODE_RIGHT] = RightNodeCount;
328 CurrProbs[2] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[2], Count);
329
330 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
331 Count[VP9_NODE_LEFT] = CurrCounts[VP9_MV_CLASS_1];
332 CurrProbs[1] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[1], Count);
333
334 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
335 Count[VP9_NODE_LEFT] = CurrCounts[VP9_MV_CLASS_0];
336 CurrProbs[0] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[0], Count);
337 }
338
Intel_HostvldVp9_AdaptProbs3NodeTreeWithIndex(UINT8 CurrProbs[3],UINT8 PrevProbs[3],UINT CurrCounts[4],const INT Index[4])339 static VOID Intel_HostvldVp9_AdaptProbs3NodeTreeWithIndex(
340 UINT8 CurrProbs[3],
341 UINT8 PrevProbs[3],
342 UINT CurrCounts[4],
343 const INT Index[4])
344 {
345 UINT Count[2];
346
347 Count[VP9_NODE_RIGHT] = CurrCounts[Index[3]];
348 Count[VP9_NODE_LEFT] = CurrCounts[Index[2]];
349 CurrProbs[2] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[2], Count);
350
351 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
352 Count[VP9_NODE_LEFT] = CurrCounts[Index[1]];
353 CurrProbs[1] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[1], Count);
354
355 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
356 Count[VP9_NODE_LEFT] = CurrCounts[Index[0]];
357 CurrProbs[0] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[0], Count);
358 }
359
Intel_HostvldVp9_AdaptProbs3NodeTree(UINT8 CurrProbs[3],UINT8 PrevProbs[3],UINT CurrCounts[4])360 static VOID Intel_HostvldVp9_AdaptProbs3NodeTree(
361 UINT8 CurrProbs[3],
362 UINT8 PrevProbs[3],
363 UINT CurrCounts[4])
364 {
365 UINT Count[2];
366
367 Count[VP9_NODE_RIGHT] = CurrCounts[3];
368 Count[VP9_NODE_LEFT] = CurrCounts[2];
369 CurrProbs[2] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[2], Count);
370
371 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
372 Count[VP9_NODE_LEFT] = CurrCounts[1];
373 CurrProbs[1] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[1], Count);
374
375 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
376 Count[VP9_NODE_LEFT] = CurrCounts[0];
377 CurrProbs[0] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[0], Count);
378 }
379
Intel_HostvldVp9_AdaptProbs2NodeTree(UINT8 CurrProbs[2],UINT8 PrevProbs[2],UINT CurrCounts[3])380 static VOID Intel_HostvldVp9_AdaptProbs2NodeTree(
381 UINT8 CurrProbs[2],
382 UINT8 PrevProbs[2],
383 UINT CurrCounts[3])
384 {
385 UINT Count[2];
386
387 Count[VP9_NODE_RIGHT] = CurrCounts[2];
388 Count[VP9_NODE_LEFT] = CurrCounts[1];
389 CurrProbs[1] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[1], Count);
390
391 Count[VP9_NODE_RIGHT] = Count[VP9_NODE_LEFT] + Count[VP9_NODE_RIGHT];
392 Count[VP9_NODE_LEFT] = CurrCounts[0];
393 CurrProbs[0] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(PrevProbs[0], Count);
394 }
395
Intel_HostvldVp9_AdaptCoeffProbs(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCurrContext,PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pPrevContext,PINTEL_HOSTVLD_VP9_COUNT pCount,PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)396 static VAStatus Intel_HostvldVp9_AdaptCoeffProbs(
397 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCurrContext,
398 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pPrevContext,
399 PINTEL_HOSTVLD_VP9_COUNT pCount,
400 PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)
401 {
402 UINT uiCountSat, uiUpdateFactor;
403 INT i, j, k, l, m, n;
404 UINT BranchCount[VP9_UNCONSTRAINED_NODES][2];
405 VAStatus eStatus = VA_STATUS_SUCCESS;
406
407 if (pFrameInfo->bIsIntraOnly)
408 {
409 uiCountSat = VP9_COEFF_COUNT_SAT_KEY;
410 uiUpdateFactor = VP9_COEFF_MAX_UPDATE_FACTOR_KEY;
411 }
412 else if (pFrameInfo->LastFrameType == KEY_FRAME)
413 {
414 uiCountSat = VP9_COEFF_COUNT_SAT_AFTER_KEY;
415 uiUpdateFactor = VP9_COEFF_MAX_UPDATE_FACTOR_AFTER_KEY;
416 }
417 else
418 {
419 uiCountSat = VP9_COEFF_COUNT_SAT;
420 uiUpdateFactor = VP9_COEFF_MAX_UPDATE_FACTOR;
421 }
422
423 // Coefficient probabilities
424 for (n = TX_4X4; n < TX_SIZES; n++)
425 {
426 for (i = 0; i < INTEL_HOSTVLD_VP9_YUV_PLANE_NUMBER; i++)
427 {
428 for (j = 0; j < REF_TYPES; j++)
429 {
430 for (k = 0; k < VP9_COEF_BANDS; k++)
431 {
432 for (l = 0; l < VP9_PREV_COEF_CONTEXTS; l++)
433 {
434 if (k == 0 && l >= 3)
435 {
436 continue;
437 }
438
439 Intel_HostvldVp9_GetBranchCount(BranchCount, pCount->CoeffCounts[n][i][j][k][l]);
440 BranchCount[0][1] = pCount->EobBranchCounts[n][i][j][k][l] - BranchCount[0][0];
441
442 for (m = 0; m < VP9_UNCONSTRAINED_NODES; m++)
443 {
444 pCurrContext->CoeffProbs[n][i][j][k][l][m] = Intel_HostvldVp9_MergeProb(
445 pPrevContext->CoeffProbs[n][i][j][k][l][m],
446 BranchCount[m],
447 uiCountSat,
448 uiUpdateFactor);
449 }
450 }
451 }
452 }
453 }
454 }
455
456 return eStatus;
457 }
458
Intel_HostvldVp9_AdaptModeProbs(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCurrContext,PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pPrevContext,PINTEL_HOSTVLD_VP9_COUNT pCount,PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)459 static VAStatus Intel_HostvldVp9_AdaptModeProbs(
460 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCurrContext,
461 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pPrevContext,
462 PINTEL_HOSTVLD_VP9_COUNT pCount,
463 PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)
464 {
465 INT i, j;
466 VAStatus eStatus = VA_STATUS_SUCCESS;
467
468 for (i = 0; i < VP9_INTRA_INTER_CONTEXTS; i++)
469 {
470 pCurrContext->IntraInterProbs[i] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
471 pPrevContext->IntraInterProbs[i],
472 pCount->IntraInterCounts[i]);
473 }
474
475 for (i = 0; i < VP9_COMPOUND_INTER_CONTEXTS; i++)
476 {
477 pCurrContext->CompoundInterProbs[i] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
478 pPrevContext->CompoundInterProbs[i],
479 pCount->CompoundInterCounts[i]);
480 }
481
482 for (i = 0; i < VP9_REF_CONTEXTS; i++)
483 {
484 pCurrContext->CompoundRefProbs[i] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
485 pPrevContext->CompoundRefProbs[i],
486 pCount->CompoundRefCounts[i]);
487 }
488
489 // adapt inter mode contexts
490 for (i = 0; i < VP9_REF_CONTEXTS; i++)
491 {
492 for (j = 0; j < 2; j++)
493 {
494 pCurrContext->SingleRefProbs[i][j] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
495 pPrevContext->SingleRefProbs[i][j],
496 pCount->SingleRefCounts[i][j]);
497 }
498 }
499
500 for (i = 0; i < VP9_INTER_MODE_CONTEXTS; i++)
501 {
502 Intel_HostvldVp9_AdaptProbs3NodeTreeWithIndex(
503 pCurrContext->InterModeProbs[i],
504 pPrevContext->InterModeProbs[i],
505 pCount->InterModeCounts[i],
506 g_Vp9InterModeLookup);
507 }
508
509 for (i = 0; i < VP9_BLK_SIZE_GROUPS; i++)
510 {
511 Intel_HostvldVp9_AdaptProbsIntraMode(
512 pCurrContext->ModeTree_Y[i],
513 pPrevContext->ModeTree_Y[i],
514 pCount->IntraModeCounts_Y[i]);
515 }
516
517 for (i = 0; i < INTRA_MODE_COUNT; i++)
518 {
519 Intel_HostvldVp9_AdaptProbsIntraMode(
520 pCurrContext->ModeTree_UV[i],
521 pPrevContext->ModeTree_UV[i],
522 pCount->IntraModeCounts_UV[i]);
523 }
524
525 // adapt partition contexts
526 for (i = 0; i < VP9_PARTITION_CONTEXTS; i++)
527 {
528 Intel_HostvldVp9_AdaptProbs3NodeTree(
529 pCurrContext->PartitionProbs[i].Prob,
530 pPrevContext->PartitionProbs[i].Prob,
531 pCount->PartitionCounts[i]);
532 }
533
534 // adapt switchable interpolation contexts
535 if (pFrameInfo->bIsSwitchableInterpolation)
536 {
537 for (i = 0; i < VP9_SWITCHABLE_FILTER_CONTEXTS; i++)
538 {
539 Intel_HostvldVp9_AdaptProbs2NodeTree(
540 pCurrContext->SwitchableInterpProbs[i],
541 pPrevContext->SwitchableInterpProbs[i],
542 pCount->SwitchableInterpCounts[i]);
543 }
544 }
545
546 if (pFrameInfo->TxMode == TX_MODE_SELECT)
547 {
548 PUINT puiTxCounts;
549 UINT uiBranchCounts[3][2];
550
551 for (i = 0; i < VP9_TX_SIZE_CONTEXTS; i++)
552 {
553 // 8x8 or less transform
554 puiTxCounts = pCount->TxCountSet.Tx_8X8[i];
555 uiBranchCounts[0][0] = puiTxCounts[TX_4X4];
556 uiBranchCounts[0][1] = puiTxCounts[TX_8X8];
557 pCurrContext->TxProbTableSet.Tx_8X8[i][0] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
558 pPrevContext->TxProbTableSet.Tx_8X8[i][0],
559 uiBranchCounts[0]);
560
561 // 16x16 transform
562 puiTxCounts = pCount->TxCountSet.Tx_16X16[i];
563 uiBranchCounts[0][0] = puiTxCounts[TX_4X4];
564 uiBranchCounts[0][1] = puiTxCounts[TX_8X8] + puiTxCounts[TX_16X16];
565 uiBranchCounts[1][0] = puiTxCounts[TX_8X8];
566 uiBranchCounts[1][1] = puiTxCounts[TX_16X16];
567 for (j = 0; j < TX_SIZES - 2; j++)
568 {
569 pCurrContext->TxProbTableSet.Tx_16X16[i][j] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
570 pPrevContext->TxProbTableSet.Tx_16X16[i][j],
571 uiBranchCounts[j]);
572 }
573
574 // 32x32 transform
575 puiTxCounts = pCount->TxCountSet.Tx_32X32[i];
576 uiBranchCounts[0][0] = puiTxCounts[TX_4X4];
577 uiBranchCounts[0][1] = puiTxCounts[TX_8X8] + puiTxCounts[TX_16X16] + puiTxCounts[TX_32X32];
578 uiBranchCounts[1][0] = puiTxCounts[TX_8X8];
579 uiBranchCounts[1][1] = puiTxCounts[TX_16X16] + puiTxCounts[TX_32X32];
580 uiBranchCounts[2][0] = puiTxCounts[TX_16X16];
581 uiBranchCounts[2][1] = puiTxCounts[TX_32X32];
582 for (j = 0; j < TX_SIZES - 1; j++)
583 {
584 pCurrContext->TxProbTableSet.Tx_32X32[i][j] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
585 pPrevContext->TxProbTableSet.Tx_32X32[i][j],
586 uiBranchCounts[j]);
587 }
588 }
589 }
590
591 for (i = 0; i < VP9_MBSKIP_CONTEXTS; i++)
592 {
593 pCurrContext->MbSkipProbs[i] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
594 pPrevContext->MbSkipProbs[i],
595 pCount->MbSkipCounts[i]);
596 }
597
598 return eStatus;
599 }
600
Intel_HostvldVp9_AdaptMvProbs(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCurrContext,PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pPrevContext,PINTEL_HOSTVLD_VP9_COUNT pCount,PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)601 static VAStatus Intel_HostvldVp9_AdaptMvProbs(
602 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCurrContext,
603 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pPrevContext,
604 PINTEL_HOSTVLD_VP9_COUNT pCount,
605 PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)
606 {
607 INT i, j;
608 VAStatus eStatus = VA_STATUS_SUCCESS;
609
610
611 Intel_HostvldVp9_AdaptProbs3NodeTree(
612 pCurrContext->MvJointProbs,
613 pPrevContext->MvJointProbs,
614 pCount->MvJointCounts);
615
616 for (i = 0; i < VP9_MV_COMPONENTS; i++)
617 {
618 PINTEL_HOSTVLD_VP9_MV_PROB_SET pCurrMvProbs = pCurrContext->MvProbSet + i;
619 PINTEL_HOSTVLD_VP9_MV_PROB_SET pPrevMvProbs = pPrevContext->MvProbSet + i;
620 PINTEL_HOSTVLD_VP9_MV_COUNT_SET pMvCounts = pCount->MvCountSet + i;
621
622 pCurrMvProbs->MvSignProbs = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
623 pPrevMvProbs->MvSignProbs,
624 pMvCounts->MvSignCounts);
625
626 Intel_HostvldVp9_AdaptProbsMvClass(
627 pCurrMvProbs->MvClassProbs,
628 pPrevMvProbs->MvClassProbs,
629 pMvCounts->MvClassCounts);
630
631 pCurrMvProbs->MvClass0Probs[0] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
632 pPrevMvProbs->MvClass0Probs[0],
633 pMvCounts->MvClass0Counts);
634
635 for (j = 0; j < VP9_MV_OFFSET_BITS; j++)
636 {
637 pCurrMvProbs->MvBitsProbs[j] = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
638 pPrevMvProbs->MvBitsProbs[j],
639 pMvCounts->MvBitsCounts[j]);
640 }
641
642 for (j = 0; j < VP9_MV_CLASS0_SIZE; j++)
643 {
644 Intel_HostvldVp9_AdaptProbs3NodeTree(
645 pCurrMvProbs->MvClass0FpProbs[j],
646 pPrevMvProbs->MvClass0FpProbs[j],
647 pMvCounts->MvClass0FpCounts[j]);
648 }
649
650 Intel_HostvldVp9_AdaptProbs3NodeTree(
651 pCurrMvProbs->MvFpProbs,
652 pPrevMvProbs->MvFpProbs,
653 pMvCounts->MvFpCounts);
654
655 if (pFrameInfo->bAllowHighPrecisionMv)
656 {
657 pCurrMvProbs->MvClass0HpProbs = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
658 pPrevMvProbs->MvClass0HpProbs,
659 pMvCounts->MvClass0HpCounts);
660
661 pCurrMvProbs->MvHpProbs = INTEL_HOSTVLD_VP9_MERGE_PROB_MAX(
662 pPrevMvProbs->MvHpProbs,
663 pMvCounts->MvHpCounts);
664 }
665 }
666
667 return eStatus;
668 }
669
Intel_HostvldVp9_InitializeProbabilities(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pContext)670 VAStatus Intel_HostvldVp9_InitializeProbabilities(
671 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pContext)
672 {
673 size_t Size;
674 VAStatus eStatus = VA_STATUS_SUCCESS;
675
676
677 Size = sizeof(pContext->TxProbTableSet);
678 memcpy(
679 &pContext->TxProbTableSet,
680 &g_Vp9DefaultTxProbs,
681 Size);
682 Size = VP9_MBSKIP_CONTEXTS * sizeof(pContext->MbSkipProbs[0]);
683 memcpy(
684 pContext->MbSkipProbs,
685 g_Vp9DefaultMbSkipProbs,
686 Size);
687 Size = VP9_PARTITION_CONTEXTS * sizeof(pContext->PartitionProbs[0]);
688 memcpy(
689 pContext->PartitionProbs,
690 g_Vp9DefaultPartitionProbs,
691 Size);
692
693 // inter probs
694 Size = VP9_BLK_SIZE_GROUPS * sizeof(pContext->ModeTree_Y[0]);
695 memcpy(
696 pContext->ModeTree_Y,
697 g_Vp9DefaultIntraInInterProbTreeY,
698 Size);
699 Size = INTRA_MODE_COUNT * sizeof(pContext->ModeTree_UV[0]);
700 memcpy(
701 pContext->ModeTree_UV,
702 g_Vp9DefaultIntraInInterProbTreeUV,
703 Size);
704 Size = VP9_INTER_MODE_CONTEXTS * (INTER_MODE_COUNT - 1) *
705 sizeof(pContext->InterModeProbs[0][0]);
706 memcpy(
707 pContext->InterModeProbs,
708 g_Vp9DefaultInterModeProbs,
709 Size);
710 Size = VP9_SWITCHABLE_FILTER_CONTEXTS * (VP9_SWITCHABLE_FILTERS - 1) *
711 sizeof(pContext->SwitchableInterpProbs[0][0]);
712 memcpy(
713 pContext->SwitchableInterpProbs,
714 g_Vp9DefaultSwitchableInterpProbs,
715 Size);
716 Size = VP9_INTRA_INTER_CONTEXTS * sizeof(pContext->IntraInterProbs[0]);
717 memcpy(
718 &pContext->IntraInterProbs[0],
719 g_Vp9DefaultIntraInterProbs,
720 Size);
721 Size = VP9_COMPOUND_INTER_CONTEXTS * sizeof(pContext->CompoundInterProbs[0]);
722 memcpy(
723 &pContext->CompoundInterProbs[0],
724 g_Vp9DefaultCompoundInterProbs,
725 Size);
726 Size = VP9_REF_CONTEXTS * 2 * sizeof(pContext->SingleRefProbs[0][0]);
727 memcpy(
728 pContext->SingleRefProbs,
729 g_Vp9DefaultSingleRefProbs,
730 Size);
731 Size = VP9_REF_CONTEXTS * sizeof(pContext->CompoundRefProbs[0]);
732 memcpy(
733 &pContext->CompoundRefProbs[0],
734 g_Vp9DefaultCompoundRefProbs,
735 Size);
736
737 // mv probs
738 Size = (VP9_MV_JOINTS - 1) * sizeof(pContext->MvJointProbs[0]);
739 memcpy(
740 &pContext->MvJointProbs[0],
741 g_Vp9DefaultMvJointProbs,
742 Size);
743 Size = VP9_MV_COMPONENTS * sizeof(pContext->MvProbSet[0]);
744 memcpy(
745 &pContext->MvProbSet[0],
746 g_Vp9DefaultMvProbSet,
747 Size);
748
749 // coefficient probs
750 Size = TX_SIZES * INTEL_HOSTVLD_VP9_YUV_PLANE_NUMBER *
751 REF_TYPES * VP9_COEF_BANDS * VP9_PREV_COEF_CONTEXTS * VP9_UNCONSTRAINED_NODES *
752 sizeof(pContext->CoeffProbs[0][0][0][0][0][0]);
753 memcpy(
754 pContext->CoeffProbs,
755 g_Vp9DefaultCoeffProbs,
756 Size);
757
758 return eStatus;
759 }
760
761 /******************************************************************/
762 /*********************** PUBLIC FUNCTIONS *************************/
763 /******************************************************************/
764
Intel_HostvldVp9_GetCurrFrameContext(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCtxTable,PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)765 VAStatus Intel_HostvldVp9_GetCurrFrameContext(
766 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCtxTable,
767 PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)
768 {
769 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pContext;
770 VAStatus eStatus = VA_STATUS_SUCCESS;
771
772 if (pFrameInfo->uiFrameContextIndex >= 4)
773 {
774 eStatus = VA_STATUS_ERROR_INVALID_PARAMETER;
775 goto finish;
776 }
777 memcpy(
778 pFrameInfo->pContext,
779 pCtxTable + pFrameInfo->uiFrameContextIndex,
780 sizeof(*(pCtxTable + pFrameInfo->uiFrameContextIndex)));
781
782 //reset TxProbTables pointers.
783 pContext = pFrameInfo->pContext;
784 pContext->TxProbTables[TX_8X8].pui8ProbTable = &pContext->TxProbTableSet.Tx_8X8[0][0];
785 pContext->TxProbTables[TX_8X8].uiStride = TX_8X8;
786 pContext->TxProbTables[TX_16X16].pui8ProbTable = &pContext->TxProbTableSet.Tx_16X16[0][0];
787 pContext->TxProbTables[TX_16X16].uiStride = TX_16X16;
788 pContext->TxProbTables[TX_32X32].pui8ProbTable = &pContext->TxProbTableSet.Tx_32X32[0][0];
789 pContext->TxProbTables[TX_32X32].uiStride = TX_32X32;
790
791 finish:
792 return eStatus;
793 }
794
Intel_HostvldVp9_ResetContext(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCtxTable,PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)795 VAStatus Intel_HostvldVp9_ResetContext(
796 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCtxTable,
797 PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)
798 {
799 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pContext;
800 BOOL bResetAll, bResetSpecified;
801 VAStatus eStatus = VA_STATUS_SUCCESS;
802
803
804 bResetAll =
805 (pFrameInfo->bIsKeyFrame ||
806 pFrameInfo->bErrorResilientMode ||
807 (pFrameInfo->uiResetFrameContext == 3));
808
809 bResetSpecified = (pFrameInfo->uiResetFrameContext == 2);
810
811 pFrameInfo->bResetContext = (bResetAll || bResetSpecified);
812
813 if (bResetAll)
814 {
815 Intel_HostvldVp9_InitializeProbabilities(
816 pFrameInfo->pContext);
817 //all 4 context tables updating will be done in postparser thread
818 }
819 else if (bResetSpecified)
820 {
821 if (pFrameInfo->uiFrameContextIndex >= 4)
822 {
823 eStatus = VA_STATUS_ERROR_INVALID_PARAMETER;
824 goto finish;
825 }
826 Intel_HostvldVp9_InitializeProbabilities(
827 pCtxTable + pFrameInfo->uiFrameContextIndex);
828
829 memcpy(
830 pFrameInfo->pContext,
831 pCtxTable,
832 sizeof(*pCtxTable));
833 }
834
835 //reset TxProbTables pointers.
836 pContext = pFrameInfo->pContext;
837 pContext->TxProbTables[TX_8X8].pui8ProbTable = &pContext->TxProbTableSet.Tx_8X8[0][0];
838 pContext->TxProbTables[TX_8X8].uiStride = TX_8X8;
839 pContext->TxProbTables[TX_16X16].pui8ProbTable = &pContext->TxProbTableSet.Tx_16X16[0][0];
840 pContext->TxProbTables[TX_16X16].uiStride = TX_16X16;
841 pContext->TxProbTables[TX_32X32].pui8ProbTable = &pContext->TxProbTableSet.Tx_32X32[0][0];
842 pContext->TxProbTables[TX_32X32].uiStride = TX_32X32;
843
844 pFrameInfo->uiFrameContextIndex = 0;
845
846 finish:
847 return eStatus;
848 }
849
Intel_HostvldVp9_UpdateContextTables(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCtxTable,PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)850 VAStatus Intel_HostvldVp9_UpdateContextTables(
851 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCtxTable,
852 PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)
853 {
854 VAStatus eStatus = VA_STATUS_SUCCESS;
855
856 if (pFrameInfo->bIsKeyFrame ||
857 pFrameInfo->bErrorResilientMode ||
858 (pFrameInfo->uiResetFrameContext == 3))
859 {
860 INT i;
861 Intel_HostvldVp9_InitializeProbabilities(
862 pCtxTable);
863
864 for (i = 1; i < 4; i++)
865 {
866 memcpy(
867 pCtxTable + i,
868 pCtxTable,
869 sizeof(*pCtxTable));
870 }
871 }
872
873 return eStatus;
874 }
875
Intel_HostvldVp9_SetupSegmentationProbs(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pContext,PUCHAR pSegTreeProb,PUCHAR pSegPredProb)876 VAStatus Intel_HostvldVp9_SetupSegmentationProbs(
877 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pContext,
878 PUCHAR pSegTreeProb,
879 PUCHAR pSegPredProb)
880 {
881 size_t Size;
882 VAStatus eStatus = VA_STATUS_SUCCESS;
883
884 INTEL_HOSTVLD_VP9_SEGMENT_TREE SegTree = INTEL_HOSTVLD_VP9_SEGMENT_PROB_TREE(
885 pSegTreeProb[0],
886 pSegTreeProb[1],
887 pSegTreeProb[2],
888 pSegTreeProb[3],
889 pSegTreeProb[4],
890 pSegTreeProb[5],
891 pSegTreeProb[6]);
892
893 Size = sizeof(pContext->SegmentTree);
894 memcpy(
895 &pContext->SegmentTree,
896 &SegTree,
897 Size);
898 Size = sizeof(pContext->SegPredProbs);
899 memcpy(
900 pContext->SegPredProbs,
901 pSegPredProb,
902 Size);
903
904 return eStatus;
905 }
906
Intel_HostvldVp9_ReadProbabilitiesInter(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pContext,PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo,PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine)907 VAStatus Intel_HostvldVp9_ReadProbabilitiesInter(
908 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pContext,
909 PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo,
910 PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine)
911 {
912 INT i, j;
913 PBOOL pbRefFrameSignBias;
914 DWORD dwPredictionMode;
915 VAStatus eStatus = VA_STATUS_SUCCESS;
916
917 pbRefFrameSignBias = pFrameInfo->RefFrameSignBias;
918
919 // inter mode probs
920 for (i = 0; i < VP9_INTER_MODE_CONTEXTS; i++)
921 {
922 for (j = 0; j < INTER_MODE_COUNT - 1; j++)
923 {
924 Intel_HostvldVp9_UpdateProb(pBacEngine, pContext->InterModeProbs[i] + j);
925 }
926 }
927
928 if (pFrameInfo->bIsSwitchableInterpolation)
929 {
930 // switchable interpolation probs
931 for (i = 0; i < VP9_SWITCHABLE_FILTER_CONTEXTS; i++)
932 {
933 for (j = 0; j < VP9_SWITCHABLE_FILTERS - 1; j++)
934 {
935 Intel_HostvldVp9_UpdateProb(pBacEngine, pContext->SwitchableInterpProbs[i] + j);
936 }
937 }
938 }
939
940 // intra inter probs
941 for (i = 0; i < VP9_INTRA_INTER_CONTEXTS; ++i)
942 {
943 Intel_HostvldVp9_UpdateProb(pBacEngine, pContext->IntraInterProbs + i);
944 }
945
946 // compound prediction probs
947 dwPredictionMode = VP9_SINGLE_PREDICTION_ONLY;
948 if ((pbRefFrameSignBias[VP9_REF_FRAME_GOLDEN] != pbRefFrameSignBias[VP9_REF_FRAME_LAST]) ||
949 (pbRefFrameSignBias[VP9_REF_FRAME_ALTREF] != pbRefFrameSignBias[VP9_REF_FRAME_LAST]))
950 {
951 // compound allowed, read prediction mode
952 if (INTEL_HOSTVLD_VP9_READ_ONE_BIT)
953 {
954 dwPredictionMode = INTEL_HOSTVLD_VP9_READ_ONE_BIT ? VP9_HYBRID_PREDICTION : VP9_COMPOUND_PREDICTION_ONLY;
955 }
956
957 // setup frame level compound prediction reference frame
958 if (pbRefFrameSignBias[VP9_REF_FRAME_LAST] == pbRefFrameSignBias[VP9_REF_FRAME_GOLDEN])
959 {
960 pFrameInfo->CompondFixedRef = VP9_REF_FRAME_ALTREF;
961 pFrameInfo->CompondVarRef[0] = VP9_REF_FRAME_LAST;
962 pFrameInfo->CompondVarRef[1] = VP9_REF_FRAME_GOLDEN;
963 }
964 else if (pbRefFrameSignBias[VP9_REF_FRAME_LAST] == pbRefFrameSignBias[VP9_REF_FRAME_ALTREF])
965 {
966 pFrameInfo->CompondFixedRef = VP9_REF_FRAME_GOLDEN;
967 pFrameInfo->CompondVarRef[0] = VP9_REF_FRAME_LAST;
968 pFrameInfo->CompondVarRef[1] = VP9_REF_FRAME_ALTREF;
969 }
970 else
971 {
972 pFrameInfo->CompondFixedRef = VP9_REF_FRAME_LAST;
973 pFrameInfo->CompondVarRef[0] = VP9_REF_FRAME_GOLDEN;
974 pFrameInfo->CompondVarRef[1] = VP9_REF_FRAME_ALTREF;
975 }
976 }
977
978 pFrameInfo->dwPredictionMode = dwPredictionMode;
979
980 // compound inter probs
981 if (dwPredictionMode == VP9_HYBRID_PREDICTION)
982 {
983 for (i = 0; i < VP9_COMPOUND_INTER_CONTEXTS; i++)
984 {
985 Intel_HostvldVp9_UpdateProb(pBacEngine, pContext->CompoundInterProbs + i);
986 }
987 }
988
989 // single reference probs
990 if (dwPredictionMode != VP9_COMPOUND_PREDICTION_ONLY)
991 {
992 for (i = 0; i < VP9_REF_CONTEXTS; i++)
993 {
994 Intel_HostvldVp9_UpdateProb(pBacEngine, pContext->SingleRefProbs[i]);
995 Intel_HostvldVp9_UpdateProb(pBacEngine, pContext->SingleRefProbs[i] + 1);
996 }
997 }
998
999 // compound reference probs
1000 if (dwPredictionMode != VP9_SINGLE_PREDICTION_ONLY)
1001 {
1002 for (i = 0; i < VP9_REF_CONTEXTS; i++)
1003 {
1004 Intel_HostvldVp9_UpdateProb(pBacEngine, pContext->CompoundRefProbs + i);
1005 }
1006 }
1007
1008 // Luma intra mode probs
1009 for (i = 0; i < VP9_BLK_SIZE_GROUPS; i++)
1010 {
1011 Intel_HostvldVp9_UpdateProb(pBacEngine, &(pContext->ModeTree_Y[i][0].ui8Prob));
1012 Intel_HostvldVp9_UpdateProb(pBacEngine, &(pContext->ModeTree_Y[i][2].ui8Prob));
1013 Intel_HostvldVp9_UpdateProb(pBacEngine, &(pContext->ModeTree_Y[i][4].ui8Prob));
1014 Intel_HostvldVp9_UpdateProb(pBacEngine, &(pContext->ModeTree_Y[i][6].ui8Prob));
1015 Intel_HostvldVp9_UpdateProb(pBacEngine, &(pContext->ModeTree_Y[i][7].ui8Prob));
1016 Intel_HostvldVp9_UpdateProb(pBacEngine, &(pContext->ModeTree_Y[i][10].ui8Prob));
1017 Intel_HostvldVp9_UpdateProb(pBacEngine, &(pContext->ModeTree_Y[i][8].ui8Prob));
1018 Intel_HostvldVp9_UpdateProb(pBacEngine, &(pContext->ModeTree_Y[i][14].ui8Prob));
1019 Intel_HostvldVp9_UpdateProb(pBacEngine, &(pContext->ModeTree_Y[i][16].ui8Prob));
1020 }
1021
1022 // partition probs
1023 for (i = 0; i < VP9_PARTITION_CONTEXTS; i++)
1024 {
1025 for (j = 0; j < PARTITION_TYPES - 1; j++)
1026 {
1027 Intel_HostvldVp9_UpdateProb(pBacEngine, pContext->PartitionProbs[i].Prob + j);
1028 }
1029 }
1030
1031 // MV probs
1032 Intel_HostvldVp9_UpdateMvProb(pBacEngine, pContext->MvJointProbs, VP9_MV_JOINTS - 1);
1033
1034 for (i = 0; i < VP9_MV_COMPONENTS; i++)
1035 {
1036 PINTEL_HOSTVLD_VP9_MV_PROB_SET pMvProbSet = pContext->MvProbSet + i;
1037
1038 if (INTEL_HOSTVLD_VP9_READ_BIT(VP9_NMV_UPDATE_PROB))
1039 {
1040 pMvProbSet->MvSignProbs = (UINT8)(INTEL_HOSTVLD_VP9_READ_BITS(7) << 1) | 1;
1041 }
1042
1043 Intel_HostvldVp9_UpdateMvProb(pBacEngine, pMvProbSet->MvClassProbs, VP9_MV_CLASSES - 1);
1044 Intel_HostvldVp9_UpdateMvProb(pBacEngine, pMvProbSet->MvClass0Probs, VP9_MV_CLASS0_SIZE - 1);
1045 Intel_HostvldVp9_UpdateMvProb(pBacEngine, pMvProbSet->MvBitsProbs, VP9_MV_OFFSET_BITS);
1046 }
1047
1048 for (i = 0; i < VP9_MV_COMPONENTS; i++)
1049 {
1050 PINTEL_HOSTVLD_VP9_MV_PROB_SET pMvProbSet = pContext->MvProbSet + i;
1051
1052 for (j = 0; j < VP9_MV_CLASS0_SIZE; ++j)
1053 {
1054 Intel_HostvldVp9_UpdateMvProb(pBacEngine, pMvProbSet->MvClass0FpProbs[j], 3);
1055 }
1056
1057 Intel_HostvldVp9_UpdateMvProb(pBacEngine, pMvProbSet->MvFpProbs, 3);
1058 }
1059
1060 if (pFrameInfo->bAllowHighPrecisionMv)
1061 {
1062 for (i = 0; i < VP9_MV_COMPONENTS; i++)
1063 {
1064 PINTEL_HOSTVLD_VP9_MV_PROB_SET pMvProbSet = pContext->MvProbSet + i;
1065
1066 if (INTEL_HOSTVLD_VP9_READ_BIT(VP9_NMV_UPDATE_PROB))
1067 {
1068 pMvProbSet->MvClass0HpProbs = (UINT8)(INTEL_HOSTVLD_VP9_READ_BITS(7) << 1) | 1;
1069 }
1070
1071 if (INTEL_HOSTVLD_VP9_READ_BIT(VP9_NMV_UPDATE_PROB))
1072 {
1073 pMvProbSet->MvHpProbs = (UINT8)(INTEL_HOSTVLD_VP9_READ_BITS(7) << 1) | 1;
1074 }
1075 }
1076 }
1077
1078 return eStatus;
1079 }
1080
Intel_HostvldVp9_ReadProbabilities(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pContext,PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo,PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine)1081 VAStatus Intel_HostvldVp9_ReadProbabilities(
1082 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pContext,
1083 PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo,
1084 PINTEL_HOSTVLD_VP9_BAC_ENGINE pBacEngine)
1085 {
1086 INT i, j, k, l, m, n;
1087 VAStatus eStatus = VA_STATUS_SUCCESS;
1088
1089 // Read probabilities
1090 if (pFrameInfo->TxMode == TX_MODE_SELECT)
1091 {
1092 // transform probabilities
1093 PINTEL_HOSTVLD_VP9_TX_PROB_TABLE_SET pTxProbs = &pContext->TxProbTableSet;
1094
1095 // 8x8
1096 for (i = 0; i < VP9_TX_SIZE_CONTEXTS; i++)
1097 {
1098 for (j = 0; j < TX_SIZES - 3; j++)
1099 {
1100 Intel_HostvldVp9_UpdateProb(pBacEngine, pTxProbs->Tx_8X8[i] + j);
1101 }
1102 }
1103 // 16x16
1104 for (i = 0; i < VP9_TX_SIZE_CONTEXTS; i++)
1105 {
1106 for (j = 0; j < TX_SIZES - 2; ++j)
1107 {
1108 Intel_HostvldVp9_UpdateProb(pBacEngine, pTxProbs->Tx_16X16[i] + j);
1109 }
1110 }
1111 // 32x32
1112 for (i = 0; i < VP9_TX_SIZE_CONTEXTS; i++)
1113 {
1114 for (j = 0; j < TX_SIZES - 1; ++j)
1115 {
1116 Intel_HostvldVp9_UpdateProb(pBacEngine, pTxProbs->Tx_32X32[i] + j);
1117 }
1118 }
1119 }
1120
1121 // Coefficient probabilities
1122 for (n = TX_4X4; n <= g_Vp9TxMode2MaxTxSize[pFrameInfo->TxMode]; n++)
1123 {
1124 if (INTEL_HOSTVLD_VP9_READ_ONE_BIT)
1125 {
1126 for (i = 0; i < INTEL_HOSTVLD_VP9_YUV_PLANE_NUMBER; i++)
1127 {
1128 for (j = 0; j < REF_TYPES; j++)
1129 {
1130 for (k = 0; k < VP9_COEF_BANDS; k++)
1131 {
1132 for (l = 0; l < VP9_PREV_COEF_CONTEXTS; l++)
1133 {
1134 if (k == 0 && l >= 3)
1135 {
1136 continue;
1137 }
1138
1139 for (m = 0; m < VP9_UNCONSTRAINED_NODES; m++)
1140 {
1141 Intel_HostvldVp9_UpdateProb(pBacEngine, &pContext->CoeffProbs[n][i][j][k][l][m]);
1142 }
1143 }
1144 }
1145 }
1146 }
1147 }
1148 }
1149
1150 // Skip Flag probabilities
1151 for (i = 0; i < VP9_MBSKIP_CONTEXTS; i++)
1152 {
1153 Intel_HostvldVp9_UpdateProb(pBacEngine, &pContext->MbSkipProbs[i]);
1154 }
1155
1156 if (!pFrameInfo->bIsIntraOnly)
1157 {
1158 Intel_HostvldVp9_ReadProbabilitiesInter(
1159 pContext, pFrameInfo, pBacEngine);
1160 }
1161
1162 return eStatus;
1163 }
1164
Intel_HostvldVp9_AdaptProbabilities(PINTEL_HOSTVLD_VP9_FRAME_STATE pFrameState)1165 VAStatus Intel_HostvldVp9_AdaptProbabilities(
1166 PINTEL_HOSTVLD_VP9_FRAME_STATE pFrameState)
1167 {
1168 PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo;
1169 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCurrContext, pPrevContext;
1170 PINTEL_HOSTVLD_VP9_COUNT pCount;
1171 VAStatus eStatus = VA_STATUS_SUCCESS;
1172
1173 pFrameInfo = &pFrameState->FrameInfo;
1174 pCurrContext = pFrameInfo->pContext;
1175 pPrevContext = &(pFrameState->pVp9HostVld->ContextTable[pFrameInfo->uiFrameContextIndex]);
1176 pCount = &pFrameState->pTileStateBase->Count;
1177
1178 if (!pFrameInfo->bErrorResilientMode && pFrameInfo->bFrameParallelDisabled)
1179 {
1180 Intel_HostvldVp9_AdaptCoeffProbs(
1181 pCurrContext, pPrevContext, pCount, pFrameInfo);
1182
1183 if (!pFrameInfo->bIsIntraOnly)
1184 {
1185 Intel_HostvldVp9_AdaptModeProbs(
1186 pCurrContext, pPrevContext, pCount, pFrameInfo);
1187 Intel_HostvldVp9_AdaptMvProbs(
1188 pCurrContext, pPrevContext, pCount, pFrameInfo);
1189 }
1190 }
1191
1192 return eStatus;
1193 }
1194
Intel_HostvldVp9_RefreshFrameContext(PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCtxTable,PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)1195 VAStatus Intel_HostvldVp9_RefreshFrameContext(
1196 PINTEL_HOSTVLD_VP9_FRAME_CONTEXT pCtxTable,
1197 PINTEL_HOSTVLD_VP9_FRAME_INFO pFrameInfo)
1198 {
1199 VAStatus eStatus = VA_STATUS_SUCCESS;
1200
1201
1202 if (pFrameInfo->pPicParams->PicFlags.fields.refresh_frame_context)
1203 {
1204 if (pFrameInfo->uiFrameContextIndex >= 4)
1205 {
1206 eStatus = VA_STATUS_ERROR_INVALID_PARAMETER;
1207 goto finish;
1208 }
1209 memcpy(
1210 pCtxTable + pFrameInfo->uiFrameContextIndex,
1211 pFrameInfo->pContext,
1212 sizeof(*pFrameInfo->pContext));
1213 }
1214
1215 finish:
1216 return eStatus;
1217 }
1218
1219