Coverage Report

Created: 2026-09-01 06:44

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libavc/decoder/ih264d_mb_utils.c
Line
Count
Source
1
/******************************************************************************
2
 *
3
 * Copyright (C) 2015 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 ih264d_mb_utils.c
23
 *
24
 * \brief
25
 *    Contains utitlity functions needed for Macroblock decoding
26
 *
27
 * \date
28
 *    18/12/2002
29
 *
30
 * \author  AI
31
 **************************************************************************
32
 */
33
#include <string.h>
34
#include <stdlib.h>
35
#include "ih264_defs.h"
36
#include "ih264d_bitstrm.h"
37
#include "ih264d_defs.h"
38
#include "ih264d_debug.h"
39
#include "ih264d_structs.h"
40
#include "ih264d_defs.h"
41
#include "ih264d_mb_utils.h"
42
#include "ih264d_parse_slice.h"
43
#include "ih264d_error_handler.h"
44
#include "ih264d_parse_mb_header.h"
45
#include "ih264d_cabac.h"
46
#include "ih264d_defs.h"
47
#include "ih264d_tables.h"
48
49
/*****************************************************************************/
50
/*                                                                           */
51
/*  Function Name : get_mb_info_cavlc                                        */
52
/*                                                                           */
53
/*  Description   : This function sets the following information of cur MB   */
54
/*                  (a) mb_x and mb_y                                        */
55
/*                  (b) Neighbour availablity                                */
56
/*                  (c) Macroblock location in the frame buffer              */
57
/*                  (e) For mbaff predicts field/frame u4_flag for topMb        */
58
/*                      and sets the field/frame for botMb. This is          */
59
/*                      written in ps_dec->u1_cur_mb_fld_dec_flag            */
60
/*                                                                           */
61
/*  Inputs        : pointer to decstruct                                     */
62
/*                  pointer to current mb info                               */
63
/*                  currentMbaddress                                         */
64
/*                                                                           */
65
/*  Processing    : leftMb and TopMb params are used by DecMbskip and        */
66
/*                  DecCtxMbfield  modules so that these modules do not      */
67
/*                  check for neigbour availability and then find the        */
68
/*                  neigbours for context increments                         */
69
/*                                                                           */
70
/*  Returns       : OK                                                       */
71
/*                                                                           */
72
/*  Issues        : <List any issues or problems with this function>         */
73
/*                                                                           */
74
/*  Revision History:                                                        */
75
/*                                                                           */
76
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
77
/*         13 07 2002   Jay             Draft                                */
78
/*                                                                           */
79
/*****************************************************************************/
80
81
UWORD32 ih264d_get_mb_info_cavlc_nonmbaff(dec_struct_t *ps_dec,
82
                                          const UWORD16 u2_cur_mb_address,
83
                                          dec_mb_info_t * ps_cur_mb_info,
84
                                          UWORD32 u4_mbskip_run)
85
20.6M
{
86
20.6M
    WORD32 mb_x;
87
20.6M
    WORD32 mb_y;
88
20.6M
    UWORD8 u1_mb_ngbr_avail = 0;
89
20.6M
    UWORD16 u2_frm_width_in_mb = ps_dec->u2_frm_wd_in_mbs;
90
20.6M
    WORD16 i2_prev_slice_mbx = ps_dec->i2_prev_slice_mbx;
91
20.6M
    UWORD16 u2_top_right_mask = TOP_RIGHT_DEFAULT_AVAILABLE;
92
20.6M
    UWORD16 u2_top_left_mask = TOP_LEFT_DEFAULT_AVAILABLE;
93
20.6M
    UNUSED(u4_mbskip_run);
94
    /*--------------------------------------------------------------------*/
95
    /* Calculate values of mb_x and mb_y                                  */
96
    /*--------------------------------------------------------------------*/
97
20.6M
    mb_x = (WORD16)ps_dec->u2_mbx;
98
20.6M
    mb_y = (WORD16)ps_dec->u2_mby;
99
100
20.6M
    ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
101
102
20.6M
    mb_x++;
103
104
20.6M
    if(mb_x == u2_frm_width_in_mb)
105
361k
    {
106
361k
        mb_x = 0;
107
361k
        mb_y++;
108
361k
    }
109
20.6M
    if(mb_y > ps_dec->i2_prev_slice_mby)
110
20.1M
    {
111
        /* if not in the immemdiate row of prev slice end then top
112
         will be available */
113
20.1M
        if(mb_y > (ps_dec->i2_prev_slice_mby + 1))
114
19.5M
            i2_prev_slice_mbx = -1;
115
116
20.1M
        if(mb_x > i2_prev_slice_mbx)
117
19.9M
        {
118
19.9M
            u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
119
19.9M
            u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
120
19.9M
            u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
121
19.9M
        }
122
123
20.1M
        if((mb_x > (i2_prev_slice_mbx - 1))
124
19.9M
                        && (mb_x != (u2_frm_width_in_mb - 1)))
125
19.6M
        {
126
19.6M
            u1_mb_ngbr_avail |= TOP_RIGHT_MB_AVAILABLE_MASK;
127
19.6M
            u2_top_right_mask |= TOP_RIGHT_TOPR_AVAILABLE;
128
19.6M
        }
129
130
20.1M
        if(mb_x > (i2_prev_slice_mbx + 1))
131
19.6M
        {
132
19.6M
            u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
133
19.6M
            u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
134
19.6M
        }
135
136
        /* Next row  Left will be available*/
137
20.1M
        i2_prev_slice_mbx = -1;
138
20.1M
    }
139
140
    /* Same row */
141
20.6M
    if(mb_x > (i2_prev_slice_mbx + 1))
142
20.2M
    {
143
20.2M
        u1_mb_ngbr_avail |= LEFT_MB_AVAILABLE_MASK;
144
20.2M
        u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
145
20.2M
    }
146
147
20.6M
    {
148
20.6M
        mb_neigbour_params_t *ps_cur_mb_row = ps_dec->ps_cur_mb_row;
149
20.6M
        mb_neigbour_params_t *ps_top_mb_row = ps_dec->ps_top_mb_row;
150
151
        /* copy the parameters of topleft Mb */
152
20.6M
        ps_cur_mb_info->u1_topleft_mbtype = ps_dec->u1_topleft_mbtype;
153
        /* Neighbour pointer assignments*/
154
20.6M
        ps_cur_mb_info->ps_curmb = ps_cur_mb_row + mb_x;
155
20.6M
        ps_cur_mb_info->ps_left_mb = ps_cur_mb_row + mb_x - 1;
156
20.6M
        ps_cur_mb_info->ps_top_mb = ps_top_mb_row + mb_x;
157
20.6M
        ps_cur_mb_info->ps_top_right_mb = ps_top_mb_row + mb_x + 1;
158
159
        /* Update the parameters of topleftmb*/
160
20.6M
        ps_dec->u1_topleft_mbtype = ps_cur_mb_info->ps_top_mb->u1_mb_type;
161
20.6M
    }
162
163
20.6M
    ps_dec->u2_mby = mb_y;
164
20.6M
    ps_dec->u2_mbx = mb_x;
165
20.6M
    ps_cur_mb_info->u2_mbx = mb_x;
166
20.6M
    ps_cur_mb_info->u2_mby = mb_y;
167
20.6M
    ps_cur_mb_info->u1_topmb = 1;
168
20.6M
    ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
169
20.6M
    ps_dec->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
170
20.6M
    ps_cur_mb_info->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
171
20.6M
    ps_cur_mb_info->ps_curmb->u1_mb_fld = ps_dec->u1_cur_mb_fld_dec_flag;
172
20.6M
    ps_cur_mb_info->u1_mb_field_decodingflag = ps_dec->u1_cur_mb_fld_dec_flag;
173
20.6M
    ps_cur_mb_info->u2_top_left_avail_mask = u2_top_left_mask;
174
20.6M
    ps_cur_mb_info->u2_top_right_avail_mask = u2_top_right_mask;
175
20.6M
    return (OK);
176
177
20.6M
}
178
179
/*****************************************************************************/
180
/*                                                                           */
181
/*  Function Name : get_mb_info_cavlc                                        */
182
/*                                                                           */
183
/*  Description   : This function sets the following information of cur MB   */
184
/*                  (a) mb_x and mb_y                                        */
185
/*                  (b) Neighbour availablity                                */
186
/*                  (c) Macroblock location in the frame buffer              */
187
/*                  (e) For mbaff predicts field/frame u4_flag for topMb        */
188
/*                      and sets the field/frame for botMb. This is          */
189
/*                      written in ps_dec->u1_cur_mb_fld_dec_flag            */
190
/*                                                                           */
191
/*  Inputs        : pointer to decstruct                                     */
192
/*                  pointer to current mb info                               */
193
/*                  currentMbaddress                                         */
194
/*                                                                           */
195
/*  Processing    : leftMb and TopMb params are used by DecMbskip and        */
196
/*                  DecCtxMbfield  modules so that these modules do not      */
197
/*                  check for neigbour availability and then find the        */
198
/*                  neigbours for context increments                         */
199
/*                                                                           */
200
/*  Returns       : OK                                                       */
201
/*                                                                           */
202
/*  Issues        : <List any issues or problems with this function>         */
203
/*                                                                           */
204
/*  Revision History:                                                        */
205
/*                                                                           */
206
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
207
/*         13 07 2002   Jay             Draft                                */
208
/*                                                                           */
209
/*****************************************************************************/
210
211
UWORD32 ih264d_get_mb_info_cavlc_mbaff(dec_struct_t *ps_dec,
212
                                       const UWORD16 u2_cur_mb_address,
213
                                       dec_mb_info_t * ps_cur_mb_info,
214
                                       UWORD32 u4_mbskip_run)
