Coverage Report

Created: 2026-02-26 07:09

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libavc/decoder/svc/isvcd_iquant_itrans.c
Line
Count
Source
1
/******************************************************************************
2
 *
3
 * Copyright (C) 2022 The Android Open Source Project
4
 *
5
 * Licensed under the Apache License, Version 2.0 (the "License");
6
 * you may not use this file except in compliance with the License.
7
 * You may obtain a copy of the License at:
8
 *
9
 * http://www.apache.org/licenses/LICENSE-2.0
10
 *
11
 * Unless required by applicable law or agreed to in writing, software
12
 * distributed under the License is distributed on an "AS IS" BASIS,
13
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
 * See the License for the specific language governing permissions and
15
 * limitations under the License.
16
 *
17
 *****************************************************************************
18
 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19
 */
20
/**
21
*******************************************************************************
22
* @file
23
*  isvcd_iquant_itrans.c
24
*
25
* @brief
26
*  Contains definition of functions for h264 inverse quantization inverse
27
transformation and resd comp
28
*
29
* @author
30
*  Kishore
31
*
32
*  @par List of Functions:
33
*  - isvcd_iquant_itrans_4x4()
34
*  - isvcd_iquant_itrans_8x8()
35
*  - isvcd_iquant_itrans_4x4_dc()
36
*  - isvcd_iquant_itrans_8x8_dc()
37
*  - isvcd_iquant_itrans_chroma_4x4()
38
*  - isvcd_iquant_itrans_chroma_4x4_dc()
39
40
*
41
* @remarks
42
*
43
*******************************************************************************
44
*/
45
46
/*****************************************************************************/
47
/* File Includes                                                             */
48
/*****************************************************************************/
49
50
/* User include files */
51
#include "ih264_typedefs.h"
52
#include "ih264_defs.h"
53
#include "ih264_trans_macros.h"
54
#include "ih264_macros.h"
55
#include "ih264_platform_macros.h"
56
#include "ih264_trans_data.h"
57
#include "ih264_size_defs.h"
58
#include "ih264_structs.h"
59
#include "isvcd_iquant_itrans.h"
60
61
/*****************************************************************************/
62
/*                                                                           */
63
/*  Function Name : isvcd_iquant_itrans_4x4                                   */
64
/*                                                                           */
65
/*  Description   : this function computes the inverse quantized and         */
66
/*                   inverse transformed output                              */
67
/*                                                                           */
68
/*  Inputs        :                                                          */
69
/*  Globals       : none                                                     */
70
/*  Processing    :                                                          */
71
/*                                                                           */
72
/*  Outputs       : none                                                     */
73
/*  Returns       : none                                                     */
74
/*                                                                           */
75
/*  Issues        : none                                                     */
76
/*                                                                           */
77
/*  Revision History:                                                        */
78
/*                                                                           */
79
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
80
/*         25 11 2021   Kishore               creation                       */
81
/*                                                                           */
82
/*****************************************************************************/
83
void isvcd_iquant_itrans_4x4(WORD16 *pi2_src, WORD16 *pi2_out, WORD32 out_strd,
84
                             const UWORD16 *pu2_iscal_mat, const UWORD16 *pu2_weigh_mat,
85
                             UWORD32 u4_qp_div_6, WORD16 *pi2_tmp, WORD32 iq_start_idx,
86
                             WORD16 *pi2_dc_ld_addr)
