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_recon.c
22 *
23 * @brief
24 *  Functions definitions reconstruction
25 *
26 * @author
27 *  Ittiam
28 *
29 * @par List of Functions:
30 *  - ihevc_recon_4x4_ttype1()
31 *  - ihevc_recon_4x4()
32 *  - ihevc_recon_8x8()
33 *  - ihevc_recon_16x16()
34 *  - ihevc_recon_32x32()
35 *
36 * @remarks
37 *  None
38 *
39 *******************************************************************************
40 */
41#include <stdio.h>
42#include <string.h>
43#include "ihevc_typedefs.h"
44#include "ihevc_macros.h"
45#include "ihevc_platform_macros.h"
46#include "ihevc_defs.h"
47#include "ihevc_trans_tables.h"
48#include "ihevc_recon.h"
49#include "ihevc_func_selector.h"
50#include "ihevc_trans_macros.h"
51
52/* All the functions here are replicated from ihevc.c and modified to */
53/* include reconstruction */
54
55/**
56 *******************************************************************************
57 *
58 * @brief
59 *  This function performs reconstruction for  4x4 input block
60 *
61 * @par Description:
62 *  Performs reconstruction of 4x4 input block by adding  adding prediction
63 * data to input and clipping it to 8 bit
64 *
65 * @param[in] pi2_src
66 *  Input 4x4 coefficients
67 *
68 * @param[in] pu1_pred
69 *  Prediction 4x4 block
70 *
71 * @param[out] pu1_dst
72 *  Output 4x4 block
73 *
74 * @param[in] src_strd
75 *  Input stride
76 *
77 * @param[in] pred_strd
78 *  Prediction stride
79 *
80 * @param[in] dst_strd
81 *  Output Stride
82 *
83 * @param[in] zero_cols
84 *  Zero columns in pi2_tmp
85 *
86 * @returns  Void
87 *
88 * @remarks
89 *  None
90 *
91 *******************************************************************************
92 */
93
94void ihevc_recon_4x4_ttype1(WORD16 *pi2_src,
95                            UWORD8 *pu1_pred,
96                            UWORD8 *pu1_dst,
97                            WORD32 src_strd,
98                            WORD32 pred_strd,
99                            WORD32 dst_strd,
100                            WORD32 zero_cols)
101{
102    WORD32 i, j;
103    WORD32 trans_size;
104
105    trans_size = TRANS_SIZE_4;
106
107    /* Reconstruction */
108
109    for(i = 0; i < trans_size; i++)
110    {
111        /* Checking for Zero Cols */
112        if((zero_cols & 1) == 1)
113        {
114            for(j = 0; j < trans_size; j++)
115            {
116                pu1_dst[j * dst_strd] = pu1_pred[j * pred_strd];
117            }
118        }
119        else
120        {
121            for(j = 0; j < trans_size; j++)
122            {
123                pu1_dst[j * dst_strd] =
124                                CLIP_U8(pi2_src[j * src_strd] + pu1_pred[j * pred_strd]);
125            }
126        }
127        pi2_src++;
128        pu1_dst++;
129        pu1_pred++;
130        zero_cols = zero_cols >> 1;
131    }
132}
133
134/**
135 *******************************************************************************
136 *
137 * @brief
138 *  This function performs reconstruction for  4x4 input block
139 *
140 * @par Description:
141 *  Performs reconstruction of 4x4 input block by adding  adding prediction
142 * data to input and clipping it to 8 bit
143 *
144 * @param[in] pi2_src
145 *  Input 4x4 coefficients
146 *
147 * @param[in] pu1_pred
148 *  Prediction 4x4 block
149 *
150 * @param[out] pu1_dst
151 *  Output 4x4 block
152 *
153 * @param[in] src_strd
154 *  Input stride
155 *
156 * @param[in] pred_strd
157 *  Prediction stride
158 *
159 * @param[in] dst_strd
160 *  Output Stride
161 *
162 * @param[in] shift
163 *  Output shift
164 *
165 * @param[in] zero_cols
166 *  Zero columns in pi2_tmp
167 *
168 * @returns  Void
169 *
170 * @remarks
171 *  None
172 *
173 *******************************************************************************
174 */
175
176void ihevc_recon_4x4(WORD16 *pi2_src,
177                     UWORD8 *pu1_pred,
178                     UWORD8 *pu1_dst,
179                     WORD32 src_strd,
180                     WORD32 pred_strd,
181                     WORD32 dst_strd,
182                     WORD32 zero_cols)
183{
184    WORD32 i, j;
185    WORD32 trans_size;
186
187    trans_size = TRANS_SIZE_4;
188
189    /* Reconstruction */
190
191    for(i = 0; i < trans_size; i++)
192    {
193        /* Checking for Zero Cols */
194        if((zero_cols & 1) == 1)
195        {
196            for(j = 0; j < trans_size; j++)
197            {
198                pu1_dst[j * dst_strd] = pu1_pred[j * pred_strd];
199            }
200        }
201        else
202        {
203            for(j = 0; j < trans_size; j++)
204            {
205                pu1_dst[j * dst_strd] =
206                                CLIP_U8(pi2_src[j * src_strd] + pu1_pred[j * pred_strd]);
207            }
208        }
209        pi2_src++;
210        pu1_dst++;
211        pu1_pred++;
212        zero_cols = zero_cols >> 1;
213    }
214}
215
216/**
217 *******************************************************************************
218 *
219 * @brief
220 *  This function performs reconstruction for  8x8 input block
221 *
222 * @par Description:
223 *  Performs reconstruction of 8x8 input block by adding  adding prediction
224 * data to input and clipping it to 8 bit
225 *
226 * @param[in] pi2_src
227 *  Input 8x8 coefficients
228 *
229 * @param[in] pu1_pred
230 *  Prediction 8x8 block
231 *
232 * @param[out] pu1_dst
233 *  Output 8x8 block
234 *
235 * @param[in] src_strd
236 *  Input stride
237 *
238 * @param[in] pred_strd
239 *  Prediction stride
240 *
241 * @param[in] dst_strd
242 *  Output Stride
243 *
244 * @param[in] shift
245 *  Output shift
246 *
247 * @param[in] zero_cols
248 *  Zero columns in pi2_tmp
249 *
250 * @returns  Void
251 *
252 * @remarks
253 *  None
254 *
255 *******************************************************************************
256 */
257
258void ihevc_recon_8x8(WORD16 *pi2_src,
259                     UWORD8 *pu1_pred,
260                     UWORD8 *pu1_dst,
261                     WORD32 src_strd,
262                     WORD32 pred_strd,
263                     WORD32 dst_strd,
264                     WORD32 zero_cols)
265{
266    WORD32 i, j;
267    WORD32 trans_size;
268
269    trans_size = TRANS_SIZE_8;
270
271    /* Reconstruction */
272
273    for(i = 0; i < trans_size; i++)
274    {
275        /* Checking for Zero Cols */
276        if((zero_cols & 1) == 1)
277        {
278            for(j = 0; j < trans_size; j++)
279            {
280                pu1_dst[j * dst_strd] = pu1_pred[j * pred_strd];
281            }
282        }
283        else
284        {
285            for(j = 0; j < trans_size; j++)
286            {
287                pu1_dst[j * dst_strd] =
288                                CLIP_U8(pi2_src[j * src_strd] + pu1_pred[j * pred_strd]);
289            }
290        }
291        pi2_src++;
292        pu1_dst++;
293        pu1_pred++;
294        zero_cols = zero_cols >> 1;
295    }
296}
297
298/**
299 *******************************************************************************
300 *
301 * @brief
302 *  This function performs reconstruction for  16x16 input block
303 *
304 * @par Description:
305 *  Performs reconstruction of 16x16 input block by adding  adding prediction
306 * data to input and clipping it to 8 bit
307 *
308 * @param[in] pi2_src
309 *  Input 16x16 coefficients
310 *
311 * @param[in] pu1_pred
312 *  Prediction 16x16 block
313 *
314 * @param[out] pu1_dst
315 *  Output 16x16 block
316 *
317 * @param[in] src_strd
318 *  Input stride
319 *
320 * @param[in] pred_strd
321 *  Prediction stride
322 *
323 * @param[in] dst_strd
324 *  Output Stride
325 *
326 * @param[in] shift
327 *  Output shift
328 *
329 * @param[in] zero_cols
330 *  Zero columns in pi2_tmp
331 *
332 * @returns  Void
333 *
334 * @remarks
335 *  None
336 *
337 *******************************************************************************
338 */
339
340void ihevc_recon_16x16(WORD16 *pi2_src,
341                       UWORD8 *pu1_pred,
342                       UWORD8 *pu1_dst,
343                       WORD32 src_strd,
344                       WORD32 pred_strd,
345                       WORD32 dst_strd,
346                       WORD32 zero_cols)
347{
348    WORD32 i, j;
349    WORD32 trans_size;
350
351    trans_size = TRANS_SIZE_16;
352
353    /* Reconstruction */
354
355    for(i = 0; i < trans_size; i++)
356    {
357        /* Checking for Zero Cols */
358        if((zero_cols & 1) == 1)
359        {
360            for(j = 0; j < trans_size; j++)
361            {
362                pu1_dst[j * dst_strd] = pu1_pred[j * pred_strd];
363            }
364        }
365        else
366        {
367            for(j = 0; j < trans_size; j++)
368            {
369                pu1_dst[j * dst_strd] =
370                                CLIP_U8(pi2_src[j * src_strd] + pu1_pred[j * pred_strd]);
371            }
372        }
373        pi2_src++;
374        pu1_dst++;
375        pu1_pred++;
376        zero_cols = zero_cols >> 1;
377    }
378}
379
380/**
381 *******************************************************************************
382 *
383 * @brief
384 *  This function performs reconstruction for  32x32 input block
385 *
386 * @par Description:
387 *  Performs reconstruction of 32x32 input block by adding  adding prediction
388 * data to input and clipping it to 8 bit
389 *
390 * @param[in] pi2_src
391 *  Input 32x32 coefficients
392 *
393 * @param[in] pu1_pred
394 *  Prediction 32x32 block
395 *
396 * @param[out] pu1_dst
397 *  Output 32x32 block
398 *
399 * @param[in] src_strd
400 *  Input stride
401 *
402 * @param[in] pred_strd
403 *  Prediction stride
404 *
405 * @param[in] dst_strd
406 *  Output Stride
407 *
408 * @param[in] shift
409 *  Output shift
410 *
411 * @param[in] zero_cols
412 *  Zero columns in pi2_tmp
413 *
414 * @returns  Void
415 *
416 * @remarks
417 *  None
418 *
419 *******************************************************************************
420 */
421
422void ihevc_recon_32x32(WORD16 *pi2_src,
423                       UWORD8 *pu1_pred,
424                       UWORD8 *pu1_dst,
425                       WORD32 src_strd,
426                       WORD32 pred_strd,
427                       WORD32 dst_strd,
428                       WORD32 zero_cols)
429{
430    WORD32 i, j;
431    WORD32 trans_size;
432
433    trans_size = TRANS_SIZE_32;
434
435    /* Reconstruction */
436
437    for(i = 0; i < trans_size; i++)
438    {
439        /* Checking for Zero Cols */
440        if((zero_cols & 1) == 1)
441        {
442            for(j = 0; j < trans_size; j++)
443            {
444                pu1_dst[j * dst_strd] = pu1_pred[j * pred_strd];
445            }
446        }
447        else
448        {
449            for(j = 0; j < trans_size; j++)
450            {
451                pu1_dst[j * dst_strd] =
452                                CLIP_U8(pi2_src[j * src_strd] + pu1_pred[j * pred_strd]);
453            }
454        }
455        pi2_src++;
456        pu1_dst++;
457        pu1_pred++;
458        zero_cols = zero_cols >> 1;
459    }
460}
461
462