215
1.40M
{
216
1.40M
    UWORD16 u2_mb_x;
217
1.40M
    UWORD16 u2_mb_y;
218
1.40M
    UWORD8 u1_mb_ngbr_avail = 0;
219
1.40M
    UWORD16 u2_frm_width_in_mb = ps_dec->u2_frm_wd_in_mbs;
220
221
1.40M
    UWORD8 u1_top_mb = 1 - (u2_cur_mb_address & 0x01);
222
1.40M
    WORD16 i2_prev_slice_mbx = ps_dec->i2_prev_slice_mbx;
223
1.40M
    UWORD8 u1_cur_mb_field = 0;
224
1.40M
    UWORD16 u2_top_right_mask = TOP_RIGHT_DEFAULT_AVAILABLE;
225
1.40M
    UWORD16 u2_top_left_mask = TOP_LEFT_DEFAULT_AVAILABLE;
226
227
    /*--------------------------------------------------------------------*/
228
    /* Calculate values of mb_x and mb_y                                  */
229
    /*--------------------------------------------------------------------*/
230
1.40M
    u2_mb_x = ps_dec->u2_mbx;
231
1.40M
    u2_mb_y = ps_dec->u2_mby;
232
233
1.40M
    ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
234
235
236
1.40M
    if(u1_top_mb)
237
704k
    {
238
704k
        u2_mb_x++;
239
704k
        if(u2_mb_x == u2_frm_width_in_mb)
240
26.2k
        {
241
26.2k
            u2_mb_x = 0;
242
26.2k
            u2_mb_y += 2;
243
26.2k
        }
244
704k
        if(u2_mb_y > ps_dec->i2_prev_slice_mby)
245
660k
        {
246
            /* if not in the immemdiate row of prev slice end then top
247
             will be available */
248
660k
            if(u2_mb_y > (ps_dec->i2_prev_slice_mby + 2))
249
629k
                i2_prev_slice_mbx = -1;
250
660k
            if(u2_mb_x > i2_prev_slice_mbx)
251
653k
            {
252
653k
                u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
253
653k
                u1_cur_mb_field = ps_dec->ps_top_mb_row[u2_mb_x << 1].u1_mb_fld;
254
653k
                u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
255
653k
                u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
256
653k
            }
257
660k
            if((u2_mb_x > (i2_prev_slice_mbx - 1))
258
654k
                            && (u2_mb_x != (u2_frm_width_in_mb - 1)))
259
628k
            {
260
628k
                u1_mb_ngbr_avail |= TOP_RIGHT_MB_AVAILABLE_MASK;
261
628k
                u2_top_right_mask |= TOP_RIGHT_TOPR_AVAILABLE;
262
628k
            }
263
264
660k
            if(u2_mb_x > (i2_prev_slice_mbx + 1))
265
627k
            {
266
627k
                u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
267
627k
                u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
268
627k
            }
269
270
660k
            i2_prev_slice_mbx = -1;
271
660k
        }
272
        /* Same row */
273
704k
        if(u2_mb_x > (i2_prev_slice_mbx + 1))
274
676k
        {
275
676k
            u1_mb_ngbr_avail |= LEFT_MB_AVAILABLE_MASK;
276
676k
            u1_cur_mb_field =
277
676k
                            ps_dec->ps_cur_mb_row[(u2_mb_x << 1) - 1].u1_mb_fld;
278
676k
            u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
279
676k
        }
280
        /* Read u1_cur_mb_field from the bitstream if u4_mbskip_run <= 1*/
281
704k
        if(u4_mbskip_run <= 1)
282
6.53k
            u1_cur_mb_field = (UWORD8)ih264d_get_bit_h264(ps_dec->ps_bitstrm);
283
284
704k
        ps_dec->u1_cur_mb_fld_dec_flag = u1_cur_mb_field;
285
704k
        ps_dec->u2_top_left_mask = u2_top_left_mask;
286
704k
        ps_dec->u2_top_right_mask = u2_top_right_mask;
287
704k
    }
288
704k
    else
289
704k
    {
290
704k
        u1_mb_ngbr_avail = ps_dec->u1_mb_ngbr_availablity;
291
704k
        u1_cur_mb_field = ps_dec->u1_cur_mb_fld_dec_flag;
292
704k
        u2_top_left_mask = ps_dec->u2_top_left_mask;
293
704k
        u2_top_right_mask = ps_dec->u2_top_right_mask;
294
295
704k
        if(!u1_cur_mb_field)
296
695k
        {
297
            /* Top is available */
298
695k
            u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
299
695k
            u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
300
695k
            u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
301
            /* Top Right not available */
302
695k
            u1_mb_ngbr_avail &= TOP_RT_SUBBLOCK_MASK_MOD;
303
695k
            u2_top_right_mask &= (~TOP_RIGHT_TOPR_AVAILABLE);
304
305
695k
            if(u1_mb_ngbr_avail & LEFT_MB_AVAILABLE_MASK)
306
668k
            {
307
668k
                u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
308
668k
                u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
309
668k
                u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
310
668k
            }
311
695k
        }
312
704k
    }
313
314
1.40M
    ps_dec->u2_mby = u2_mb_y;
315
1.40M
    ps_dec->u2_mbx = u2_mb_x;
316
1.40M
    ps_cur_mb_info->u2_mbx = u2_mb_x;
317
1.40M
    ps_cur_mb_info->u2_mby = u2_mb_y;
318
1.40M
    ps_cur_mb_info->u1_topmb = u1_top_mb;
319
1.40M
    ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
320
1.40M
    ps_dec->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
321
1.40M
    ps_cur_mb_info->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
322
1.40M
    ps_cur_mb_info->u1_mb_field_decodingflag = u1_cur_mb_field;
323
1.40M
    ps_cur_mb_info->u2_top_left_avail_mask = u2_top_left_mask;
324
1.40M
    ps_cur_mb_info->u2_top_right_avail_mask = u2_top_right_mask;
325
1.40M
    ih264d_get_mbaff_neighbours(ps_dec, ps_cur_mb_info, u1_cur_mb_field);
326
1.40M
    return (OK);
327
1.40M
}
328
329
/*****************************************************************************/
330
/*                                                                           */
331
/*  Function Name : get_mb_info_cabac                                        */
332
/*                                                                           */
333
/*  Description   : This function sets the following information of cur MB   */
334
/*                  (a) mb_x and mb_y                                        */
335
/*                  (b) Neighbour availablity                                */
336
/*                  (c) Macroblock location in the frame buffer              */
337
/*                  (e) leftMb parama and TopMb params of curMB              */
338
/*                  (f) For Mbaff case leftMb params and TopMb params of     */
339
/*                      bottomMb are also set if curMB is top                */
340
/*                  (g) For mbaff predicts field/frame u4_flag for topMb        */
341
/*                      and sets the field/frame for botMb. This is          */
342
/*                      written in ps_dec->u1_cur_mb_fld_dec_flag            */
343
/*                                                                           */
344
/*  Inputs        : pointer to decstruct                                     */
345
/*                  pointer to current mb info                               */
346
/*                  currentMbaddress                                         */
347
/*                                                                           */
348
/*  Processing    : leftMb and TopMb params are used by DecMbskip and        */
349
/*                  DecCtxMbfield  modules so that these modules do not      */
350
/*                  check for neigbour availability and then find the        */
351
/*                  neigbours for context increments                         */
352
/*                                                                           */
353
/*  Returns       : OK                                                       */
354
/*                                                                           */
355
/*  Issues        : <List any issues or problems with this function>         */
356
/*                                                                           */
357
/*  Revision History:                                                        */
358
/*                                                                           */
359
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
360
/*         13 07 2002   Jay             Draft                                */
361
/*                                                                           */
362
/*****************************************************************************/
363
UWORD32 ih264d_get_mb_info_cabac_nonmbaff(dec_struct_t *ps_dec,
364
                                          const UWORD16 u2_cur_mb_address,
365
                                          dec_mb_info_t * ps_cur_mb_info,
366
                                          UWORD32 u4_mbskip)