87
69.3k
{
88
69.3k
    WORD16 *pi2_src_ptr = pi2_src;
89
69.3k
    WORD16 *pi2_tmp_ptr = pi2_tmp;
90
69.3k
    WORD16 *pi2_out_ptr = pi2_out;
91
69.3k
    WORD16 x0, x1, x2, x3, i;
92
69.3k
    WORD32 q0, q1, q2, q3;
93
69.3k
    WORD16 i_macro;
94
69.3k
    WORD16 rnd_fact = (u4_qp_div_6 < 4) ? 1 << (3 - u4_qp_div_6) : 0;
95
96
    /* inverse quant */
97
    /*horizontal inverse transform */
98
346k
    for(i = 0; i < SUB_BLK_WIDTH_4x4; i++)
99
277k
    {
100
277k
        q0 = pi2_src_ptr[0];
101
277k
        INV_QUANT(q0, pu2_iscal_mat[0], pu2_weigh_mat[0], u4_qp_div_6, rnd_fact, 4);
102
277k
        if(i == 0 && iq_start_idx == 1)
103
0
            q0 = pi2_dc_ld_addr[0];  // Restoring dc value for intra case
104
105
277k
        q2 = pi2_src_ptr[2];
106
277k
        INV_QUANT(q2, pu2_iscal_mat[2], pu2_weigh_mat[2], u4_qp_div_6, rnd_fact, 4);
107
108
277k
        x0 = q0 + q2;
109
277k
        x1 = q0 - q2;
110
111
277k
        q1 = pi2_src_ptr[1];
112
277k
        INV_QUANT(q1, pu2_iscal_mat[1], pu2_weigh_mat[1], u4_qp_div_6, rnd_fact, 4);
113
114
277k
        q3 = pi2_src_ptr[3];
115
277k
        INV_QUANT(q3, pu2_iscal_mat[3], pu2_weigh_mat[3], u4_qp_div_6, rnd_fact, 4);
116
117
277k
        x2 = (q1 >> 1) - q3;
118
277k
        x3 = q1 + (q3 >> 1);
119
120
277k
        pi2_tmp_ptr[0] = x0 + x3;
121
277k
        pi2_tmp_ptr[1] = x1 + x2;
122
277k
        pi2_tmp_ptr[2] = x1 - x2;
123
277k
        pi2_tmp_ptr[3] = x0 - x3;
124
125
277k
        pi2_src_ptr += SUB_BLK_WIDTH_4x4;
126
277k
        pi2_tmp_ptr += SUB_BLK_WIDTH_4x4;
127
277k
        pu2_iscal_mat += SUB_BLK_WIDTH_4x4;
128
277k
        pu2_weigh_mat += SUB_BLK_WIDTH_4x4;
129
277k
    }
130
131
    /* vertical inverse transform */
132
69.3k
    pi2_tmp_ptr = pi2_tmp;
133
346k
    for(i = 0; i < SUB_BLK_WIDTH_4x4; i++)
134
277k
    {
135
277k
        pi2_out = pi2_out_ptr;
136
137
277k
        x0 = (pi2_tmp_ptr[0] + pi2_tmp_ptr[8]);
138
277k
        x1 = (pi2_tmp_ptr[0] - pi2_tmp_ptr[8]);
139
277k
        x2 = (pi2_tmp_ptr[4] >> 1) - pi2_tmp_ptr[12];
140
277k
        x3 = pi2_tmp_ptr[4] + (pi2_tmp_ptr[12] >> 1);
141
142
        /* inverse prediction */
143
277k
        i_macro = x0 + x3;
144
277k
        *pi2_out = CLIP_RSD((i_macro + 32) >> 6);
145
277k
        pi2_out += out_strd;
146
147
277k
        i_macro = x1 + x2;
148
277k
        *pi2_out = CLIP_RSD((i_macro + 32) >> 6);
149
277k
        pi2_out += out_strd;
150
151
277k
        i_macro = x1 - x2;
152
277k
        *pi2_out = CLIP_RSD((i_macro + 32) >> 6);
153
277k
        pi2_out += out_strd;
154
155
277k
        i_macro = x0 - x3;
156
277k
        *pi2_out = CLIP_RSD((i_macro + 32) >> 6);
157
277k
        pi2_tmp_ptr++;
158
277k
        pi2_out_ptr++;
159
277k
    }
160
69.3k
}
161
162
/*****************************************************************************/
163
/*                                                                           */
164
/*  Function Name : isvcd_iquant_itrans_4x4_dc                                */
165
/*                                                                           */
166
/*  Description   : this function computes the inverse quantized and         */
167
/*                   inverse transformed output                              */
168
/*                                                                           */
169
/*  Inputs        :                                                          */
170
/*  Globals       : none                                                     */
171
/*  Processing    :                                                          */
172
/*                                                                           */
173
/*  Outputs       : none                                                     */
174
/*  Returns       : none                                                     */
175
/*                                                                           */
176
/*  Issues        : none                                                     */
177
/*                                                                           */
178
/*  Revision History:                                                        */
179
/*                                                                           */
180
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
181
/*         25 11 2021   Kishore               creation                       */
182
/*                                                                           */
183
/*****************************************************************************/
184
void isvcd_iquant_itrans_4x4_dc(WORD16 *pi2_src, WORD16 *pi2_out, WORD32 out_strd,
185
                                const UWORD16 *pu2_iscal_mat, const UWORD16 *pu2_weigh_mat,
186
                                UWORD32 u4_qp_div_6, WORD16 *pi2_tmp, WORD32 iq_start_idx,
187
                                WORD16 *pi2_dc_ld_addr)
