1/******************************************************************************
2*
3* Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore
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/**
19 *******************************************************************************
20 * @file
21 *  ihevc_itrans_recon.c
22 *
23 * @brief
24 *  Contains function definitions for inverse transform  and reconstruction
25 *
26 *
27 * @author
28 *  100470
29 *
30 * @par List of Functions:
31 *  - ihevc_itrans_recon_4x4_ttype1()
32 *  - ihevc_itrans_recon_4x4()
33 *
34 * @remarks
35 *  None
36 *
37 *******************************************************************************
38 */
39#include <stdio.h>
40#include <string.h>
41#include "ihevc_typedefs.h"
42#include "ihevc_macros.h"
43#include "ihevc_platform_macros.h"
44#include "ihevc_defs.h"
45#include "ihevc_trans_tables.h"
46#include "ihevc_itrans_recon.h"
47#include "ihevc_func_selector.h"
48#include "ihevc_trans_macros.h"
49
50/* All the functions here are replicated from ihevc_itrans.c and modified to */
51/* include reconstruction */
52
53/**
54 *******************************************************************************
55 *
56 * @brief
57 *  This function performs Inverse transform type 1 (DST)  and reconstruction
58 * for 4x4 input block
59 *
60 * @par Description:
61 *  Performs inverse transform and adds the prediction  data and clips output
62 * to 8 bit
63 *
64 * @param[in] pi2_src
65 *  Input 4x4 coefficients
66 *
67 * @param[in] pi2_tmp
68 *  Temporary 4x4 buffer for storing inverse
69 *
70 *  transform
71 *  1st stage output
72 *
73 * @param[in] pu1_pred
74 *  Prediction 4x4 block
75 *
76 * @param[out] pu1_dst
77 *  Output 4x4 block
78 *
79 * @param[in] src_strd
80 *  Input stride
81 *
82 * @param[in] pred_strd
83 *  Prediction stride
84 *
85 * @param[in] dst_strd
86 *  Output Stride
87 *
88 * @param[in] zero_cols
89 *  Zero columns in pi2_src
90 *
91 * @returns  Void
92 *
93 * @remarks
94 *  None
95 *
96 *******************************************************************************
97 */
98
99void ihevc_itrans_recon_4x4_ttype1(WORD16 *pi2_src,
100                                   WORD16 *pi2_tmp,
101                                   UWORD8 *pu1_pred,
102                                   UWORD8 *pu1_dst,
103                                   WORD32 src_strd,
104                                   WORD32 pred_strd,
105                                   WORD32 dst_strd,
106                                   WORD32 zero_cols,
107                                   WORD32 zero_rows)
108{
109    WORD32 i, c[4];
110    WORD32 add;
111    WORD32 shift;
112    WORD16 *pi2_tmp_orig;
113    WORD32 trans_size;
114    UNUSED(zero_rows);
115    trans_size = TRANS_SIZE_4;
116
117    pi2_tmp_orig = pi2_tmp;
118
119    /* Inverse Transform 1st stage */
120    shift = IT_SHIFT_STAGE_1;
121    add = 1 << (shift - 1);
122
123    for(i = 0; i < trans_size; i++)
124    {
125        /* Checking for Zero Cols */
126        if((zero_cols & 1) == 1)
127        {
128            memset(pi2_tmp, 0, trans_size * sizeof(WORD16));
129        }
130        else
131        {
132            // Intermediate Variables
133            c[0] = pi2_src[0] + pi2_src[2 * src_strd];
134            c[1] = pi2_src[2 * src_strd] + pi2_src[3 * src_strd];
135            c[2] = pi2_src[0] - pi2_src[3 * src_strd];
136            c[3] = 74 * pi2_src[src_strd];
137
138            pi2_tmp[0] =
139                            CLIP_S16((29 * c[0] + 55 * c[1] + c[3] + add) >> shift);
140            pi2_tmp[1] =
141                            CLIP_S16((55 * c[2] - 29 * c[1] + c[3] + add) >> shift);
142            pi2_tmp[2] =
143                            CLIP_S16((74 * (pi2_src[0] - pi2_src[2 * src_strd] + pi2_src[3 * src_strd]) + add) >> shift);
144            pi2_tmp[3] =
145                            CLIP_S16((55 * c[0] + 29 * c[2] - c[3] + add) >> shift);
146        }
147        pi2_src++;
148        pi2_tmp += trans_size;
149        zero_cols = zero_cols >> 1;
150    }
151
152    pi2_tmp = pi2_tmp_orig;
153
154    /* Inverse Transform 2nd stage */
155    shift = IT_SHIFT_STAGE_2;
156    add = 1 << (shift - 1);
157
158    for(i = 0; i < trans_size; i++)
159    {
160        WORD32 itrans_out;
161        // Intermediate Variables
162        c[0] = pi2_tmp[0] + pi2_tmp[2 * trans_size];
163        c[1] = pi2_tmp[2 * trans_size] + pi2_tmp[3 * trans_size];
164        c[2] = pi2_tmp[0] - pi2_tmp[3 * trans_size];
165        c[3] = 74 * pi2_tmp[trans_size];
166
167        itrans_out =
168                        CLIP_S16((29 * c[0] + 55 * c[1] + c[3] + add) >> shift);
169        pu1_dst[0] = CLIP_U8((itrans_out + pu1_pred[0]));
170        itrans_out =
171                        CLIP_S16((55 * c[2] - 29 * c[1] + c[3] + add) >> shift);
172        pu1_dst[1] = CLIP_U8((itrans_out + pu1_pred[1]));
173        itrans_out =
174                        CLIP_S16((74 * (pi2_tmp[0] - pi2_tmp[2 * trans_size] + pi2_tmp[3 * trans_size]) + add) >> shift);
175        pu1_dst[2] = CLIP_U8((itrans_out + pu1_pred[2]));
176        itrans_out =
177                        CLIP_S16((55 * c[0] + 29 * c[2] - c[3] + add) >> shift);
178        pu1_dst[3] = CLIP_U8((itrans_out + pu1_pred[3]));
179        pi2_tmp++;
180        pu1_pred += pred_strd;
181        pu1_dst += dst_strd;
182    }
183}
184
185/**
186 *******************************************************************************
187 *
188 * @brief
189 *  This function performs Inverse transform  and reconstruction for 4x4
190 * input block
191 *
192 * @par Description:
193 *  Performs inverse transform and adds the prediction  data and clips output
194 * to 8 bit
195 *
196 * @param[in] pi2_src
197 *  Input 4x4 coefficients
198 *
199 * @param[in] pi2_tmp
200 *  Temporary 4x4 buffer for storing inverse
201 *
202 *  transform
203 *  1st stage output
204 *
205 * @param[in] pu1_pred
206 *  Prediction 4x4 block
207 *
208 * @param[out] pu1_dst
209 *  Output 4x4 block
210 *
211 * @param[in] src_strd
212 *  Input stride
213 *
214 * @param[in] pred_strd
215 *  Prediction stride
216 *
217 * @param[in] dst_strd
218 *  Output Stride
219 *
220 * @param[in] shift
221 *  Output shift
222 *
223 * @param[in] zero_cols
224 *  Zero columns in pi2_src
225 *
226 * @returns  Void
227 *
228 * @remarks
229 *  None
230 *
231 *******************************************************************************
232 */
233
234void ihevc_itrans_recon_4x4(WORD16 *pi2_src,
235                            WORD16 *pi2_tmp,
236                            UWORD8 *pu1_pred,
237                            UWORD8 *pu1_dst,
238                            WORD32 src_strd,
239                            WORD32 pred_strd,
240                            WORD32 dst_strd,
241                            WORD32 zero_cols,
242                            WORD32 zero_rows)
243
244{
245    WORD32 j;
246    WORD32 e[2], o[2];
247    WORD32 add;
248    WORD32 shift;
249    WORD16 *pi2_tmp_orig;
250    WORD32 trans_size;
251    UNUSED(zero_rows);
252    trans_size = TRANS_SIZE_4;
253
254    pi2_tmp_orig = pi2_tmp;
255
256    /* Inverse Transform 1st stage */
257    shift = IT_SHIFT_STAGE_1;
258    add = 1 << (shift - 1);
259
260    for(j = 0; j < trans_size; j++)
261    {
262        /* Checking for Zero Cols */
263        if((zero_cols & 1) == 1)
264        {
265            memset(pi2_tmp, 0, trans_size * sizeof(WORD16));
266        }
267        else
268        {
269
270            /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
271            o[0] = g_ai2_ihevc_trans_4[1][0] * pi2_src[src_strd]
272                            + g_ai2_ihevc_trans_4[3][0] * pi2_src[3 * src_strd];
273            o[1] = g_ai2_ihevc_trans_4[1][1] * pi2_src[src_strd]
274                            + g_ai2_ihevc_trans_4[3][1] * pi2_src[3 * src_strd];
275            e[0] = g_ai2_ihevc_trans_4[0][0] * pi2_src[0]
276                            + g_ai2_ihevc_trans_4[2][0] * pi2_src[2 * src_strd];
277            e[1] = g_ai2_ihevc_trans_4[0][1] * pi2_src[0]
278                            + g_ai2_ihevc_trans_4[2][1] * pi2_src[2 * src_strd];
279
280            pi2_tmp[0] =
281                            CLIP_S16(((e[0] + o[0] + add) >> shift));
282            pi2_tmp[1] =
283                            CLIP_S16(((e[1] + o[1] + add) >> shift));
284            pi2_tmp[2] =
285                            CLIP_S16(((e[1] - o[1] + add) >> shift));
286            pi2_tmp[3] =
287                            CLIP_S16(((e[0] - o[0] + add) >> shift));
288
289        }
290        pi2_src++;
291        pi2_tmp += trans_size;
292        zero_cols = zero_cols >> 1;
293    }
294
295    pi2_tmp = pi2_tmp_orig;
296
297    /* Inverse Transform 2nd stage */
298    shift = IT_SHIFT_STAGE_2;
299    add = 1 << (shift - 1);
300
301    for(j = 0; j < trans_size; j++)
302    {
303        WORD32 itrans_out;
304        /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
305        o[0] = g_ai2_ihevc_trans_4[1][0] * pi2_tmp[trans_size]
306                        + g_ai2_ihevc_trans_4[3][0] * pi2_tmp[3 * trans_size];
307        o[1] = g_ai2_ihevc_trans_4[1][1] * pi2_tmp[trans_size]
308                        + g_ai2_ihevc_trans_4[3][1] * pi2_tmp[3 * trans_size];
309        e[0] = g_ai2_ihevc_trans_4[0][0] * pi2_tmp[0]
310                        + g_ai2_ihevc_trans_4[2][0] * pi2_tmp[2 * trans_size];
311        e[1] = g_ai2_ihevc_trans_4[0][1] * pi2_tmp[0]
312                        + g_ai2_ihevc_trans_4[2][1] * pi2_tmp[2 * trans_size];
313
314        itrans_out =
315                        CLIP_S16(((e[0] + o[0] + add) >> shift));
316        pu1_dst[0] = CLIP_U8((itrans_out + pu1_pred[0]));
317        itrans_out =
318                        CLIP_S16(((e[1] + o[1] + add) >> shift));
319        pu1_dst[1] = CLIP_U8((itrans_out + pu1_pred[1]));
320        itrans_out =
321                        CLIP_S16(((e[1] - o[1] + add) >> shift));
322        pu1_dst[2] = CLIP_U8((itrans_out + pu1_pred[2]));
323        itrans_out =
324                        CLIP_S16(((e[0] - o[0] + add) >> shift));
325        pu1_dst[3] = CLIP_U8((itrans_out + pu1_pred[3]));
326
327        pi2_tmp++;
328        pu1_pred += pred_strd;
329        pu1_dst += dst_strd;
330
331    }
332}
333
334