367
1.89M
{
368
1.89M
    WORD32 mb_x;
369
1.89M
    WORD32 mb_y;
370
1.89M
    UWORD32 u1_mb_ngbr_avail = 0;
371
1.89M
    UWORD32 u2_frm_width_in_mb = ps_dec->u2_frm_wd_in_mbs;
372
1.89M
    UWORD32 u1_top_mb = 1;
373
1.89M
    WORD32 i2_prev_slice_mbx = ps_dec->i2_prev_slice_mbx;
374
1.89M
    UWORD32 u2_top_right_mask = TOP_RIGHT_DEFAULT_AVAILABLE;
375
1.89M
    UWORD32 u2_top_left_mask = TOP_LEFT_DEFAULT_AVAILABLE;
376
1.89M
    ctxt_inc_mb_info_t * const p_ctx_inc_mb_map = ps_dec->p_ctxt_inc_mb_map;
377
378
    /*--------------------------------------------------------------------*/
379
    /* Calculate values of mb_x and mb_y                                  */
380
    /*--------------------------------------------------------------------*/
381
1.89M
    mb_x = (WORD16)ps_dec->u2_mbx;
382
1.89M
    mb_y = (WORD16)ps_dec->u2_mby;
383
384
1.89M
    ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
385
386
1.89M
    mb_x++;
387
1.89M
    if((UWORD32)mb_x == u2_frm_width_in_mb)
388
62.5k
    {
389
62.5k
        mb_x = 0;
390
62.5k
        mb_y++;
391
62.5k
    }
392
    /*********************************************************************/
393
    /* Cabac Context Initialisations                                     */
394
    /*********************************************************************/
395
1.89M
    ps_dec->ps_curr_ctxt_mb_info = p_ctx_inc_mb_map + mb_x;
396
1.89M
    ps_dec->p_left_ctxt_mb_info = p_ctx_inc_mb_map - 1;
397
1.89M
    ps_dec->p_top_ctxt_mb_info = p_ctx_inc_mb_map - 1;
398
399
    /********************************************************************/
400
    /* neighbour availablility                                          */
401
    /********************************************************************/
402
1.89M
    if(mb_y > ps_dec->i2_prev_slice_mby)
403
1.63M
    {
404
        /* if not in the immemdiate row of prev slice end then top
405
         will be available */
406
1.63M
        if(mb_y > (ps_dec->i2_prev_slice_mby + 1))
407
1.51M
            i2_prev_slice_mbx = -1;
408
409
1.63M
        if(mb_x > i2_prev_slice_mbx)
410
1.59M
        {
411
1.59M
            u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
412
1.59M
            u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
413
1.59M
            u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
414
1.59M
            ps_dec->p_top_ctxt_mb_info = ps_dec->ps_curr_ctxt_mb_info;
415
1.59M
        }
416
1.63M
        if((mb_x > (i2_prev_slice_mbx - 1))
417
1.60M
                        && ((UWORD32)mb_x != (u2_frm_width_in_mb - 1)))
418
1.54M
        {
419
1.54M
            u1_mb_ngbr_avail |= TOP_RIGHT_MB_AVAILABLE_MASK;
420
1.54M
            u2_top_right_mask |= TOP_RIGHT_TOPR_AVAILABLE;
421
1.54M
        }
422
423
1.63M
        if(mb_x > (i2_prev_slice_mbx + 1))
424
1.54M
        {
425
1.54M
            u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
426
1.54M
            u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
427
1.54M
        }
428
        /* Next row */
429
1.63M
        i2_prev_slice_mbx = -1;
430
1.63M
    }
431
    /* Same row */
432
1.89M
    if(mb_x > (i2_prev_slice_mbx + 1))
433
1.82M
    {
434
1.82M
        u1_mb_ngbr_avail |= LEFT_MB_AVAILABLE_MASK;
435
1.82M
        u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
436
1.82M
        ps_dec->p_left_ctxt_mb_info = ps_dec->ps_curr_ctxt_mb_info - 1;
437
1.82M
    }
438
1.89M
    {
439
1.89M
        mb_neigbour_params_t *ps_cur_mb_row = ps_dec->ps_cur_mb_row;
440
1.89M
        mb_neigbour_params_t *ps_top_mb_row = ps_dec->ps_top_mb_row;
441
        /* copy the parameters of topleft Mb */
442
1.89M
        ps_cur_mb_info->u1_topleft_mbtype = ps_dec->u1_topleft_mbtype;
443
        /* Neighbour pointer assignments*/
444
1.89M
        ps_cur_mb_info->ps_curmb = ps_cur_mb_row + mb_x;
445
1.89M
        ps_cur_mb_info->ps_left_mb = ps_cur_mb_row + mb_x - 1;
446
1.89M
        ps_cur_mb_info->ps_top_mb = ps_top_mb_row + mb_x;
447
1.89M
        ps_cur_mb_info->ps_top_right_mb = ps_top_mb_row + mb_x + 1;
448
449
        /* Update the parameters of topleftmb*/
450
1.89M
        ps_dec->u1_topleft_mbtype = ps_cur_mb_info->ps_top_mb->u1_mb_type;
451
1.89M
    }
452
453
1.89M
    ps_dec->u2_mby = mb_y;
454
1.89M
    ps_dec->u2_mbx = mb_x;
455
1.89M
    ps_cur_mb_info->u2_mbx = mb_x;
456
1.89M
    ps_cur_mb_info->u2_mby = mb_y;
457
1.89M
    ps_cur_mb_info->u1_topmb = u1_top_mb;
458
1.89M
    ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
459
1.89M
    ps_dec->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
460
1.89M
    ps_cur_mb_info->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
461
1.89M
    ps_cur_mb_info->ps_curmb->u1_mb_fld = ps_dec->u1_cur_mb_fld_dec_flag;
462
1.89M
    ps_cur_mb_info->u1_mb_field_decodingflag = ps_dec->u1_cur_mb_fld_dec_flag;
463
1.89M
    ps_cur_mb_info->u2_top_left_avail_mask = u2_top_left_mask;
464
1.89M
    ps_cur_mb_info->u2_top_right_avail_mask = u2_top_right_mask;
465
466
    /*********************************************************************/
467
    /*                  Assign the neigbours                             */
468
    /*********************************************************************/
469
1.89M
    if(u4_mbskip)
470
547k
    {
471
547k
        UWORD32 u4_ctx_inc =
472
547k
                        2
473
547k
                                        - ((!!(ps_dec->p_top_ctxt_mb_info->u1_mb_type
474
547k
                                                        & CAB_SKIP_MASK))
475
547k
                                                        + (!!(ps_dec->p_left_ctxt_mb_info->u1_mb_type
476
547k
                                                                        & CAB_SKIP_MASK)));
477
478
547k
        u4_mbskip = ih264d_decode_bin(u4_ctx_inc, ps_dec->p_mb_skip_flag_t,
479
547k
                                      ps_dec->ps_bitstrm, &ps_dec->s_cab_dec_env);
480
481
547k
        if(!u4_mbskip)
482
165k
        {
483
165k
            if(!(u1_mb_ngbr_avail & LEFT_MB_AVAILABLE_MASK))
484
16.6k
            {
485
16.6k
                UWORD32 *pu4_buf;
486
16.6k
                UWORD8 *pu1_buf;
487
488
16.6k
                pu1_buf = ps_dec->pu1_left_nnz_y;
489
16.6k
                pu4_buf = (UWORD32 *)pu1_buf;
490
16.6k
                *pu4_buf = 0;
491
16.6k
                pu1_buf = ps_dec->pu1_left_nnz_uv;
492
16.6k
                pu4_buf = (UWORD32 *)pu1_buf;
493
16.6k
                *pu4_buf = 0;
494
495
496
16.6k
                *(ps_dec->pu1_left_yuv_dc_csbp) = 0;
497
16.6k
                MEMSET_16BYTES(&ps_dec->pu1_left_mv_ctxt_inc[0][0], 0);
498
16.6k
                *(UWORD32 *)ps_dec->pi1_left_ref_idx_ctxt_inc = 0;
499
16.6k
            }
500
165k
            if(!(u1_mb_ngbr_avail & TOP_MB_AVAILABLE_MASK))
501
51.5k
            {
502
51.5k
                MEMSET_16BYTES(ps_dec->ps_curr_ctxt_mb_info->u1_mv, 0);
503
51.5k
                memset(ps_dec->ps_curr_ctxt_mb_info->i1_ref_idx, 0, 4);
504
51.5k
            }
505
165k
        }
506
547k
    }
507
1.89M
    return (u4_mbskip);
508
1.89M
}
509
510
/*****************************************************************************/
511
/*                                                                           */
512
/*  Function Name : get_mb_info_cabac                                        */
513
/*                                                                           */
514
/*  Description   : This function sets the following information of cur MB   */
515
/*                  (a) mb_x and mb_y                                        */
516
/*                  (b) Neighbour availablity                                */
517
/*                  (c) Macroblock location in the frame buffer              */
518
/*                  (e) leftMb parama and TopMb params of curMB              */
519
/*                  (f) For Mbaff case leftMb params and TopMb params of     */
520
/*                      bottomMb are also set if curMB is top                */
521
/*                  (g) For mbaff predicts field/frame u4_flag for topMb        */
522
/*                      and sets the field/frame for botMb. This is          */
523
/*                      written in ps_dec->u1_cur_mb_fld_dec_flag            */
524
/*                                                                           */
525
/*  Inputs        : pointer to decstruct                                     */
526
/*                  pointer to current mb info                               */
527
/*                  currentMbaddress                                         */
528
/*                                                                           */
529
/*  Processing    : leftMb and TopMb params are used by DecMbskip and        */
530
/*                  DecCtxMbfield  modules so that these modules do not      */
531
/*                  check for neigbour availability and then find the        */
532
/*                  neigbours for context increments                         */
533
/*                                                                           */
534
/*  Returns       : OK                                                       */
535
/*                                                                           */
536
/*  Issues        : <List any issues or problems with this function>         */
537
/*                                                                           */
538
/*  Revision History:                                                        */
539
/*                                                                           */
540
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
541
/*         13 07 2002   Jay             Draft                                */
542
/*                                                                           */
543
/*****************************************************************************/
544
545
UWORD32 ih264d_get_mb_info_cabac_mbaff(dec_struct_t *ps_dec,
546
                                       const UWORD16 u2_cur_mb_address,
547
                                       dec_mb_info_t * ps_cur_mb_info,
548
                                       UWORD32 u4_mbskip)