188
4.29k
{
189
4.29k
    WORD16 *pi2_out_ptr = pi2_out;
190
4.29k
    WORD32 q0;
191
4.29k
    WORD16 i_macro, i;
192
4.29k
    WORD16 rnd_fact = (u4_qp_div_6 < 4) ? 1 << (3 - u4_qp_div_6) : 0;
193
4.29k
    UNUSED(pi2_tmp);
194
195
4.29k
    if(iq_start_idx == 0)
196
4.29k
    {
197
4.29k
        q0 = pi2_src[0];
198
4.29k
        INV_QUANT(q0, pu2_iscal_mat[0], pu2_weigh_mat[0], u4_qp_div_6, rnd_fact, 4);
199
4.29k
    }
200
0
    else
201
0
    {
202
0
        q0 = pi2_dc_ld_addr[0];  // Restoring dc value for intra case3
203
0
    }
204
4.29k
    i_macro = CLIP_RSD((q0 + 32) >> 6);
205
21.4k
    for(i = 0; i < SUB_BLK_WIDTH_4x4; i++)
206
17.1k
    {
207
17.1k
        pi2_out = pi2_out_ptr;
208
209
        /* inverse prediction */
210
17.1k
        *pi2_out = i_macro;
211
17.1k
        pi2_out += out_strd;
212
17.1k
        *pi2_out = i_macro;
213
17.1k
        pi2_out += out_strd;
214
17.1k
        *pi2_out = i_macro;
215
17.1k
        pi2_out += out_strd;
216
17.1k
        *pi2_out = i_macro;
217
17.1k
        pi2_out_ptr++;
218
17.1k
    }
219
4.29k
}
220
221
/*****************************************************************************/
222
/*                                                                           */
223
/*  Function Name : isvcd_iquant_itrans_chroma_4x4                            */
224
/*                                                                           */
225
/*  Description   : this function computes the inverse quantized and         */
226
/*                   inverse transformed output                              */
227
/*                                                                           */
228
/*  Inputs        :                                                          */
229
/*  Globals       : none                                                     */
230
/*  Processing    :                                                          */
231
/*                                                                           */
232
/*  Outputs       : none                                                     */
233
/*  Returns       : none                                                     */
234
/*                                                                           */
235
/*  Issues        : none                                                     */
236
/*                                                                           */
237
/*  Revision History:                                                        */
238
/*                                                                           */
239
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
240
/*         25 11 2021   Kishore               creation                       */
241
/*                                                                           */
242
/*****************************************************************************/
243
void isvcd_iquant_itrans_chroma_4x4(WORD16 *pi2_src, WORD16 *pi2_out, WORD32 out_strd,
244
                                    const UWORD16 *pu2_iscal_mat, const UWORD16 *pu2_weigh_mat,
245
                                    UWORD32 u4_qp_div_6, WORD16 *pi2_tmp, WORD16 *pi2_dc_src)