549
101k
{
550
101k
    WORD32 mb_x;
551
101k
    WORD32 mb_y;
552
101k
    UWORD8 u1_mb_ngbr_avail = 0;
553
101k
    UWORD16 u2_frm_width_in_mb = ps_dec->u2_frm_wd_in_mbs;
554
101k
    ctxt_inc_mb_info_t * const p_ctx_inc_mb_map = ps_dec->p_ctxt_inc_mb_map;
555
101k
    ctxt_inc_mb_info_t *ps_curr_ctxt, *ps_top_ctxt, *ps_left_ctxt;
556
101k
    mb_neigbour_params_t *ps_cur_mb_row = ps_dec->ps_cur_mb_row;
557
101k
    mb_neigbour_params_t *ps_top_mb_row = ps_dec->ps_top_mb_row;
558
101k
    UWORD32 u4_left_mb_pair_fld = 0;
559
101k
    UWORD32 u4_top_mb_pair_fld = 0;
560
101k
    UWORD8 u1_cur_mb_field = 0;
561
101k
    UWORD8 u1_top_mb = 1 - (u2_cur_mb_address & 0x01);
562
101k
    WORD16 i2_prev_slice_mbx = ps_dec->i2_prev_slice_mbx;
563
101k
    UWORD16 u2_top_right_mask = TOP_RIGHT_DEFAULT_AVAILABLE;
564
101k
    UWORD16 u2_top_left_mask = TOP_LEFT_DEFAULT_AVAILABLE;
565
566
    /*--------------------------------------------------------------------*/
567
    /* Calculate values of mb_x and mb_y                                  */
568
    /*--------------------------------------------------------------------*/
569
101k
    mb_x = (WORD16)ps_dec->u2_mbx;
570
101k
    mb_y = (WORD16)ps_dec->u2_mby;
571
572
101k
    ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
573
574
101k
    ps_top_ctxt = ps_left_ctxt = p_ctx_inc_mb_map - 1;
575
576
101k
    if(u1_top_mb)
577
50.8k
    {
578
50.8k
        ctxt_inc_mb_info_t *ps_left_mb_of_bot = ps_left_ctxt;
579
50.8k
        ctxt_inc_mb_info_t *ps_top_mb_of_bot = ps_top_ctxt;
580
581
50.8k
        mb_x++;
582
583
50.8k
        if(mb_x == u2_frm_width_in_mb)
584
2.65k
        {
585
2.65k
            mb_x = 0;
586
2.65k
            mb_y += 2;
587
2.65k
        }
588
589
50.8k
        ps_curr_ctxt = p_ctx_inc_mb_map + (mb_x << 1);
590
50.8k
        if(mb_y > ps_dec->i2_prev_slice_mby)
591
45.5k
        {
592
45.5k
            UWORD8 u1_cur_mb_fld_flag_known = 0;
593
            /* Next row */
594
45.5k
            if(mb_x > 0)
595
42.8k
            {
596
                /***********************************************************************/
597
                /*                    Left Mb is avialable                             */
598
                /***********************************************************************/
599
42.8k
                u1_mb_ngbr_avail |= LEFT_MB_AVAILABLE_MASK;
600
42.8k
                ps_left_ctxt = ps_curr_ctxt - 2;
601
42.8k
                ps_left_mb_of_bot = ps_curr_ctxt - 1;
602
42.8k
                u1_cur_mb_field = u4_left_mb_pair_fld = ps_cur_mb_row[(mb_x
603
42.8k
                                << 1) - 1].u1_mb_fld;
604
42.8k
                u1_cur_mb_fld_flag_known = 1;
605
42.8k
                u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
606
42.8k
            }
607
            /* if not in the immemdiate row of prev slice end then top
608
             will be available */
609
45.5k
            if(mb_y > (ps_dec->i2_prev_slice_mby + 2))
610
42.2k
                i2_prev_slice_mbx = -1;
611
45.5k
            if(mb_x > i2_prev_slice_mbx)
612
45.5k
            {
613
                /*********************************************************************/
614
                /*                    Top Mb is avialable                            */
615
                /*********************************************************************/
616
45.5k
                u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
617
45.5k
                u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
618
45.5k
                u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
619
620
                /* point to MbAddrB + 1 */
621
45.5k
                ps_top_ctxt = ps_curr_ctxt + 1;
622
45.5k
                u4_top_mb_pair_fld = ps_top_mb_row[(mb_x << 1)].u1_mb_fld;
623
624
45.5k
                u1_cur_mb_field =
625
45.5k
                                u1_cur_mb_fld_flag_known ?
626
42.8k
                                                u1_cur_mb_field :
627
45.5k
                                                u4_top_mb_pair_fld;
628
45.5k
                ps_top_mb_of_bot = u1_cur_mb_field ? ps_top_ctxt : ps_curr_ctxt;
629
630
                /* MbAddrB */
631
45.5k
                ps_top_ctxt -= (u1_cur_mb_field && u4_top_mb_pair_fld);
632
45.5k
            }
633
634
45.5k
            if((mb_x > (i2_prev_slice_mbx - 1))
635
45.5k
                            && (mb_x != (u2_frm_width_in_mb - 1)))
636
43.0k
            {
637
43.0k
                u1_mb_ngbr_avail |= TOP_RIGHT_MB_AVAILABLE_MASK;
638
43.0k
                u2_top_right_mask |= TOP_RIGHT_TOPR_AVAILABLE;
639
43.0k
            }
640
641
45.5k
            if(mb_x > (i2_prev_slice_mbx + 1))
642
42.8k
            {
643
42.8k
                u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
644
42.8k
                u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
645
42.8k
            }
646
45.5k
        }
647
5.29k
        else
648
5.29k
        {
649
            /* Same row */
650
5.29k
            if(mb_x > (i2_prev_slice_mbx + 1))
651
4.71k
            {
652
                /***************************************************************/
653
                /*                    Left Mb is avialable                     */
654
                /***************************************************************/
655
4.71k
                u1_mb_ngbr_avail |= LEFT_MB_AVAILABLE_MASK;
656
657
4.71k
                u1_cur_mb_field = u4_left_mb_pair_fld = ps_cur_mb_row[(mb_x
658
4.71k
                                << 1) - 1].u1_mb_fld;
659
4.71k
                ps_left_ctxt = ps_curr_ctxt - 2;
660
4.71k
                ps_left_mb_of_bot = ps_curr_ctxt - 1;
661
4.71k
                u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
662
4.71k
            }
663
5.29k
        }
664
        /*********************************************************/
665
        /* Check whether the call is from I slice or Inter slice */
666
        /*********************************************************/
667
50.8k
        if(u4_mbskip)
668
49.3k
        {
669
49.3k
            UWORD32 u4_ctx_inc = 2
670
49.3k
                            - ((!!(ps_top_ctxt->u1_mb_type & CAB_SKIP_MASK))
671
49.3k
                                            + (!!(ps_left_ctxt->u1_mb_type
672
49.3k
                                                            & CAB_SKIP_MASK)));
673
49.3k
            dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
674
49.3k
            decoding_envirnoment_t *ps_cab_dec_env = &ps_dec->s_cab_dec_env;
675
49.3k
            bin_ctxt_model_t *p_mb_skip_flag_t = ps_dec->p_mb_skip_flag_t;
676
677
49.3k
            ps_dec->u4_next_mb_skip = 0;
678
49.3k
            u4_mbskip = ih264d_decode_bin(u4_ctx_inc, p_mb_skip_flag_t,
679
49.3k
                                          ps_bitstrm, ps_cab_dec_env);
680
681
49.3k
            if(u4_mbskip)
682
17.8k
            {
683
17.8k
                UWORD32 u4_next_mbskip;
684
17.8k
                ps_curr_ctxt->u1_mb_type = CAB_SKIP;
685
686
17.8k
                u4_ctx_inc =
687
17.8k
                                2
688
17.8k
                                                - ((!!(ps_top_mb_of_bot->u1_mb_type
689
17.8k
                                                                & CAB_SKIP_MASK))
690
17.8k
                                                                + (!!(ps_left_mb_of_bot->u1_mb_type
691
17.8k
                                                                                & CAB_SKIP_MASK)));
692
693
                /* Decode the skip u4_flag of bottom Mb */
694
17.8k
                u4_next_mbskip = ih264d_decode_bin(u4_ctx_inc, p_mb_skip_flag_t,
695
17.8k
                                                   ps_bitstrm,
696
17.8k
                                                   ps_cab_dec_env);
697
698
17.8k
                ps_dec->u4_next_mb_skip = u4_next_mbskip;
699
700
17.8k
                if(!u4_next_mbskip)
701
4.21k
                {
702
4.21k
                    u4_ctx_inc = u4_top_mb_pair_fld + u4_left_mb_pair_fld;
703
704
4.21k
                    u1_cur_mb_field = ih264d_decode_bin(
705
4.21k
                                    u4_ctx_inc, ps_dec->p_mb_field_dec_flag_t,
706
4.21k
                                    ps_bitstrm, ps_cab_dec_env);
707
4.21k
                }
708
17.8k
            }
709
49.3k
        }
710
711
50.8k
        if(!u4_mbskip)
712
32.9k
        {
713
32.9k
            UWORD32 u4_ctx_inc = u4_top_mb_pair_fld + u4_left_mb_pair_fld;
714
32.9k
            u1_cur_mb_field = ih264d_decode_bin(u4_ctx_inc,
715
32.9k
                                                ps_dec->p_mb_field_dec_flag_t,
716
32.9k
                                                ps_dec->ps_bitstrm,
717
32.9k
                                                &ps_dec->s_cab_dec_env);
718
32.9k
        }
719
720
50.8k
        ps_dec->u1_cur_mb_fld_dec_flag = u1_cur_mb_field;
721
50.8k
        ps_dec->u2_top_left_mask = u2_top_left_mask;
722
50.8k
        ps_dec->u2_top_right_mask = u2_top_right_mask;
723
50.8k
        ps_dec->u2_mby = mb_y;
724
50.8k
        ps_dec->u2_mbx = mb_x;
725
50.8k
    }
726
50.5k
    else
727
50.5k
    {
728
50.5k
        u1_cur_mb_field = ps_dec->u1_cur_mb_fld_dec_flag;
729
50.5k
        u1_mb_ngbr_avail = ps_dec->u1_mb_ngbr_availablity;
730
50.5k
        u2_top_left_mask = ps_dec->u2_top_left_mask;
731
50.5k
        u2_top_right_mask = ps_dec->u2_top_right_mask;
732
50.5k
        ps_curr_ctxt = p_ctx_inc_mb_map + (mb_x << 1) + 1;
733
734
50.5k
        if(u1_mb_ngbr_avail & LEFT_MB_AVAILABLE_MASK)
735
47.4k
        {
736
47.4k
            u4_left_mb_pair_fld = ps_cur_mb_row[(mb_x << 1) - 1].u1_mb_fld;
737
738
            /* point to A if top else A+1 */
739
47.4k
            ps_left_ctxt = ps_curr_ctxt - 2
740
47.4k
                            - (u4_left_mb_pair_fld != u1_cur_mb_field);
741
47.4k
        }
742
743
50.5k
        if(u1_cur_mb_field)
744
20.9k
        {
745
20.9k
            if(u1_mb_ngbr_avail & TOP_MB_AVAILABLE_MASK)
746
19.8k
            {
747
                /* point to MbAddrB + 1 */
748
19.8k
                ps_top_ctxt = ps_curr_ctxt;
749
19.8k
            }
750
20.9k
        }
751
29.5k
        else
752
29.5k
        {
753
            /* Top is available */
754
29.5k
            u1_mb_ngbr_avail |= TOP_MB_AVAILABLE_MASK;
755
29.5k
            u2_top_right_mask |= TOP_RIGHT_TOP_AVAILABLE;
756
29.5k
            u2_top_left_mask |= TOP_LEFT_TOP_AVAILABLE;
757
            /* Top Right not available */
758
29.5k
            u1_mb_ngbr_avail &= TOP_RT_SUBBLOCK_MASK_MOD;
759
29.5k
            u2_top_right_mask &= (~TOP_RIGHT_TOPR_AVAILABLE);
760
761
29.5k
            if(u1_mb_ngbr_avail & LEFT_MB_AVAILABLE_MASK)
762
27.1k
            {
763
27.1k
                u1_mb_ngbr_avail |= TOP_LEFT_MB_AVAILABLE_MASK;
764
27.1k
                u2_top_left_mask |= TOP_LEFT_LEFT_AVAILABLE;
765
27.1k
                u2_top_left_mask |= TOP_LEFT_TOPL_AVAILABLE;
766
27.1k
            }
767
768
            /* CurMbAddr - 1 */
769
29.5k
            ps_top_ctxt = ps_curr_ctxt - 1;
770
29.5k
        }
771
772
50.5k
        if(u4_mbskip)
773
49.0k
        {
774
49.0k
            if(ps_curr_ctxt[-1].u1_mb_type & CAB_SKIP_MASK)
775
17.8k
            {
776
                /* If previous mb is skipped, return value of next mb skip */
777
17.8k
                u4_mbskip = ps_dec->u4_next_mb_skip;
778
779
17.8k
            }
780
31.2k
            else
781
31.2k
            {
782
                /* If previous mb is not skipped then call DecMbSkip */
783
31.2k
                UWORD32 u4_ctx_inc =
784
31.2k
                                2
785
31.2k
                                                - ((!!(ps_top_ctxt->u1_mb_type
786
31.2k
                                                                & CAB_SKIP_MASK))
787
31.2k
                                                                + (!!(ps_left_ctxt->u1_mb_type
788
31.2k
                                                                                & CAB_SKIP_MASK)));
789
790
31.2k
                u4_mbskip = ih264d_decode_bin(u4_ctx_inc,
791
31.2k
                                              ps_dec->p_mb_skip_flag_t,
792
31.2k
                                              ps_dec->ps_bitstrm,
793
31.2k
                                              &ps_dec->s_cab_dec_env);
794
31.2k
            }
795
49.0k
        }
796
50.5k
    }
797
798
101k
    ps_cur_mb_info->u2_mbx = mb_x;
799
101k
    ps_cur_mb_info->u2_mby = mb_y;
800
101k
    ps_cur_mb_info->u1_topmb = u1_top_mb;
801
101k
    ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
802
101k
    ps_dec->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
803
101k
    ps_cur_mb_info->u1_mb_ngbr_availablity = u1_mb_ngbr_avail;
804
101k
    ps_cur_mb_info->u1_mb_field_decodingflag = u1_cur_mb_field;
805
101k
    ps_cur_mb_info->u2_top_left_avail_mask = u2_top_left_mask;
806
101k
    ps_cur_mb_info->u2_top_right_avail_mask = u2_top_right_mask;
807
808
101k
    ih264d_get_mbaff_neighbours(ps_dec, ps_cur_mb_info, u1_cur_mb_field);
809
101k
    {
810
101k
        ih264d_get_cabac_context_mbaff(ps_dec, ps_cur_mb_info, u4_mbskip);
811
101k
    }
812
813
101k
    {
814
101k
        bin_ctxt_model_t *p_cabac_ctxt_table_t = ps_dec->p_cabac_ctxt_table_t;
815
816
101k
        if(u1_cur_mb_field)
817
42.1k
        {
818
42.1k
            p_cabac_ctxt_table_t += SIGNIFICANT_COEFF_FLAG_FLD;
819
42.1k
        }
820
59.2k
        else
821
59.2k
        {
822
59.2k
            p_cabac_ctxt_table_t += SIGNIFICANT_COEFF_FLAG_FRAME;
823
59.2k
        }
824
101k
        {
825
101k
            bin_ctxt_model_t * * p_significant_coeff_flag_t =
826
101k
                            ps_dec->p_significant_coeff_flag_t;
827
101k
            p_significant_coeff_flag_t[0] = p_cabac_ctxt_table_t
828
101k
                            + SIG_COEFF_CTXT_CAT_0_OFFSET;
829
101k
            p_significant_coeff_flag_t[1] = p_cabac_ctxt_table_t
830
101k
                            + SIG_COEFF_CTXT_CAT_1_OFFSET;
831
101k
            p_significant_coeff_flag_t[2] = p_cabac_ctxt_table_t
832
101k
                            + SIG_COEFF_CTXT_CAT_2_OFFSET;
833
101k
            p_significant_coeff_flag_t[3] = p_cabac_ctxt_table_t
834
101k
                            + SIG_COEFF_CTXT_CAT_3_OFFSET;
835
101k
            p_significant_coeff_flag_t[4] = p_cabac_ctxt_table_t
836
101k
                            + SIG_COEFF_CTXT_CAT_4_OFFSET;
837
101k
            p_significant_coeff_flag_t[5] = p_cabac_ctxt_table_t
838
101k
                            + SIG_COEFF_CTXT_CAT_5_OFFSET;
839
840
101k
        }
841
101k
    }
842
101k
    return (u4_mbskip);
843
101k
}
844
845
/*****************************************************************************/
846
/*                                                                           */
847
/*  Function Name : ih264d_get_cabac_context_mbaff                                  */
848
/*                                                                           */
849
/*  Description   : Gets the current macroblock Cabac Context and sets the   */
850
/*                  top and left cabac context ptrs in CtxIncMbMap           */
851
/*                  1. For Coss field left neigbours it alters coded block   */
852
/*                     u4_flag , motion vectors, reference indices, cbp of      */
853
/*                     the left neigbours which increases the code i4_size      */
854
/*                  2. For Coss field top neigbours it alters motion         */
855
/*                     vectors reference indices of the top neigbours        */
856
/*                     which further increases the code i4_size                 */
857
/*                                                                           */
858
/*  Inputs        : 1. dec_struct_t                                             */
859
/*                  2. CurMbAddr used for Mbaff (only to see if curMB        */
860
/*                  is top or bottom)                                        */
861
/*                  3. uc_curMbFldDecFlag only for Mbaff                     */
862
/*                                                                           */
863
/*  Returns       : 0                                                        */
864
/*                                                                           */
865
/*  Issues        : code i4_size can be reduced if ui_CodedBlockFlag storage    */
866
/*                  structure in context is changed. This change however     */
867
/*                  would break the parseResidual4x4Cabac asm routine.       */
868
/*                                                                           */
869
/*  Revision History:                                                        */
870
/*                                                                           */
871
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
872
/*         18 06 2005   Jay                                                  */
873
/*                                                                           */
874
/*****************************************************************************/
875
UWORD32 ih264d_get_cabac_context_mbaff(dec_struct_t * ps_dec,
876
                                       dec_mb_info_t *ps_cur_mb_info,
877
                                       UWORD32 u4_mbskip)