246
10.8k
{
247
10.8k
    WORD16 *pi2_src_ptr = pi2_src;
248
10.8k
    WORD16 *pi2_tmp_ptr = pi2_tmp;
249
10.8k
    WORD16 *pi2_out_ptr = pi2_out;
250
10.8k
    WORD16 x0, x1, x2, x3, i;
251
10.8k
    WORD32 q0, q1, q2, q3;
252
10.8k
    WORD16 i_macro;
253
10.8k
    WORD16 rnd_fact = (u4_qp_div_6 < 4) ? 1 << (3 - u4_qp_div_6) : 0;
254
255
    /* inverse quant */
256
    /*horizontal inverse transform */
257
54.3k
    for(i = 0; i < SUB_BLK_WIDTH_4x4; i++)
258
43.4k
    {
259
43.4k
        if(i == 0)
260
10.8k
        {
261
10.8k
            q0 = pi2_dc_src[0];
262
10.8k
        }
263
32.6k
        else
264
32.6k
        {
265
32.6k
            q0 = pi2_src_ptr[0];
266
32.6k
            INV_QUANT(q0, pu2_iscal_mat[0], pu2_weigh_mat[0], u4_qp_div_6, rnd_fact, 4);
267
32.6k
        }
268
269
43.4k
        q2 = pi2_src_ptr[2];
270
43.4k
        INV_QUANT(q2, pu2_iscal_mat[2], pu2_weigh_mat[2], u4_qp_div_6, rnd_fact, 4);
271
272
43.4k
        x0 = q0 + q2;
273
43.4k
        x1 = q0 - q2;
274
275
43.4k
        q1 = pi2_src_ptr[1];
276
43.4k
        INV_QUANT(q1, pu2_iscal_mat[1], pu2_weigh_mat[1], u4_qp_div_6, rnd_fact, 4);
277
278
43.4k
        q3 = pi2_src_ptr[3];
279
43.4k
        INV_QUANT(q3, pu2_iscal_mat[3], pu2_weigh_mat[3], u4_qp_div_6, rnd_fact, 4);
280
281
43.4k
        x2 = (q1 >> 1) - q3;
282
43.4k
        x3 = q1 + (q3 >> 1);
283
284
43.4k
        pi2_tmp_ptr[0] = x0 + x3;
285
43.4k
        pi2_tmp_ptr[1] = x1 + x2;
286
43.4k
        pi2_tmp_ptr[2] = x1 - x2;
287
43.4k
        pi2_tmp_ptr[3] = x0 - x3;
288
289
43.4k
        pi2_src_ptr += SUB_BLK_WIDTH_4x4;
290
43.4k
        pi2_tmp_ptr += SUB_BLK_WIDTH_4x4;
291
43.4k
        pu2_iscal_mat += SUB_BLK_WIDTH_4x4;
292
43.4k
        pu2_weigh_mat += SUB_BLK_WIDTH_4x4;
293
43.4k
    }
294
295
    /* vertical inverse transform */
296
10.8k
    pi2_tmp_ptr = pi2_tmp;
297
54.3k
    for(i = 0; i < SUB_BLK_WIDTH_4x4; i++)
298
43.4k
    {
299
43.4k
        pi2_out = pi2_out_ptr;
300
301
43.4k
        x0 = (pi2_tmp_ptr[0] + pi2_tmp_ptr[8]);
302
43.4k
        x1 = (pi2_tmp_ptr[0] - pi2_tmp_ptr[8]);
303
43.4k
        x2 = (pi2_tmp_ptr[4] >> 1) - pi2_tmp_ptr[12];
304
43.4k
        x3 = pi2_tmp_ptr[4] + (pi2_tmp_ptr[12] >> 1);
305
306
        /* inverse prediction */
307
43.4k
        i_macro = x0 + x3;
308
43.4k
        *pi2_out = CLIP_RSD((i_macro + 32) >> 6);
309
43.4k
        pi2_out += out_strd;
310
311
43.4k
        i_macro = x1 + x2;
312
43.4k
        *pi2_out = CLIP_RSD((i_macro + 32) >> 6);
313
43.4k
        pi2_out += out_strd;
314
315
43.4k
        i_macro = x1 - x2;
316
43.4k
        *pi2_out = CLIP_RSD((i_macro + 32) >> 6);
317
43.4k
        pi2_out += out_strd;
318
319
43.4k
        i_macro = x0 - x3;
320
43.4k
        *pi2_out = CLIP_RSD((i_macro + 32) >> 6);
321
43.4k
        pi2_tmp_ptr++;
322
43.4k
        pi2_out_ptr += 2;  // Interleaved store for output
323
43.4k
    }
324
10.8k
}
325
/*****************************************************************************/
326
/*                                                                           */
327
/*  Function Name : isvcd_iquant_itrans_chroma_4x4_dc                         */
328
/*                                                                           */
329
/*  Description   : this function computes the inverse quantized and         */
330
/*                   inverse transformed output                              */
331
/*                                                                           */
332
/*  Inputs        :                                                          */
333
/*  Globals       : none                                                     */
334
/*  Processing    :                                                          */
335
/*                                                                           */
336
/*  Outputs       : none                                                     */
337
/*  Returns       : none                                                     */
338
/*                                                                           */
339
/*  Issues        : none                                                     */
340
/*                                                                           */
341
/*  Revision History:                                                        */
342
/*                                                                           */
343
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
344
/*         25 11 2021   Kishore               creation                       */
345
/*                                                                           */
346
/*****************************************************************************/
347
348
void isvcd_iquant_itrans_chroma_4x4_dc(WORD16 *pi2_src, WORD16 *pi2_out, WORD32 out_strd,
349
                                       const UWORD16 *pu2_iscal_mat, const UWORD16 *pu2_weigh_mat,
350
                                       UWORD32 u4_qp_div_6, WORD16 *pi2_tmp, WORD16 *pi2_dc_src)