878
101k
{
879
101k
    const UWORD8 u1_mb_ngbr_availablity = ps_dec->u1_mb_ngbr_availablity;
880
101k
    ctxt_inc_mb_info_t * const p_ctx_inc_mb_map = ps_dec->p_ctxt_inc_mb_map;
881
882
101k
    UWORD8 (*pu1_left_mv_ctxt_inc_2d)[4] = &ps_dec->pu1_left_mv_ctxt_inc[0];
883
101k
    WORD8 (*pi1_left_ref_idx_ctxt_inc) = ps_dec->pi1_left_ref_idx_ctxt_inc;
884
101k
    const UWORD8 u1_cur_mb_fld_flag = ps_cur_mb_info->u1_mb_field_decodingflag;
885
101k
    const UWORD8 u1_topmb = ps_cur_mb_info->u1_topmb;
886
101k
    const UWORD8 uc_botMb = 1 - ps_cur_mb_info->u1_topmb;
887
888
101k
    ctxt_inc_mb_info_t * ps_leftMB;
889
890
101k
    ps_dec->ps_curr_ctxt_mb_info = p_ctx_inc_mb_map + (ps_dec->u2_mbx << 1);
891
101k
    ps_dec->p_top_ctxt_mb_info = ps_dec->ps_curr_ctxt_mb_info;
892
893
101k
    if(u1_topmb)
894
50.8k
    {
895
50.8k
        pu1_left_mv_ctxt_inc_2d = ps_dec->u1_left_mv_ctxt_inc_arr[0];
896
50.8k
        pi1_left_ref_idx_ctxt_inc = &ps_dec->i1_left_ref_idx_ctx_inc_arr[0][0];
897
50.8k
        ps_dec->pu1_left_yuv_dc_csbp = &ps_dec->u1_yuv_dc_csbp_topmb;
898
50.8k
    }
899
50.5k
    else
900
50.5k
    {
901
        /* uc_botMb */
902
50.5k
        pu1_left_mv_ctxt_inc_2d = ps_dec->u1_left_mv_ctxt_inc_arr[1];
903
50.5k
        pi1_left_ref_idx_ctxt_inc = &ps_dec->i1_left_ref_idx_ctx_inc_arr[1][0];
904
50.5k
        ps_dec->pu1_left_yuv_dc_csbp = &ps_dec->u1_yuv_dc_csbp_bot_mb;
905
50.5k
        ps_dec->ps_curr_ctxt_mb_info += 1;
906
50.5k
    }
907
908
101k
    ps_dec->pu1_left_mv_ctxt_inc = pu1_left_mv_ctxt_inc_2d;
909
101k
    ps_dec->pi1_left_ref_idx_ctxt_inc = pi1_left_ref_idx_ctxt_inc;
910
911
101k
    if(u1_mb_ngbr_availablity & LEFT_MB_AVAILABLE_MASK)
912
94.9k
    {
913
94.9k
        const UWORD8 u1_left_mb_fld_flag = ps_cur_mb_info->ps_left_mb->u1_mb_fld;
914
915
94.9k
        ps_leftMB = ps_dec->ps_curr_ctxt_mb_info - 2;
916
94.9k
        if(u1_left_mb_fld_flag != u1_cur_mb_fld_flag)
917
17.2k
        {
918
17.2k
            ctxt_inc_mb_info_t *ps_tempLeft;
919
17.2k
            UWORD8 u1_cbp_t, u1_cbp_b;
920
17.2k
            UWORD8 u1_cr_cpb;
921
922
17.2k
            ps_leftMB -= uc_botMb;
923
17.2k
            ps_tempLeft = ps_dec->ps_left_mb_ctxt_info;
924
17.2k
            ps_tempLeft->u1_mb_type = ps_leftMB->u1_mb_type;
925
17.2k
            ps_tempLeft->u1_intra_chroma_pred_mode =
926
17.2k
                            ps_leftMB->u1_intra_chroma_pred_mode;
927
928
17.2k
            ps_tempLeft->u1_transform8x8_ctxt = ps_leftMB->u1_transform8x8_ctxt;
929
930
17.2k
            u1_cr_cpb = ps_leftMB->u1_cbp;
931
            /*****************************************************************/
932
            /* reform RefIdx, CBP, MV and CBF ctxInc taking care of A and A+1*/
933
            /*****************************************************************/
934
17.2k
            if(u1_cur_mb_fld_flag)
935
9.66k
            {
936
                /* current MB is a FLD and left a FRM */
937
9.66k
                UWORD8 (* const pu1_left_mv_ctxt_inc_2d_arr_top)[4] =
938
9.66k
                                ps_dec->u1_left_mv_ctxt_inc_arr[0];
939
9.66k
                UWORD8 (* const pu1_left_mv_ctxt_inc_2d_arr_bot)[4] =
940
9.66k
                                ps_dec->u1_left_mv_ctxt_inc_arr[1];
941
9.66k
                WORD8 (* const i1_left_ref_idx_ctxt_inc_arr_top) =
942
9.66k
                                &ps_dec->i1_left_ref_idx_ctx_inc_arr[0][0];
943
9.66k
                WORD8 (* const i1_left_ref_idx_ctxt_inc_arr_bot) =
944
9.66k
                                &ps_dec->i1_left_ref_idx_ctx_inc_arr[1][0];
945
946
9.66k
                u1_cbp_t = ps_leftMB->u1_cbp;
947
9.66k
                u1_cbp_b = (ps_leftMB + 1)->u1_cbp;
948
9.66k
                ps_tempLeft->u1_cbp = (u1_cbp_t & 0x02)
949
9.66k
                                | ((u1_cbp_b & 0x02) << 2);
950
951
                // set motionvectors as
952
                // 0T = 0T  0B = 0T
953
                // 1T = 2T  1B = 2T
954
                // 2T = 0B  2B = 0B
955
                // 3T = 2B  3B = 2B
956
9.66k
                if(u1_topmb)
957
4.84k
                {
958
                    /********************************************/
959
                    /*    Bottoms  DC CBF = Top DC CBF          */
960
                    /********************************************/
961
4.84k
                    ps_dec->u1_yuv_dc_csbp_bot_mb =
962
4.84k
                                    ps_dec->u1_yuv_dc_csbp_topmb;
963
964
4.84k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[3] =
965
4.84k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d_arr_bot[2];
966
4.84k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[1] =
967
4.84k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d_arr_top[2];
968
4.84k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[2] =
969
4.84k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d_arr_bot[0];
970
4.84k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[0] =
971
4.84k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d_arr_top[0];
972
973
4.84k
                    i1_left_ref_idx_ctxt_inc_arr_top[1] =
974
4.84k
                                    i1_left_ref_idx_ctxt_inc_arr_bot[0];
975
4.84k
                    i1_left_ref_idx_ctxt_inc_arr_top[3] =
976
4.84k
                                    i1_left_ref_idx_ctxt_inc_arr_bot[2];
977
978
4.84k
                    *(UWORD32 *)(i1_left_ref_idx_ctxt_inc_arr_bot) =
979
4.84k
                                    *(UWORD32 *)(i1_left_ref_idx_ctxt_inc_arr_top);
980
981
4.84k
                    memcpy(pu1_left_mv_ctxt_inc_2d_arr_bot,
982
4.84k
                           pu1_left_mv_ctxt_inc_2d_arr_top, 16);
983
4.84k
                }
984
985
9.66k
                {
986
9.66k
                    UWORD8 i;
987
48.3k
                    for(i = 0; i < 4; i++)
988
38.6k
                    {
989
38.6k
                        pu1_left_mv_ctxt_inc_2d[i][1] >>= 1;
990
38.6k
                        pu1_left_mv_ctxt_inc_2d[i][3] >>= 1;
991
38.6k
                    }
992
9.66k
                }
993
9.66k
            }
994
7.58k
            else
995
7.58k
            {
996
                /* current MB is a FRM and left FLD */
997
7.58k
                if(u1_topmb)
998
3.79k
                {
999
3.79k
                    u1_cbp_t = ps_leftMB->u1_cbp;
1000
3.79k
                    u1_cbp_t = (u1_cbp_t & 0x02);
1001
3.79k
                    ps_tempLeft->u1_cbp = (u1_cbp_t | (u1_cbp_t << 2));
1002
1003
                    /********************************************/
1004
                    /*    Bottoms  DC CBF = Top DC CBF          */
1005
                    /********************************************/
1006
3.79k
                    ps_dec->u1_yuv_dc_csbp_bot_mb =
1007
3.79k
                                    ps_dec->u1_yuv_dc_csbp_topmb;
1008
1009
                    // set motionvectors as
1010
                    // 3B = 2B = 3T
1011
                    // 1B = 0B = 2T
1012
                    // 3T = 2T = 1T
1013
                    // 1T = 0T = 0T
1014
1015
3.79k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[7] =
1016
3.79k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[3];
1017
3.79k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[6] =
1018
3.79k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[3];
1019
1020
3.79k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[5] =
1021
3.79k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[2];
1022
3.79k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[4] =
1023
3.79k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[2];
1024
1025
3.79k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[3] =
1026
3.79k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[1];
1027
3.79k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[2] =
1028
3.79k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[1];
1029
1030
3.79k
                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[1] =
1031
3.79k
                                    *(UWORD32 *)pu1_left_mv_ctxt_inc_2d[0];
1032
1033
3.79k
                    pi1_left_ref_idx_ctxt_inc[7] = (pi1_left_ref_idx_ctxt_inc[3]
1034
3.79k
                                    - 1);
1035
3.79k
                    pi1_left_ref_idx_ctxt_inc[6] = (pi1_left_ref_idx_ctxt_inc[3]
1036
3.79k
                                    - 1);
1037
1038
3.79k
                    pi1_left_ref_idx_ctxt_inc[5] = (pi1_left_ref_idx_ctxt_inc[1]
1039
3.79k
                                    - 1);
1040
3.79k
                    pi1_left_ref_idx_ctxt_inc[4] = (pi1_left_ref_idx_ctxt_inc[1]
1041
3.79k
                                    - 1);
1042
1043
3.79k
                    pi1_left_ref_idx_ctxt_inc[3] = (pi1_left_ref_idx_ctxt_inc[2]
1044
3.79k
                                    - 1);
1045
3.79k
                    pi1_left_ref_idx_ctxt_inc[2] = (pi1_left_ref_idx_ctxt_inc[2]
1046
3.79k
                                    - 1);
1047
1048
3.79k
                    pi1_left_ref_idx_ctxt_inc[1] = (pi1_left_ref_idx_ctxt_inc[0]
1049
3.79k
                                    - 1);
1050
3.79k
                    pi1_left_ref_idx_ctxt_inc[0] = (pi1_left_ref_idx_ctxt_inc[0]
1051
3.79k
                                    - 1);
1052
3.79k
                }
1053
3.78k
                else
1054
3.78k
                {
1055
3.78k
                    u1_cbp_t = ps_leftMB->u1_cbp;
1056
3.78k
                    u1_cbp_t = (u1_cbp_t & 0x08);
1057
3.78k
                    ps_tempLeft->u1_cbp = (u1_cbp_t | (u1_cbp_t >> 2));
1058
3.78k
                }
1059
1060
7.58k
                {
1061
7.58k
                    UWORD8 i;
1062
37.9k
                    for(i = 0; i < 4; i++)
1063
30.3k
                    {
1064
30.3k
                        pu1_left_mv_ctxt_inc_2d[i][1] <<= 1;
1065
30.3k
                        pu1_left_mv_ctxt_inc_2d[i][3] <<= 1;
1066
30.3k
                    }
1067
7.58k
                }
1068
1069
7.58k
            }
1070
1071
17.2k
            ps_tempLeft->u1_cbp = ps_tempLeft->u1_cbp + ((u1_cr_cpb >> 4) << 4);
1072
17.2k
            ps_leftMB = ps_tempLeft;
1073
17.2k
        }
1074
1075
94.9k
        ps_dec->p_left_ctxt_mb_info = ps_leftMB;
1076
94.9k
    }
1077
6.36k
    else
1078
6.36k
    {
1079
6.36k
        ps_dec->p_left_ctxt_mb_info = p_ctx_inc_mb_map - 1;
1080
6.36k
        if(!u4_mbskip)
1081
2.77k
        {
1082
2.77k
            *(ps_dec->pu1_left_yuv_dc_csbp) = 0;
1083
1084
2.77k
            MEMSET_16BYTES(&pu1_left_mv_ctxt_inc_2d[0][0], 0);
1085
2.77k
            *(UWORD32 *)pi1_left_ref_idx_ctxt_inc = 0;
1086
2.77k
        }
1087
6.36k
    }
1088
1089
    /*************************************************************************/
1090
    /*                Now get the top context mb info                        */
1091
    /*************************************************************************/
1092
101k
    {
1093
101k
        UWORD8 (*u1_top_mv_ctxt_inc_arr_2d)[4] =
1094
101k
                        ps_dec->ps_curr_ctxt_mb_info->u1_mv;
1095
101k
        WORD8 (*pi1_top_ref_idx_ctxt_inc) =
1096
101k
                        ps_dec->ps_curr_ctxt_mb_info->i1_ref_idx;
1097
101k
        UWORD8 uc_topMbFldDecFlag = ps_cur_mb_info->ps_top_mb->u1_mb_fld;
1098
1099
101k
        if(u1_mb_ngbr_availablity & TOP_MB_AVAILABLE_MASK)
1100
94.9k
        {
1101
94.9k
            if(ps_cur_mb_info->i1_offset)
1102
51.0k
                ps_dec->p_top_ctxt_mb_info += 1;
1103
1104
94.9k
            if(!u4_mbskip)
1105
62.2k
            {
1106
62.2k
                memcpy(u1_top_mv_ctxt_inc_arr_2d,
1107
62.2k
                       &ps_dec->p_top_ctxt_mb_info->u1_mv, 16);
1108
62.2k
                memcpy(pi1_top_ref_idx_ctxt_inc,
1109
62.2k
                       &ps_dec->p_top_ctxt_mb_info->i1_ref_idx, 4);
1110
62.2k
                if(uc_topMbFldDecFlag ^ u1_cur_mb_fld_flag)
1111
11.4k
                {
1112
11.4k
                    UWORD8 i;
1113
11.4k
                    if(u1_cur_mb_fld_flag)
1114
8.19k
                    {
1115
40.9k
                        for(i = 0; i < 4; i++)
1116
32.7k
                        {
1117
32.7k
                            u1_top_mv_ctxt_inc_arr_2d[i][1] >>= 1;
1118
32.7k
                            u1_top_mv_ctxt_inc_arr_2d[i][3] >>= 1;
1119
32.7k
                        }
1120
8.19k
                    }
1121
3.20k
                    else
1122
3.20k
                    {
1123
16.0k
                        for(i = 0; i < 4; i++)
1124
12.8k
                        {
1125
12.8k
                            u1_top_mv_ctxt_inc_arr_2d[i][1] <<= 1;
1126
12.8k
                            u1_top_mv_ctxt_inc_arr_2d[i][3] <<= 1;
1127
12.8k
                            pi1_top_ref_idx_ctxt_inc[i] -= 1;
1128
12.8k
                        }
1129
3.20k
                    }
1130
11.4k
                }
1131
62.2k
            }
1132
94.9k
        }
1133
6.40k
        else
1134
6.40k
        {
1135
6.40k
            ps_dec->p_top_ctxt_mb_info = p_ctx_inc_mb_map - 1;
1136
6.40k
            if(!u4_mbskip)
1137
3.51k
            {
1138
1139
3.51k
                MEMSET_16BYTES(&u1_top_mv_ctxt_inc_arr_2d[0][0], 0);
1140
3.51k
                memset(pi1_top_ref_idx_ctxt_inc, 0, 4);
1141
3.51k
            }
1142
6.40k
        }
1143
101k
    }
1144
1145
101k
    return OK;
1146
101k
}
1147
1148
/*****************************************************************************/
1149
/*                                                                           */
1150
/*  Function Name : ih264d_update_mbaff_left_nnz                                    */
1151
/*                                                                           */
1152
/*  Description   : This function updates the left luma and chroma nnz for   */
1153
/*                  mbaff cases.                                             */
1154
/*                                                                           */
1155
/*  Inputs        : <What inputs does the function take?>                    */
1156
/*  Globals       : <Does it use any global variables?>                      */
1157
/*  Processing    : <Describe how the function operates - include algorithm  */
1158
/*                  description>                                             */
1159
/*  Outputs       : <What does the function produce?>                        */
1160
/*  Returns       : <What does the function return?>                         */
1161
/*                                                                           */
1162
/*  Issues        : <List any issues or problems with this function>         */
1163
/*                                                                           */
1164
/*  Revision History:                                                        */
1165
/*                                                                           */
1166
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
1167
/*         13 07 2002   Ittiam          Draft                                */
1168
/*                                                                           */
1169
/*****************************************************************************/
1170
void ih264d_update_mbaff_left_nnz(dec_struct_t * ps_dec,
1171
                                  dec_mb_info_t * ps_cur_mb_info)