351
31.1k
{
352
31.1k
    WORD16 *pi2_out_ptr = pi2_out;
353
31.1k
    WORD32 q0;
354
31.1k
    WORD16 i_macro, i;
355
31.1k
    UNUSED(pi2_src);
356
31.1k
    UNUSED(pu2_iscal_mat);
357
31.1k
    UNUSED(pu2_weigh_mat);
358
31.1k
    UNUSED(u4_qp_div_6);
359
31.1k
    UNUSED(pi2_tmp);
360
361
31.1k
    q0 = pi2_dc_src[0];  // Restoring dc value for intra case3
362
31.1k
    i_macro = CLIP_RSD((q0 + 32) >> 6);
363
364
155k
    for(i = 0; i < SUB_BLK_WIDTH_4x4; i++)
365
124k
    {
366
124k
        pi2_out = pi2_out_ptr;
367
368
        /* inverse prediction */
369
124k
        *pi2_out = i_macro;
370
124k
        pi2_out += out_strd;
371
372
124k
        *pi2_out = i_macro;
373
124k
        pi2_out += out_strd;
374
375
124k
        *pi2_out = i_macro;
376
124k
        pi2_out += out_strd;
377
378
124k
        *pi2_out = i_macro;
379
380
124k
        pi2_out_ptr += 2;
381
124k
    }
382
31.1k
}
383
384
/**
385
*******************************************************************************
386
*
387
* @brief
388
*  This function performs inverse quant and Inverse transform type Ci4 for 8x8
389
*block
390
*
391
* @par Description:
392
*  Performs inverse transform Ci8 and adds the residue to get the
393
*  reconstructed block
394
*
395
* @param[in] pi2_src
396
*  Input 8x8coefficients
397
*
398
* @param[in] pu1_pred
399
*  Prediction 8x8 block
400
*
401
* @param[out] pu1_recon
402
*  Output 8x8 block
403
*
404
* @param[in] q_div
405
*  QP/6
406
*
407
* @param[in] q_rem
408
*  QP%6
409
*
410
* @param[in] q_lev
411
*  Quantizer level
412
*
413
* @param[in] src_strd
414
*  Input stride
415
*
416
* @param[in] pred_strd,
417
*  Prediction stride
418
*
419
* @param[in] out_strd
420
*  Output Stride
421
*
422
* @param[in] pi4_tmp
423
*  temporary buffer of size 1*16 we dont need a bigger blcok since we reuse
424
*  the tmp for each block
425
*
426
* @param[in] pu4_iquant_mat
427
*  Pointer to the inverse quantization matrix
428
*
429
* @returns  Void
430
*
431
* @remarks
432
*  None
433
*
434
*******************************************************************************
435
*/
436
void isvcd_iquant_itrans_8x8_dc(WORD16 *pi2_src, WORD16 *pi2_out, WORD32 out_strd,
437
                                const UWORD16 *pu2_iscale_mat, const UWORD16 *pu2_weigh_mat,
438
                                UWORD32 qp_div, WORD16 *pi2_tmp, WORD32 iq_start_idx,
439
                                WORD16 *pi2_dc_ld_addr)
440
2.41k
{
441
2.41k
    WORD16 *pi2_out_ptr = pi2_out;
442
2.41k
    WORD16 i, i_macro;
443
2.41k
    WORD32 q;
444
2.41k
    WORD32 rnd_fact = (qp_div < 6) ? (1 << (5 - qp_div)) : 0;
445
2.41k
    UNUSED(pi2_tmp);
446
2.41k
    UNUSED(iq_start_idx);
447
2.41k
    UNUSED(pi2_dc_ld_addr);
448
    /*************************************************************/
449
    /* Dequantization of coefficients. Will be replaced by SIMD  */
450
    /* operations on platform. Note : DC coeff is not scaled     */
451
    /*************************************************************/
452
2.41k
    q = pi2_src[0];
453
2.41k
    INV_QUANT(q, pu2_iscale_mat[0], pu2_weigh_mat[0], qp_div, rnd_fact, 6);
454
2.41k
    i_macro = CLIP_RSD((q + 32) >> 6);
455
    /* Perform Inverse transform */
456
    /*--------------------------------------------------------------------*/
457
    /* IDCT [ Horizontal transformation ]                                 */
458
    /*--------------------------------------------------------------------*/
459
    /*--------------------------------------------------------------------*/
460
    /* IDCT [ Vertical transformation] and Xij = (xij + 32)>>6            */
461
    /*                                                                    */
462
    /* Add the prediction and store it back to reconstructed frame buffer */
463
    /* [Prediction buffer itself in this case]                            */
464
    /*--------------------------------------------------------------------*/
465
21.6k
    for(i = 0; i < SUB_BLK_WIDTH_8x8; i++)
466
19.2k
    {
467
19.2k
        pi2_out = pi2_out_ptr;
468
469
19.2k
        *pi2_out = i_macro;
470
        /* Change uc_recBuffer to Point to next element in the same column*/
471
19.2k
        pi2_out += out_strd;
472
473
19.2k
        *pi2_out = i_macro;
474
19.2k
        pi2_out += out_strd;
475
476
19.2k
        *pi2_out = i_macro;
477
19.2k
        pi2_out += out_strd;
478
479
19.2k
        *pi2_out = i_macro;
480
19.2k
        pi2_out += out_strd;
481
482
19.2k
        *pi2_out = i_macro;
483
19.2k
        pi2_out += out_strd;
484
485
19.2k
        *pi2_out = i_macro;
486
19.2k
        pi2_out += out_strd;
487
488
19.2k
        *pi2_out = i_macro;
489
19.2k
        pi2_out += out_strd;
490
491
19.2k
        *pi2_out = i_macro;
492
493
19.2k
        pi2_out_ptr++;
494
19.2k
    }
495
2.41k
}
496
/*****************************************************************************/
497
/*                                                                           */
498
/*  Function Name : isvcd_iquant_itrans_8x8                                   */
499
/*                                                                           */
500
/*  Description   : this function computes the inverse quantized and         */
501
/*                   inverse transformed output                              */
502
/*                                                                           */
503
/*  Inputs        :                                                          */
504
/*  Globals       : none                                                     */
505
/*  Processing    :                                                          */
506
/*                                                                           */
507
/*  Outputs       : none                                                     */
508
/*  Returns       : none                                                     */
509
/*                                                                           */
510
/*  Issues        : none                                                     */
511
/*                                                                           */
512
/*  Revision History:                                                        */
513
/*                                                                           */
514
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
515
/*         25 11 2021   Kishore               creation                       */
516
/*                                                                           */
517
/*****************************************************************************/
518
519
void isvcd_iquant_itrans_8x8(WORD16 *pi2_src, WORD16 *pi2_out, WORD32 out_strd,
520
                             const UWORD16 *pu2_iscale_mat, const UWORD16 *pu2_weigh_mat,
521
                             UWORD32 qp_div, WORD16 *pi2_tmp, WORD32 iq_start_idx,
522
                             WORD16 *pi2_dc_ld_addr)