1172
1.50M
{
1173
1.50M
    UWORD32 *pu4_buf;
1174
1.50M
    UWORD8 *pu1_buf;
1175
1.50M
    if(ps_cur_mb_info->u1_topmb)
1176
755k
    {
1177
755k
        pu1_buf = ps_dec->pu1_left_nnz_y;
1178
755k
        pu4_buf = (UWORD32 *)pu1_buf;
1179
755k
        ps_dec->u4_n_left_temp_y = *pu4_buf;
1180
1181
755k
        pu1_buf = ps_dec->pu1_left_nnz_uv;
1182
755k
        pu4_buf = (UWORD32 *)pu1_buf;
1183
755k
        ps_dec->u4_n_left_temp_uv = *pu4_buf;
1184
755k
    }
1185
754k
    else
1186
754k
    {
1187
1188
754k
        ps_dec->u4_n_leftY[0] = ps_dec->u4_n_left_temp_y;
1189
754k
        pu1_buf = ps_dec->pu1_left_nnz_y;
1190
754k
        pu4_buf = (UWORD32 *)pu1_buf;
1191
754k
        ps_dec->u4_n_leftY[1] = *pu4_buf;
1192
754k
        ps_dec->u4_n_left_cr[0] = ps_dec->u4_n_left_temp_uv;
1193
754k
        pu1_buf = ps_dec->pu1_left_nnz_uv;
1194
754k
        pu4_buf = (UWORD32 *)pu1_buf;
1195
754k
        ps_dec->u4_n_left_cr[1] = *pu4_buf;
1196
1197
754k
    }
1198
1.50M
}
1199
1200
/*!
1201
 **************************************************************************
1202
 * \if Function name : ih264d_get_mbaff_neighbours \endif
1203
 *
1204
 * \brief
1205
 *    Gets the neighbors for the current MB if it is of type MB-AFF
1206
 *  frame.
1207
 *
1208
 * \return
1209
 *    None
1210
 *
1211
 **************************************************************************
1212
 */
1213
void ih264d_get_mbaff_neighbours(dec_struct_t * ps_dec,
1214
                                 dec_mb_info_t * ps_cur_mb_info,
1215
                                 UWORD8 uc_curMbFldDecFlag)
1216
1.51M
{
1217
1218
1.51M
    mb_neigbour_params_t *ps_left_mb;
1219
1.51M
    mb_neigbour_params_t *ps_top_mb;
1220
1.51M
    mb_neigbour_params_t *ps_top_right_mb = NULL;
1221
1.51M
    mb_neigbour_params_t *ps_curmb;
1222
1.51M
    const UWORD8 u1_topmb = ps_cur_mb_info->u1_topmb;
1223
1.51M
    const UWORD8 uc_botMb = 1 - u1_topmb;
1224
1.51M
    const UWORD32 u4_mb_x = ps_cur_mb_info->u2_mbx;
1225
1226
    /* Current MbParams location in top row buffer */
1227
1.51M
    ps_curmb = ps_dec->ps_cur_mb_row + (u4_mb_x << 1) + uc_botMb;
1228
1.51M
    ps_left_mb = ps_curmb - 2;
1229
    /* point to A if top else A+1 */
1230
1.51M
    if(uc_botMb && (ps_left_mb->u1_mb_fld != uc_curMbFldDecFlag))
1231
12.3k
    {
1232
        /* move from A + 1 to A */
1233
12.3k
        ps_left_mb--;
1234
12.3k
    }
1235
1.51M
    ps_cur_mb_info->i1_offset = 0;
1236
1.51M
    if((uc_curMbFldDecFlag == 0) && uc_botMb)
1237
725k
    {
1238
725k
        mb_neigbour_params_t *ps_topleft_mb;
1239
        /* CurMbAddr - 1 */
1240
725k
        ps_top_mb = ps_curmb - 1;
1241
1242
        /* Mark Top right Not available */
1243
        /* point to A */
1244
725k
        ps_topleft_mb = ps_curmb - 3;
1245
1246
725k
        if(ps_topleft_mb->u1_mb_fld)
1247
5.90k
        {
1248
            /* point to A + 1 */
1249
5.90k
            ps_topleft_mb++;
1250
5.90k
        }
1251
725k
        ps_cur_mb_info->u1_topleft_mb_fld = ps_topleft_mb->u1_mb_fld;
1252
725k
        ps_cur_mb_info->u1_topleft_mbtype = ps_topleft_mb->u1_mb_type;
1253
725k
    }
1254
785k
    else
1255
785k
    {
1256
        /* Top = B + 1 */
1257
785k
        ps_top_mb = ps_dec->ps_top_mb_row + (u4_mb_x << 1) + 1;
1258
785k
        ps_top_right_mb = ps_top_mb + 2;
1259
785k
        ps_cur_mb_info->i1_offset = 4;
1260
        /* TopRight =  C + 1 */
1261
1262
        /* TopLeft = D+1 */
1263
785k
        ps_cur_mb_info->u1_topleft_mb_fld = ps_dec->u1_topleft_mb_fld_bot;
1264
785k
        ps_cur_mb_info->u1_topleft_mbtype = ps_dec->u1_topleft_mbtype_bot;
1265
1266
785k
        if(uc_curMbFldDecFlag && u1_topmb)
1267
30.0k
        {
1268
30.0k
            if(ps_top_mb->u1_mb_fld)
1269
19.1k
            {
1270
                /* MbAddrB */
1271
19.1k
                ps_top_mb--;
1272
19.1k
                ps_cur_mb_info->i1_offset = 0;
1273
19.1k
            }
1274
            /* If topright is field then point to C */
1275
30.0k
            ps_top_right_mb -= ps_top_right_mb->u1_mb_fld ? 1 : 0;
1276
30.0k
            if(ps_cur_mb_info->u1_topleft_mb_fld)
1277
18.2k
            {
1278
                /* TopLeft = D */
1279
18.2k
                ps_cur_mb_info->u1_topleft_mb_fld = ps_dec->u1_topleft_mb_fld;
1280
18.2k
                ps_cur_mb_info->u1_topleft_mbtype = ps_dec->u1_topleft_mbtype;
1281
18.2k
            }
1282
30.0k
        }
1283
785k
    }
1284
1.51M
    if(u1_topmb)
1285
755k
    {
1286
        /* Update the parameters of topleftmb*/
1287
755k
        ps_dec->u1_topleft_mb_fld = ps_top_mb->u1_mb_fld;
1288
755k
        ps_dec->u1_topleft_mbtype = ps_top_mb->u1_mb_type;
1289
        /* Set invscan and dequantMatrixScan*/
1290
755k
        if(uc_curMbFldDecFlag)
1291
30.0k
        {
1292
30.0k
            ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan_fld;
1293
30.0k
        }
1294
725k
        else
1295
725k
        {
1296
725k
            ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan;
1297
725k
        }
1298
755k
        ps_dec->pu2_quant_scale_y =
1299
755k
                        gau2_ih264_iquant_scale_4x4[ps_dec->u1_qp_y_rem6];
1300
755k
        ps_dec->pu2_quant_scale_u =
1301
755k
                        gau2_ih264_iquant_scale_4x4[ps_dec->u1_qp_u_rem6];
1302
755k
        ps_dec->pu2_quant_scale_v =
1303
755k
                        gau2_ih264_iquant_scale_4x4[ps_dec->u1_qp_v_rem6];
1304
1305
755k
    }
1306
754k
    else
1307
754k
    {
1308
        /* Update the parameters of topleftmb*/
1309
754k
        mb_neigbour_params_t *ps_top_mb_temp = ps_dec->ps_top_mb_row
1310
754k
                        + (u4_mb_x << 1) + 1;
1311
754k
        ps_dec->u1_topleft_mb_fld_bot = ps_top_mb_temp->u1_mb_fld;
1312
754k
        ps_dec->u1_topleft_mbtype_bot = ps_top_mb_temp->u1_mb_type;
1313
754k
    }
1314
1315
1.51M
    ps_cur_mb_info->ps_left_mb = ps_left_mb;
1316
1.51M
    ps_cur_mb_info->ps_top_mb = ps_top_mb;
1317
1.51M
    ps_cur_mb_info->ps_top_right_mb = ps_top_right_mb;
1318
1.51M
    ps_cur_mb_info->ps_curmb = ps_curmb;
1319
1.51M
    ps_curmb->u1_mb_fld = uc_curMbFldDecFlag;
1320
1321
1.51M
    {
1322
        /* Form Left NNZ */
1323
1.51M
        UWORD8 u1_is_left_mb_fld = ps_left_mb->u1_mb_fld;
1324
1.51M
        UWORD8 *pu1_left_mb_pair_nnz_y = (UWORD8 *)&ps_dec->u4_n_leftY[0];
1325
1.51M
        UWORD8 *pu1_left_mb_pair_nnz_uv = (UWORD8 *)&ps_dec->u4_n_left_cr[0];
1326
1.51M
        UWORD8 *pu1_left_nnz_y = ps_dec->pu1_left_nnz_y;
1327
1.51M
        UWORD8 *pu1_left_nnz_uv = ps_dec->pu1_left_nnz_uv;
1328
1329
1.51M
        if(uc_curMbFldDecFlag == u1_is_left_mb_fld)
1330
1.48M
        {
1331
1.48M
            *(UWORD32 *)pu1_left_nnz_y = *(UWORD32 *)(pu1_left_mb_pair_nnz_y
1332
1.48M
                            + (uc_botMb << 2));
1333
1.48M
            *(UWORD32 *)pu1_left_nnz_uv = *(UWORD32 *)(pu1_left_mb_pair_nnz_uv
1334
1.48M
                            + (uc_botMb << 2));
1335
1.48M
        }
1336
24.9k
        else if((uc_curMbFldDecFlag == 0) && u1_topmb && u1_is_left_mb_fld)
1337
5.91k
        {
1338
            /* 0 0 1 1 of u4_n_leftY[0], 0 0 2 2 of u4_n_left_cr[0] */
1339
5.91k
            pu1_left_nnz_y[0] = pu1_left_nnz_y[1] = pu1_left_mb_pair_nnz_y[0];
1340
5.91k
            pu1_left_nnz_y[2] = pu1_left_nnz_y[3] = pu1_left_mb_pair_nnz_y[1];
1341
5.91k
            pu1_left_nnz_uv[0] = pu1_left_nnz_uv[1] =
1342
5.91k
                            pu1_left_mb_pair_nnz_uv[0];
1343
5.91k
            pu1_left_nnz_uv[2] = pu1_left_nnz_uv[3] =
1344
5.91k
                            pu1_left_mb_pair_nnz_uv[2];
1345
5.91k
        }
1346
18.9k
        else if((uc_curMbFldDecFlag == 0) && uc_botMb && u1_is_left_mb_fld)
1347
5.90k
        {
1348
            /* 2 2 3 3 of u4_n_leftY[0] , 1 1 3 3 of u4_n_left_cr[0] */
1349
5.90k
            pu1_left_nnz_y[0] = pu1_left_nnz_y[1] = pu1_left_mb_pair_nnz_y[2];
1350
5.90k
            pu1_left_nnz_y[2] = pu1_left_nnz_y[3] = pu1_left_mb_pair_nnz_y[3];
1351
5.90k
            pu1_left_nnz_uv[0] = pu1_left_nnz_uv[1] =
1352
5.90k
                            pu1_left_mb_pair_nnz_uv[1];
1353
5.90k
            pu1_left_nnz_uv[2] = pu1_left_nnz_uv[3] =
1354
5.90k
                            pu1_left_mb_pair_nnz_uv[3];
1355
5.90k
        }
1356
13.0k
        else
1357
13.0k
        {
1358
            /* 0 2 0 2 of u4_n_leftY[0], u4_n_leftY[1] */
1359
13.0k
            pu1_left_nnz_y[0] = pu1_left_mb_pair_nnz_y[0];
1360
13.0k
            pu1_left_nnz_y[1] = pu1_left_mb_pair_nnz_y[2];
1361
13.0k
            pu1_left_nnz_y[2] = pu1_left_mb_pair_nnz_y[4 + 0];
1362
13.0k
            pu1_left_nnz_y[3] = pu1_left_mb_pair_nnz_y[4 + 2];
1363
1364
            /* 0 of u4_n_left_cr[0] and 0 u4_n_left_cr[1]
1365
             2 of u4_n_left_cr[0] and 2 u4_n_left_cr[1] */
1366
13.0k
            pu1_left_nnz_uv[0] = pu1_left_mb_pair_nnz_uv[0];
1367
13.0k
            pu1_left_nnz_uv[1] = pu1_left_mb_pair_nnz_uv[4 + 0];
1368
13.0k
            pu1_left_nnz_uv[2] = pu1_left_mb_pair_nnz_uv[2];
1369
13.0k
            pu1_left_nnz_uv[3] = pu1_left_mb_pair_nnz_uv[4 + 2];
1370
13.0k
        }
1371
1.51M
    }
1372
1.51M
}
1373
1374
/*
1375
 **************************************************************************
1376
 * \if Function name : ih264d_transfer_mb_group_data \endif
1377
 *
1378
 * \brief
1379
 *     Transfer the Following things
1380
 *     N-Mb DeblkParams Data    ( To Ext DeblkParams Buffer )
1381
 *     N-Mb Recon Data          ( To Ext Frame Buffer )
1382
 *     N-Mb Intrapredline Data  ( Updated Internally)
1383
 *     N-Mb MV Data             ( To Ext MV Buffer )
1384
 *     N-Mb MVTop/TopRight Data ( To Int MV Top Scratch Buffers)
1385
 *
1386
 * \return
1387
 *    None
1388
 *
1389
 **************************************************************************
1390
 */
1391
void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
1392
                                   const UWORD32 u4_num_mbs,