523
21.2k
{
524
21.2k
    WORD32 i;
525
21.2k
    WORD16 *pi2_tmp_ptr = pi2_tmp;
526
21.2k
    WORD16 *pi2_out_ptr = pi2_out;
527
21.2k
    WORD16 i_z0, i_z1, i_z2, i_z3, i_z4, i_z5, i_z6, i_z7;
528
21.2k
    WORD16 i_y0, i_y1, i_y2, i_y3, i_y4, i_y5, i_y6, i_y7;
529
21.2k
    WORD32 q;
530
21.2k
    WORD32 rnd_fact = (qp_div < 6) ? (1 << (5 - qp_div)) : 0;
531
21.2k
    UNUSED(iq_start_idx);
532
21.2k
    UNUSED(pi2_dc_ld_addr);
533
    /*************************************************************/
534
    /* De quantization of coefficients. Will be replaced by SIMD */
535
    /* operations on platform. Note : DC coeff is not scaled     */
536
    /*************************************************************/
537
1.38M
    for(i = 0; i < (SUB_BLK_WIDTH_8x8 * SUB_BLK_WIDTH_8x8); i++)
538
1.36M
    {
539
1.36M
        q = pi2_src[i];
540
1.36M
        INV_QUANT(q, pu2_iscale_mat[i], pu2_weigh_mat[i], qp_div, rnd_fact, 6);
541
1.36M
        pi2_tmp_ptr[i] = q;
542
1.36M
    }
543
    /* Perform Inverse transform */
544
    /*--------------------------------------------------------------------*/
545
    /* IDCT [ Horizontal transformation ]                                 */
546
    /*--------------------------------------------------------------------*/
547
191k
    for(i = 0; i < SUB_BLK_WIDTH_8x8; i++)
548
170k
    {
549
        /*------------------------------------------------------------------*/
550
        /* y0 = w0 + w4                                                     */
551
        /* y1 = -w3 + w5 - w7 - (w7 >> 1)                                   */
552
        /* y2 = w0 - w4                                                     */
553
        /* y3 = w1 + w7 - w3 - (w3 >> 1)                                    */
554
        /* y4 = (w2 >> 1) - w6                                              */
555
        /* y5 = -w1 + w7 + w5 + (w5 >> 1)                                   */
556
        /* y6 = w2 + (w6 >> 1)                                              */
557
        /* y7 = w3 + w5 + w1 + (w1 >> 1)                                    */
558
        /*------------------------------------------------------------------*/
559
170k
        i_y0 = (pi2_tmp_ptr[0] + pi2_tmp_ptr[4]);
560
561
170k
        i_y1 =
562
170k
            ((WORD32) (-pi2_tmp_ptr[3]) + pi2_tmp_ptr[5] - pi2_tmp_ptr[7] - (pi2_tmp_ptr[7] >> 1));
563
564
170k
        i_y2 = (pi2_tmp_ptr[0] - pi2_tmp_ptr[4]);
565
566
170k
        i_y3 = ((WORD32) pi2_tmp_ptr[1] + pi2_tmp_ptr[7] - pi2_tmp_ptr[3] - (pi2_tmp_ptr[3] >> 1));
567
568
170k
        i_y4 = ((pi2_tmp_ptr[2] >> 1) - pi2_tmp_ptr[6]);
569
570
170k
        i_y5 =
571
170k
            ((WORD32) (-pi2_tmp_ptr[1]) + pi2_tmp_ptr[7] + pi2_tmp_ptr[5] + (pi2_tmp_ptr[5] >> 1));
572
573
170k
        i_y6 = (pi2_tmp_ptr[2] + (pi2_tmp_ptr[6] >> 1));
574
575
170k
        i_y7 = ((WORD32) pi2_tmp_ptr[3] + pi2_tmp_ptr[5] + pi2_tmp_ptr[1] + (pi2_tmp_ptr[1] >> 1));
576
577
        /*------------------------------------------------------------------*/
578
        /* z0 = y0 + y6                                                     */
579
        /* z1 = y1 + (y7 >> 2)                                              */
580
        /* z2 = y2 + y4                                                     */
581
        /* z3 = y3 + (y5 >> 2)                                              */
582
        /* z4 = y2 - y4                                                     */
583
        /* z5 = (y3 >> 2) - y5                                              */
584
        /* z6 = y0 - y6                                                     */
585
        /* z7 = y7 - (y1 >> 2)                                              */
586
        /*------------------------------------------------------------------*/
587
170k
        i_z0 = i_y0 + i_y6;
588
170k
        i_z1 = i_y1 + (i_y7 >> 2);
589
170k
        i_z2 = i_y2 + i_y4;
590
170k
        i_z3 = i_y3 + (i_y5 >> 2);
591
170k
        i_z4 = i_y2 - i_y4;
592
170k
        i_z5 = (i_y3 >> 2) - i_y5;
593
170k
        i_z6 = i_y0 - i_y6;
594
170k
        i_z7 = i_y7 - (i_y1 >> 2);
595
596
        /*------------------------------------------------------------------*/
597
        /* x0 = z0 + z7                                                     */
598
        /* x1 = z2 + z5                                                     */
599
        /* x2 = z4 + z3                                                     */
600
        /* x3 = z6 + z1                                                     */
601
        /* x4 = z6 - z1                                                     */
602
        /* x5 = z4 - z3                                                     */
603
        /* x6 = z2 - z5                                                     */
604
        /* x7 = z0 - z7                                                     */
605
        /*------------------------------------------------------------------*/
606
170k
        pi2_tmp_ptr[0] = i_z0 + i_z7;
607
170k
        pi2_tmp_ptr[1] = i_z2 + i_z5;
608
170k
        pi2_tmp_ptr[2] = i_z4 + i_z3;
609
170k
        pi2_tmp_ptr[3] = i_z6 + i_z1;
610
170k
        pi2_tmp_ptr[4] = i_z6 - i_z1;
611
170k
        pi2_tmp_ptr[5] = i_z4 - i_z3;
612
170k
        pi2_tmp_ptr[6] = i_z2 - i_z5;
613
170k
        pi2_tmp_ptr[7] = i_z0 - i_z7;
614
615
        /* move to the next row */
616
        // pi2_src_ptr += SUB_BLK_WIDTH_8x8;
617
170k
        pi2_tmp_ptr += SUB_BLK_WIDTH_8x8;
618
170k
    }
619
    /*--------------------------------------------------------------------*/
620
    /* IDCT [ Vertical transformation] and Xij = (xij + 32)>>6            */
621
    /*                                                                    */
622
    /* Add the prediction and store it back to reconstructed frame buffer */
623
    /* [Prediction buffer itself in this case]                            */
624
    /*--------------------------------------------------------------------*/
625
626
21.2k
    pi2_tmp_ptr = pi2_tmp;
627
191k
    for(i = 0; i < SUB_BLK_WIDTH_8x8; i++)
628
170k
    {
629
170k
        pi2_out = pi2_out_ptr;
630
        /*------------------------------------------------------------------*/
631
        /* y0j = w0j + w4j                                                  */
632
        /* y1j = -w3j + w5j -w7j -(w7j >> 1)                                */
633
        /* y2j = w0j -w4j                                                   */
634
        /* y3j = w1j + w7j -w3j -(w3j >> 1)                                 */
635
        /* y4j = ( w2j >> 1 ) -w6j                                          */
636
        /* y5j = -w1j + w7j + w5j + (w5j >> 1)                              */
637
        /* y6j = w2j + ( w6j >> 1 )                                         */
638
        /* y7j = w3j + w5j + w1j + (w1j >> 1)                               */
639
        /*------------------------------------------------------------------*/
640
170k
        i_y0 = pi2_tmp_ptr[0] + pi2_tmp_ptr[32];
641
642
170k
        i_y1 = (WORD32) (-pi2_tmp_ptr[24]) + pi2_tmp_ptr[40] - pi2_tmp_ptr[56] -
643
170k
               (pi2_tmp_ptr[56] >> 1);
644
645
170k
        i_y2 = pi2_tmp_ptr[0] - pi2_tmp_ptr[32];
646
647
170k
        i_y3 = (WORD32) pi2_tmp_ptr[8] + pi2_tmp_ptr[56] - pi2_tmp_ptr[24] - (pi2_tmp_ptr[24] >> 1);
648
649
170k
        i_y4 = (pi2_tmp_ptr[16] >> 1) - pi2_tmp_ptr[48];
650
651
170k
        i_y5 =
652
170k
            (WORD32) (-pi2_tmp_ptr[8]) + pi2_tmp_ptr[56] + pi2_tmp_ptr[40] + (pi2_tmp_ptr[40] >> 1);
653
654
170k
        i_y6 = pi2_tmp_ptr[16] + (pi2_tmp_ptr[48] >> 1);
655
656
170k
        i_y7 = (WORD32) pi2_tmp_ptr[24] + pi2_tmp_ptr[40] + pi2_tmp_ptr[8] + (pi2_tmp_ptr[8] >> 1);
657
658
        /*------------------------------------------------------------------*/
659
        /* z0j = y0j + y6j                                                  */
660
        /* z1j = y1j + (y7j >> 2)                                           */
661
        /* z2j = y2j + y4j                                                  */
662
        /* z3j = y3j + (y5j >> 2)                                           */
663
        /* z4j = y2j -y4j                                                   */
664
        /* z5j = (y3j >> 2) -y5j                                            */
665
        /* z6j = y0j -y6j                                                   */
666
        /* z7j = y7j -(y1j >> 2)                                            */
667
        /*------------------------------------------------------------------*/
668
170k
        i_z0 = i_y0 + i_y6;
669
170k
        i_z1 = i_y1 + (i_y7 >> 2);
670
170k
        i_z2 = i_y2 + i_y4;
671
170k
        i_z3 = i_y3 + (i_y5 >> 2);
672
170k
        i_z4 = i_y2 - i_y4;
673
170k
        i_z5 = (i_y3 >> 2) - i_y5;
674
170k
        i_z6 = i_y0 - i_y6;
675
170k
        i_z7 = i_y7 - (i_y1 >> 2);
676
677
        /*------------------------------------------------------------------*/
678
        /* x0j = z0j + z7j                                                  */
679
        /* x1j = z2j + z5j                                                  */
680
        /* x2j = z4j + z3j                                                  */
681
        /* x3j = z6j + z1j                                                  */
682
        /* x4j = z6j -z1j                                                   */
683
        /* x5j = z4j -z3j                                                   */
684
        /* x6j = z2j -z5j                                                   */
685
        /* x7j = z0j -z7j                                                   */
686
        /*------------------------------------------------------------------*/
687
170k
        *pi2_out = CLIP_RSD((i_z0 + i_z7 + 32) >> 6);
688
        /* Change uc_recBuffer to Point to next element in the same column*/
689
170k
        pi2_out += out_strd;
690
691
170k
        *pi2_out = CLIP_RSD((i_z2 + i_z5 + 32) >> 6);
692
170k
        pi2_out += out_strd;
693
694
170k
        *pi2_out = CLIP_RSD((i_z4 + i_z3 + 32) >> 6);
695
170k
        pi2_out += out_strd;
696
697
170k
        *pi2_out = CLIP_RSD((i_z6 + i_z1 + 32) >> 6);
698
170k
        pi2_out += out_strd;
699
700
170k
        *pi2_out = CLIP_RSD((i_z6 - i_z1 + 32) >> 6);
701
170k
        pi2_out += out_strd;
702
703
170k
        *pi2_out = CLIP_RSD((i_z4 - i_z3 + 32) >> 6);
704
170k
        pi2_out += out_strd;
705
706
170k
        *pi2_out = CLIP_RSD((i_z2 - i_z5 + 32) >> 6);
707
170k
        pi2_out += out_strd;
708
709
170k
        *pi2_out = CLIP_RSD((i_z0 - i_z7 + 32) >> 6);
710
711
170k
        pi2_tmp_ptr++;
712
170k
        pi2_out_ptr++;
713
170k
    }
714
21.2k
}