1393
                                   const UWORD32 u4_end_of_row, /* Cur n-Mb End of Row Flag */
1394
                                   const UWORD32 u4_end_of_row_next /* Next n-Mb End of Row Flag */
1395
                                   )
1396
2.74M
{
1397
2.74M
    dec_mb_info_t *ps_cur_mb_info = ps_dec->ps_nmb_info;
1398
2.74M
    tfr_ctxt_t *ps_trns_addr = &ps_dec->s_tran_addrecon;
1399
2.74M
    UWORD16 u2_mb_y;
1400
2.74M
    UWORD32 y_offset;
1401
2.74M
    UWORD32 u4_frame_stride;
1402
2.74M
    mb_neigbour_params_t *ps_temp;
1403
2.74M
    const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
1404
2.74M
    UNUSED(u4_end_of_row_next);
1405
1406
2.74M
    ps_trns_addr->pu1_dest_y += ps_trns_addr->u4_inc_y[u4_end_of_row];
1407
2.74M
    ps_trns_addr->pu1_dest_u += ps_trns_addr->u4_inc_uv[u4_end_of_row];
1408
2.74M
    ps_trns_addr->pu1_dest_v += ps_trns_addr->u4_inc_uv[u4_end_of_row];
1409
1410
    /* Swap top and current pointers */
1411
2.74M
    if(u4_end_of_row)
1412
2.68M
    {
1413
1414
2.68M
        if(ps_dec->u1_separate_parse)
1415
1.38M
        {
1416
1.38M
            u2_mb_y = ps_dec->i2_dec_thread_mb_y;
1417
1.38M
        }
1418
1.30M
        else
1419
1.30M
        {
1420
1.30M
            ps_temp = ps_dec->ps_cur_mb_row;
1421
1.30M
            ps_dec->ps_cur_mb_row = ps_dec->ps_top_mb_row;
1422
1.30M
            ps_dec->ps_top_mb_row = ps_temp;
1423
1424
1.30M
            u2_mb_y = ps_dec->u2_mby + (1 + u1_mbaff);
1425
1.30M
        }
1426
1427
2.68M
        u4_frame_stride = ps_dec->u2_frm_wd_y
1428
2.68M
                        << ps_dec->ps_cur_slice->u1_field_pic_flag;
1429
2.68M
        y_offset = (u2_mb_y * u4_frame_stride) << 4;
1430
2.68M
        ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + y_offset;
1431
1432
2.68M
        u4_frame_stride = ps_dec->u2_frm_wd_uv
1433
2.68M
                        << ps_dec->ps_cur_slice->u1_field_pic_flag;
1434
2.68M
        y_offset = (u2_mb_y * u4_frame_stride) << 3;
1435
2.68M
        ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + y_offset;
1436
2.68M
        ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + y_offset;
1437
1438
2.68M
        ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1439
2.68M
        ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1440
2.68M
        ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1441
2.68M
    }
1442
1443
    /*
1444
     * The Slice boundary is also a valid condition to transfer. So recalculate
1445
     * the Left increment, in case the number of MBs is lesser than the
1446
     * N MB value. u4_num_mbs will be equal to N of N MB if the entire N Mb is
1447
     * decoded.
1448
     */
1449
2.74M
    ps_dec->s_tran_addrecon.u2_mv_left_inc = ((WORD16)(u4_num_mbs >> u1_mbaff) - 1)
1450
2.74M
                    << (4 + u1_mbaff);
1451
2.74M
    ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (WORD16)(u4_num_mbs << 2) - 1
1452
2.74M
                    - (u1_mbaff << 2);
1453
1454
2.74M
    if(ps_dec->u1_separate_parse == 0)
1455
1.33M
    {
1456
        /* reassign left MV and cur MV pointers */
1457
1.33M
        ps_dec->ps_mv_left = ps_dec->ps_mv_cur
1458
1.33M
                        + ps_dec->s_tran_addrecon.u2_mv_left_inc;
1459
1460
1.33M
        ps_dec->ps_mv_cur += (u4_num_mbs << 4);
1461
1.33M
    }
1462
1463
    /* Increment deblock parameters pointer in external memory */
1464
1465
2.74M
    if(ps_dec->u1_separate_parse == 0)
1466
1.33M
    {
1467
1.33M
        ps_dec->ps_deblk_mbn += u4_num_mbs;
1468
1.33M
    }
1469
1470
2.74M
}
1471
1472
/*
1473
 **************************************************************************
1474
 * \if Function name : ih264d_populate_mb_info_map \endif
1475
 *
1476
 * \brief
1477
 *     Populate mb info values for mbtype and qp map at 8x8 level for each MB
1478
 *
1479
 * \return
1480
 *    void
1481
 *
1482
 **************************************************************************
1483
 */
1484
void ih264d_populate_mb_info_map(dec_struct_t *ps_dec, dec_mb_info_t *ps_cur_mb_info,
1485
                                 UWORD16 u2_blk_x, UWORD16 u2_blk_y, UWORD8 u1_qp_val)
1486
0
{
1487
0
    UWORD16 stride = ps_dec->u2_frm_wd_in_mbs << 1;
1488
0
    UWORD8 *pu1_qp_map = ps_dec->as_buf_id_info_map[ps_dec->u1_pic_buf_id].pu1_qp_map;
1489
0
    UWORD8 *pu1_mb_type_map = ps_dec->as_buf_id_info_map[ps_dec->u1_pic_buf_id].pu1_mb_type_map;
1490
1491
0
    UWORD8 cur_mb_type = ps_cur_mb_info->u1_mb_type;
1492
0
    UWORD8 mb_is_inter =
1493
0
        (cur_mb_type == P_MB || cur_mb_type == B_MB || cur_mb_type == SP_MB);
1494
0
    UWORD8 mb_type = mb_is_inter ? BLOCK_TYPE_INTER_MB : BLOCK_TYPE_INTRA_MB;
1495
0
    if(cur_mb_type == MB_SKIP) mb_type = BLOCK_TYPE_SKIP_MB;
1496
1497
    // populate qp_map, mb_type_map for mbx, mby
1498
    // since we store values at 8x8 level, duplicate values for blocks while storing in map
1499
0
    if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
1500
0
    {
1501
0
        UWORD8 bot_mb = ps_cur_mb_info->u1_topmb ? 0 : 1;
1502
0
        if(ps_cur_mb_info->u1_mb_field_decodingflag)
1503
0
        {
1504
0
            pu1_qp_map[u2_blk_x +     stride * ( u2_blk_y +      bot_mb)] =
1505
0
            pu1_qp_map[u2_blk_x + 1 + stride * ( u2_blk_y +      bot_mb)] =
1506
0
            pu1_qp_map[u2_blk_x +     stride * ((u2_blk_y + 2) + bot_mb)] =
1507
0
            pu1_qp_map[u2_blk_x + 1 + stride * ((u2_blk_y + 2) + bot_mb)] =
1508
0
                u1_qp_val;
1509
1510
0
            pu1_mb_type_map[u2_blk_x +     stride * ( u2_blk_y +      bot_mb)] =
1511
0
            pu1_mb_type_map[u2_blk_x + 1 + stride * ( u2_blk_y +      bot_mb)] =
1512
0
            pu1_mb_type_map[u2_blk_x +     stride * ((u2_blk_y + 2) + bot_mb)] =
1513
0
            pu1_mb_type_map[u2_blk_x + 1 + stride * ((u2_blk_y + 2) + bot_mb)] =
1514
0
                mb_type;
1515
0
        }
1516
0
        else
1517
0
        {
1518
0
            pu1_qp_map[u2_blk_x +     stride * ( u2_blk_y +      (2 * bot_mb))] =
1519
0
            pu1_qp_map[u2_blk_x + 1 + stride * ( u2_blk_y +      (2 * bot_mb))] =
1520
0
            pu1_qp_map[u2_blk_x +     stride * ((u2_blk_y + 1) + (2 * bot_mb))] =
1521
0
            pu1_qp_map[u2_blk_x + 1 + stride * ((u2_blk_y + 1) + (2 * bot_mb))] =
1522
0
                u1_qp_val;
1523
1524
0
            pu1_mb_type_map[u2_blk_x +     stride * ( u2_blk_y +      (2 * bot_mb))] =
1525
0
            pu1_mb_type_map[u2_blk_x + 1 + stride * ( u2_blk_y +      (2 * bot_mb))] =
1526
0
            pu1_mb_type_map[u2_blk_x +     stride * ((u2_blk_y + 1) + (2 * bot_mb))] =
1527
0
            pu1_mb_type_map[u2_blk_x + 1 + stride * ((u2_blk_y + 1) + (2 * bot_mb))] =
1528
0
                mb_type;
1529
0
        }
1530
0
    }
1531
0
    else
1532
0
    {
1533
0
        if(ps_dec->ps_cur_slice->u1_field_pic_flag)
1534
0
        {
1535
0
            UWORD8 bot_mb = ps_dec->ps_cur_slice->u1_bottom_field_flag;
1536
0
            pu1_qp_map[u2_blk_x +     stride * (2 *  u2_blk_y +      bot_mb)] =
1537
0
            pu1_qp_map[u2_blk_x + 1 + stride * (2 *  u2_blk_y +      bot_mb)] =
1538
0
            pu1_qp_map[u2_blk_x +     stride * (2 * (u2_blk_y + 1) + bot_mb)] =
1539
0
            pu1_qp_map[u2_blk_x + 1 + stride * (2 * (u2_blk_y + 1) + bot_mb)] =
1540
0
                u1_qp_val;
1541
1542
0
            pu1_mb_type_map[u2_blk_x +     stride * (2 *  u2_blk_y +      bot_mb)] =
1543
0
            pu1_mb_type_map[u2_blk_x + 1 + stride * (2 *  u2_blk_y +      bot_mb)] =
1544
0
            pu1_mb_type_map[u2_blk_x +     stride * (2 * (u2_blk_y + 1) + bot_mb)] =
1545
0
            pu1_mb_type_map[u2_blk_x + 1 + stride * (2 * (u2_blk_y + 1) + bot_mb)] =
1546
0
                mb_type;
1547
0
        }
1548
0
        else
1549
0
        {
1550
0
            pu1_qp_map[u2_blk_x +     stride *  u2_blk_y     ] =
1551
0
            pu1_qp_map[u2_blk_x + 1 + stride *  u2_blk_y     ] =
1552
0
            pu1_qp_map[u2_blk_x +     stride * (u2_blk_y + 1)] =
1553
0
            pu1_qp_map[u2_blk_x + 1 + stride * (u2_blk_y + 1)] =
1554
0
                u1_qp_val;
1555
1556
0
            pu1_mb_type_map[u2_blk_x +     stride *  u2_blk_y     ] =
1557
0
            pu1_mb_type_map[u2_blk_x + 1 + stride *  u2_blk_y     ] =
1558
0
            pu1_mb_type_map[u2_blk_x +     stride * (u2_blk_y + 1)] =
1559
0
            pu1_mb_type_map[u2_blk_x + 1 + stride * (u2_blk_y + 1)] =
1560
0
                mb_type;
1561
0
        }
1562
0
    }
1563
0
}