Coverage Report

Created: 2026-06-10 07:07

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libavc/decoder/ih264d_process_bslice.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_process_bslice.c
23
 *
24
 * \brief
25
 *    Contains routines that decode B slice type
26
 *
27
 * Detailed_description
28
 *
29
 * \date
30
 *    21/12/2002
31
 *
32
 * \author  NS
33
 **************************************************************************
34
 */
35
#include "ih264_typedefs.h"
36
#include "ih264_macros.h"
37
#include "ih264_platform_macros.h"
38
39
#include <string.h>
40
#include "ih264d_structs.h"
41
#include "ih264d_bitstrm.h"
42
#include "ih264d_parse_cavlc.h"
43
#include "ih264d_mb_utils.h"
44
#include "ih264d_mvpred.h"
45
#include "ih264d_inter_pred.h"
46
#include "ih264d_process_pslice.h"
47
#include "ih264d_error_handler.h"
48
#include "ih264d_tables.h"
49
#include "ih264d_parse_slice.h"
50
#include "ih264d_process_pslice.h"
51
#include "ih264d_process_bslice.h"
52
#include "ih264d_tables.h"
53
#include "ih264d_parse_islice.h"
54
#include "ih264d_mvpred.h"
55
56
void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
57
//UWORD32 g_hits = 0;
58
//UWORD32 g_miss = 0;
59
/*!
60
 **************************************************************************
61
 * \if Function name : ih264d_decode_spatial_direct \endif
62
 *
63
 * \brief
64
 *    Decodes spatial direct mode.
65
 *
66
 * \return
67
 *    None.
68
 *    Arunoday T
69
 **************************************************************************
70
 */
71
WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
72
                                    UWORD8 u1_wd_x,
73
                                    dec_mb_info_t * ps_cur_mb_info,
74
                                    UWORD32 u4_mb_num)
75
1.66M
{
76
1.66M
    mv_pred_t s_mv_pred, *ps_mv;
77
1.66M
    UWORD32 u4_sub_mb_num;
78
1.66M
    UWORD8 u1_col_zero_flag, u1_direct_zero_pred_flag = 0;
79
1.66M
    UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
80
1.66M
    mv_pred_t *ps_mv_ntop_start;
81
1.66M
    mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
82
1.66M
    UWORD8 partition_size, sub_partition, u1_mb_partw, u1_mb_parth;
83
1.66M
    UWORD8 i;
84
1.66M
    WORD8 i1_pred, i1_ref_frame0, i1_ref_frame1;
85
1.66M
    struct pic_buffer_t *ps_ref_frame = NULL, *ps_col_pic, *ps_pic_buff0 = NULL,
86
1.66M
                    *ps_pic_buff1 = NULL;
87
88
1.66M
    UWORD8 u1_zero_pred_cond_f, u1_zero_pred_cond_b;
89
1.66M
    WORD16 i2_def_mv[2], i2_spat_pred_mv[4], *pi2_final_mv0, *pi2_final_mv1;
90
1.66M
    UWORD16 ui2_mask_fwd = 0, ui2_mask_bwd = 0, u2_mask = 0;
91
1.66M
    UWORD32 *pui32_weight_ofsts = NULL;
92
1.66M
    directmv_t s_mvdirect;
93
1.66M
    UWORD8 u1_colz;
94
1.66M
    UWORD8 u1_final_ref_idx = 0;
95
1.66M
    const UWORD8 *pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
96
1.66M
    const UWORD8 *pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw;
97
1.66M
    const UWORD16 sub_mask_table[] =
98
1.66M
        { 0x33, 0x3, 0x11, 0x1 };
99
1.66M
    const UWORD16 mask_table[] =
100
1.66M
        { 0xffff, /*16x16 NA */
101
1.66M
          0xff, /* 16x8*/
102
1.66M
          0x3333, /* 8x16*/
103
1.66M
          0x33 };/* 8x8*/
104
1.66M
    mv_pred_t s_temp_mv_pred;
105
1.66M
    WORD32 ret = 0;
106
107
    /* CHANGED CODE */
108
1.66M
    ps_mv_ntop_start = ps_dec->ps_mv_cur + (u4_mb_num << 4)
109
1.66M
                    - (ps_dec->u2_frm_wd_in_mbs << (4 + u1_mbaff)) + 12;
110
111
    /* assign default values for MotionVector as zero */
112
1.66M
    i2_def_mv[0] = 0;
113
1.66M
    i2_def_mv[1] = 0;
114
115
1.66M
    u1_direct_zero_pred_flag = ps_dec->pf_mvpred(ps_dec, ps_cur_mb_info, ps_mv_nmb_start,
116
1.66M
                                              ps_mv_ntop_start, &s_mv_pred, 0, 4,
117
1.66M
                                              0, 1, B_DIRECT_SPATIAL);
118
119
1.66M
    i2_spat_pred_mv[0] = s_mv_pred.i2_mv[0];
120
1.66M
    i2_spat_pred_mv[1] = s_mv_pred.i2_mv[1];
121
1.66M
    i2_spat_pred_mv[2] = s_mv_pred.i2_mv[2];
122
1.66M
    i2_spat_pred_mv[3] = s_mv_pred.i2_mv[3];
123
124
1.66M
    i1_ref_frame0 = s_mv_pred.i1_ref_frame[0];
125
1.66M
    i1_ref_frame1 = s_mv_pred.i1_ref_frame[1];
126
127
1.66M
    i1_ref_frame0 = (i1_ref_frame0 < 0) ? -1 : i1_ref_frame0;
128
1.66M
    i1_ref_frame1 = (i1_ref_frame1 < 0) ? -1 : i1_ref_frame1;
129
130
1.66M
    i1_pred = 0;
131
132
1.66M
    {
133
1.66M
        WORD8 u1_ref_idx, u1_ref_idx1;
134
1.66M
        UWORD32 uc_Idx, uc_Idx1;
135
1.66M
        UWORD8 u1_scale_ref = (ps_dec->ps_cur_slice->u1_mbaff_frame_flag
136
4.08k
                        && ps_cur_mb_info->u1_mb_field_decodingflag);
137
1.66M
        u1_final_ref_idx = i1_ref_frame0;
138
1.66M
        if(i1_ref_frame0 >= 0)
139
1.57M
        {
140
            /* convert RefIdx if it is MbAff */
141
1.57M
            u1_ref_idx = i1_ref_frame0;
142
1.57M
            u1_ref_idx1 = i1_ref_frame0;
143
1.57M
            if(u1_scale_ref)
144
708
            {
145
708
                u1_ref_idx1 = u1_ref_idx >> 1;
146
708
                if((u1_ref_idx & 0x01) != (1 - ps_cur_mb_info->u1_topmb))
147
413
                    u1_ref_idx1 += MAX_REF_BUFS;
148
708
            }
149
            /* If i1_ref_frame0 < 0 then refIdxCol is obtained from ps_pic_buff1 */
150
1.57M
            ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][u1_ref_idx1];
151
1.57M
            ps_ref_frame = ps_pic_buff0;
152
1.57M
            i1_pred = PRED_L0;
153
1.57M
        }
154
155
1.66M
        if(i1_ref_frame1 >= 0)
156
1.62M
        {
157
            /* convert RefIdx if it is MbAff */
158
1.62M
            u1_ref_idx = i1_ref_frame1;
159
1.62M
            u1_ref_idx1 = i1_ref_frame1;
160
1.62M
            if(u1_scale_ref)
161
869
            {
162
869
                u1_ref_idx1 = u1_ref_idx >> 1;
163
869
                if((u1_ref_idx & 0x01) != (1 - ps_cur_mb_info->u1_topmb))
164
415
                    u1_ref_idx1 += MAX_REF_BUFS;
165
869
            }
166
1.62M
            ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][u1_ref_idx1];
167
1.62M
            i1_pred = i1_pred | PRED_L1;
168
1.62M
        }
169
1.66M
        if(i1_ref_frame0 < 0)
170
94.8k
        {
171
94.8k
            ps_ref_frame = ps_pic_buff1;
172
94.8k
            u1_final_ref_idx = i1_ref_frame1;
173
94.8k
        }
174
175
1.66M
        u1_zero_pred_cond_f = (u1_direct_zero_pred_flag) || (i1_ref_frame0 < 0);
176
1.66M
        u1_zero_pred_cond_b = (u1_direct_zero_pred_flag) || (i1_ref_frame1 < 0);
177
178
1.66M
        if(ps_dec->ps_cur_pps->u1_wted_bipred_idc)
179
796k
        {
180
796k
            uc_Idx = ((i1_ref_frame0 < 1) ? 0 : i1_ref_frame0)
181
796k
                            * ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1];
182
796k
            if(u1_scale_ref)
183
1.00k
                uc_Idx >>= 1;
184
796k
            uc_Idx1 = (i1_ref_frame1 < 0) ? 0 : i1_ref_frame1;
185
796k
            uc_Idx += (u1_scale_ref) ? (uc_Idx1 >> 1) : uc_Idx1;
186
796k
            pui32_weight_ofsts =
187
796k
                            (UWORD32*)&ps_dec->pu4_wt_ofsts[2 * X3(uc_Idx)];
188
189
796k
            if(i1_ref_frame0 < 0)
190
72.5k
                pui32_weight_ofsts += 1;
191
192
796k
            if(u1_scale_ref && (ps_dec->ps_cur_pps->u1_wted_bipred_idc == 2))
193
721
            {
194
721
                WORD16 i2_ref_idx;
195
721
                i2_ref_idx = MAX(i1_ref_frame0, 0);
196
721
                i2_ref_idx *= (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1]
197
721
                                << 1);
198
721
                i2_ref_idx += MAX(i1_ref_frame1, 0);
199
721
                if(!ps_cur_mb_info->u1_topmb)
200
361
                    i2_ref_idx +=
201
361
                                    (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0]
202
361
                                                    << 1)
203
361
                                                    * (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1]
204
361
                                                                    << 1);
205
721
                pui32_weight_ofsts = (UWORD32*)&ps_dec->pu4_mbaff_wt_mat[2
206
721
                                * X3(i2_ref_idx)];
207
721
            }
208
796k
        }
209
1.66M
    }
210
211
1.66M
    s_temp_mv_pred.i1_ref_frame[0] = i1_ref_frame0;
212
1.66M
    s_temp_mv_pred.i1_ref_frame[1] = i1_ref_frame1;
213
1.66M
    s_temp_mv_pred.u1_col_ref_pic_idx = ps_ref_frame->u1_mv_buf_id;
214
1.66M
    s_temp_mv_pred.u1_pic_type = ps_ref_frame->u1_pic_type;
215
216
    /**********************************************************************/
217
    /* Call the function which gets the number of partitions and          */
218
    /* partition info of colocated Mb                                     */
219
    /**********************************************************************/
220
221
1.66M
    ps_dec->pf_parse_mvdirect(ps_dec, ps_dec->ps_col_pic, &s_mvdirect, u1_wd_x,
222
1.66M
                           ps_dec->i4_submb_ofst, ps_cur_mb_info);
223
1.66M
    ps_col_pic = ps_dec->ps_col_pic;
224
1.66M
    if((s_mvdirect.u1_col_zeroflag_change == 0) || u1_direct_zero_pred_flag)
225
1.61M
    {
226
1.61M
        WORD16 i2_mv_x, i2_mv_y, i2_mvX1, i2_mvY1;
227
        /* Most probable case */
228
1.61M
        u1_col_zero_flag = *(ps_col_pic->pu1_col_zero_flag
229
1.61M
                        + s_mvdirect.i4_mv_indices[0]);
230
1.61M
        u1_col_zero_flag = u1_col_zero_flag & 0x01;
231
232
1.61M
        if(u1_zero_pred_cond_f || ((i1_ref_frame0 == 0) && (u1_col_zero_flag == 1)))
233
1.01M
        {
234
1.01M
            i2_mv_x = 0;
235
1.01M
            i2_mv_y = 0;
236
1.01M
        }
237
594k
        else
238
594k
        {
239
594k
            i2_mv_x = i2_spat_pred_mv[0];
240
594k
            i2_mv_y = i2_spat_pred_mv[1];
241
242
594k
        }
243
244
1.61M
        if(u1_zero_pred_cond_b || ((i1_ref_frame1 == 0) && (u1_col_zero_flag == 1)))
245
985k
        {
246
985k
            i2_mvX1 = 0;
247
985k
            i2_mvY1 = 0;
248
985k
        }
249
629k
        else
250
629k
        {
251
629k
            i2_mvX1 = i2_spat_pred_mv[2];
252
629k
            i2_mvY1 = i2_spat_pred_mv[3];
253
629k
        }
254
255
1.61M
        u4_sub_mb_num = ps_dec->u1_sub_mb_num;
256
1.61M
        u1_mb_partw = (u1_wd_x >> 2);
257
258
259
1.61M
        if(i1_ref_frame0 >= 0)
260
1.52M
        {
261
1.52M
            {
262
1.52M
               pred_info_pkd_t *ps_pred_pkd;
263
1.52M
               WORD16 i2_mv[2];
264
1.52M
               WORD8 i1_ref_idx= 0;
265
266
1.52M
               i2_mv[0] = i2_mv_x;
267
1.52M
               i2_mv[1] = i2_mv_y;
268
269
1.52M
               ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
270
1.52M
            ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u4_sub_mb_num,i1_pred,
271
1.52M
                            ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
272
1.52M
                            ps_pic_buff0->u1_pic_type);
273
1.52M
            ps_dec->u4_pred_info_pkd_idx++;
274
1.52M
            ps_cur_mb_info->u1_num_pred_parts++;
275
276
277
1.52M
            }
278
279
1.52M
        }
280
281
1.61M
        if(i1_ref_frame1 >= 0)
282
1.57M
        {
283
1.57M
            {
284
1.57M
                pred_info_pkd_t *ps_pred_pkd;
285
1.57M
               WORD16 i2_mv[2];
286
1.57M
               WORD8 i1_ref_idx= 0;
287
288
1.57M
               i2_mv[0] = i2_mvX1;
289
1.57M
               i2_mv[1] = i2_mvY1;
290
291
1.57M
               ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
292
1.57M
            ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u4_sub_mb_num,i1_pred,
293
1.57M
                            ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
294
1.57M
                            ps_pic_buff1->u1_pic_type);
295
1.57M
            ps_dec->u4_pred_info_pkd_idx++;
296
1.57M
            ps_cur_mb_info->u1_num_pred_parts++;
297
298
299
1.57M
            }
300
1.57M
        }
301
302
303
        /* Replication optimisation */
304
1.61M
        s_temp_mv_pred.i2_mv[0] = i2_mv_x;
305
1.61M
        s_temp_mv_pred.i2_mv[1] = i2_mv_y;
306
1.61M
        s_temp_mv_pred.i2_mv[2] = i2_mvX1;
307
1.61M
        s_temp_mv_pred.i2_mv[3] = i2_mvY1;
308
309
        /* Calculating colocated zero information */
310
1.61M
        {
311
            /*************************************/
312
            /* If(bit2 and bit3 set)             */
313
            /* then                              */
314
            /*  (bit0 and bit1) => submmbmode    */
315
            /*  (bit2 and bit3) => mbmode        */
316
            /* else                              */
317
            /*  (bit0 and bit1) => mbmode        */
318
            /*************************************/
319
            /*UWORD8 u1_packed_mb_sub_mb_mode = sub_partition ?
320
             (s_mvdirect.i1_partitionsize[0]) : ((s_mvdirect.i1_partitionsize[0]) << 2);*/
321
1.61M
            UWORD8 u1_packed_mb_sub_mb_mode = (u1_mb_partw == 2) ? 0x03 : 0;
322
323
1.61M
            if(i1_ref_frame0 < 0)
324
90.1k
            {
325
90.1k
                i2_mv_x = i2_mvX1;
326
90.1k
                i2_mv_y = i2_mvY1;
327
90.1k
            }
328
329
            /* Change from left shift 4 to 6 - Varun */
330
1.61M
            u1_colz = (ps_cur_mb_info->u1_mb_field_decodingflag << 1)
331
1.61M
                            | ((u1_final_ref_idx == 0) && (ABS(i2_mv_x) <= 1)
332
1.27M
                                            && (ABS(i2_mv_y) <= 1));
333
1.61M
            u1_colz |= (u1_packed_mb_sub_mb_mode << 6);
334
1.61M
        }
335
1.61M
        ps_mv = ps_mv_nmb_start + u4_sub_mb_num;
336
1.61M
        ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u4_sub_mb_num, u1_colz,
337
1.61M
                           u1_mb_partw, u1_mb_partw);
338
1.61M
        if(u1_wd_x == MB_SIZE)
339
1.60M
            ps_dec->u1_currB_type = 0;
340
341
342
343
1.61M
        return OK;
344
1.61M
    }
345
    /***************************************************************************/
346
    /* If present MB is 16x16 and the partition of colocated Mb is >= PRED_8x8 */
347
    /* i.e 8x8 or less than 8x8 partitions then set up DMA for (0,0) and       */
348
    /* spatially predicted motion vector and do the multiplexing after         */
349
    /* motion compensation                                                     */
350
    /***************************************************************************/
351
352
353
53.0k
    if((u1_wd_x == MB_SIZE) && (s_mvdirect.i1_num_partitions > 2))
354
4.68k
    {
355
4.68k
        ps_cur_mb_info->u1_Mux = 1;
356
4.68k
        if(i1_ref_frame0 >= 0)
357
3.47k
        {
358
359
3.47k
            {
360
3.47k
                pred_info_pkd_t *ps_pred_pkd;
361
3.47k
               WORD8 i1_ref_idx= 0;
362
363
3.47k
               ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
364
3.47k
            ih264d_fill_pred_info(&(i2_spat_pred_mv[0]),4,4,0,i1_pred,
365
3.47k
                            ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
366
3.47k
                            ps_pic_buff0->u1_pic_type);
367
3.47k
            ps_dec->u4_pred_info_pkd_idx++;
368
3.47k
            ps_cur_mb_info->u1_num_pred_parts++;
369
370
371
3.47k
            }
372
373
            /******    (0,0) Motion vectors DMA     *****/
374
3.47k
            {
375
3.47k
                pred_info_pkd_t *ps_pred_pkd;
376
3.47k
               WORD16 i2_mv[2];
377
3.47k
               WORD8 i1_ref_idx= 0;
378
379
3.47k
               i2_mv[0] = 0;
380
3.47k
               i2_mv[1] = 0;
381
382
3.47k
               ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
383
3.47k
            ih264d_fill_pred_info(i2_mv,4,4,0,i1_pred,
384
3.47k
                            ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
385
3.47k
                            ps_pic_buff0->u1_pic_type);
386
3.47k
            ps_dec->u4_pred_info_pkd_idx++;
387
3.47k
            ps_cur_mb_info->u1_num_pred_parts++;
388
389
390
3.47k
            }
391
3.47k
        }
392
4.68k
        if(i1_ref_frame1 >= 0)
393
3.61k
        {
394
3.61k
            {
395
3.61k
                pred_info_pkd_t *ps_pred_pkd;
396
3.61k
               WORD16 i2_mv[2];
397
3.61k
               WORD8 i1_ref_idx= 0;
398
399
3.61k
               ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
400
3.61k
            ih264d_fill_pred_info(&(i2_spat_pred_mv[2]),4,4,0,i1_pred,
401
3.61k
                            ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
402
3.61k
                            ps_pic_buff1->u1_pic_type);
403
3.61k
            ps_dec->u4_pred_info_pkd_idx++;
404
3.61k
            ps_cur_mb_info->u1_num_pred_parts++;
405
406
407
3.61k
            }
408
409
            /******    (0,0) Motion vectors DMA     *****/
410
411
3.61k
            {
412
3.61k
                pred_info_pkd_t *ps_pred_pkd;
413
3.61k
               WORD16 i2_mv[2];
414
3.61k
               WORD8 i1_ref_idx= 0;
415
416
3.61k
               i2_mv[0] = 0;
417
3.61k
               i2_mv[1] = 0;
418
419
3.61k
               ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
420
3.61k
            ih264d_fill_pred_info(i2_mv,4,4,0,i1_pred,
421
3.61k
                            ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
422
3.61k
                            ps_pic_buff1->u1_pic_type);
423
3.61k
            ps_dec->u4_pred_info_pkd_idx++;
424
3.61k
            ps_cur_mb_info->u1_num_pred_parts++;
425
426
427
3.61k
            }
428
3.61k
        }
429
4.68k
    }
430
431
    /*u1_col = *(ps_col_pic->pu1_col_zero_flag + s_mvdirect.i4_mv_indices[0]);
432
     u1_col &= 1;
433
     u1_init = 0;*/
434
435
152k
    for(i = 0; i < s_mvdirect.i1_num_partitions; i++)
436
99.1k
    {
437
99.1k
        partition_size = s_mvdirect.i1_partitionsize[i];
438
99.1k
        u4_sub_mb_num = s_mvdirect.i1_submb_num[i];
439
440
99.1k
        sub_partition = partition_size >> 2;
441
99.1k
        partition_size &= 0x3;
442
99.1k
        u1_mb_partw = pu1_mb_partw[partition_size];
443
99.1k
        u1_mb_parth = pu1_mb_parth[partition_size];
444
99.1k
        u2_mask = mask_table[partition_size];
445
99.1k
        if(sub_partition != 0)
446
12.7k
        {
447
12.7k
            u1_mb_partw >>= 1;
448
12.7k
            u1_mb_parth >>= 1;
449
12.7k
            u2_mask = sub_mask_table[partition_size];
450
12.7k
        }
451
452
99.1k
        u1_col_zero_flag = *(ps_col_pic->pu1_col_zero_flag
453
99.1k
                        + s_mvdirect.i4_mv_indices[i]);
454
99.1k
        u1_col_zero_flag = u1_col_zero_flag & 0x01;
455
456
        /*if(u1_col != u1_col_zero_flag)
457
         u1_init = 1;*/
458
459
99.1k
        if(u1_zero_pred_cond_f || ((i1_ref_frame0 == 0) && (u1_col_zero_flag == 1)))
460
80.9k
        {
461
80.9k
            pi2_final_mv0 = &i2_def_mv[0];
462
80.9k
            ui2_mask_fwd |= (u2_mask << u4_sub_mb_num);
463
80.9k
        }
464
18.1k
        else
465
18.1k
            pi2_final_mv0 = &i2_spat_pred_mv[0];
466
467
99.1k
        if(u1_zero_pred_cond_b || ((i1_ref_frame1 == 0) && (u1_col_zero_flag == 1)))
468
80.2k
        {
469
80.2k
            pi2_final_mv1 = &i2_def_mv[0];
470
80.2k
            ui2_mask_bwd |= (u2_mask << u4_sub_mb_num);
471
80.2k
        }
472
18.8k
        else
473
18.8k
            pi2_final_mv1 = &i2_spat_pred_mv[2];
474
475
99.1k
        if(ps_cur_mb_info->u1_Mux != 1)
476
74.1k
        {
477
            /*u1_sub_mb_x = u4_sub_mb_num & 0x03;
478
             uc_sub_mb_y = (u4_sub_mb_num >> 2);*/
479
74.1k
            if(i1_ref_frame0 >= 0)
480
67.4k
            {
481
482
67.4k
                {
483
67.4k
                    pred_info_pkd_t *ps_pred_pkd;
484
67.4k
                   WORD8 i1_ref_idx= 0;
485
486
67.4k
                   ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
487
67.4k
                ih264d_fill_pred_info(pi2_final_mv0,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,i1_pred,
488
67.4k
                                ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
489
67.4k
                                ps_pic_buff0->u1_pic_type);
490
67.4k
                ps_dec->u4_pred_info_pkd_idx++;
491
67.4k
                ps_cur_mb_info->u1_num_pred_parts++;
492
493
494
67.4k
                }
495
496
67.4k
            }
497
498
74.1k
            if(i1_ref_frame1 >= 0)
499
71.3k
            {
500
71.3k
                {
501
71.3k
                    pred_info_pkd_t *ps_pred_pkd;
502
71.3k
                   WORD8 i1_ref_idx= 0;
503
504
71.3k
                   ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
505
71.3k
                ih264d_fill_pred_info(pi2_final_mv1,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,i1_pred,
506
71.3k
                                ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
507
71.3k
                                ps_pic_buff1->u1_pic_type);
508
71.3k
                ps_dec->u4_pred_info_pkd_idx++;
509
71.3k
                ps_cur_mb_info->u1_num_pred_parts++;
510
511
512
71.3k
                }
513
71.3k
            }
514
74.1k
        }
515
516
        /* Replication optimisation */
517
99.1k
        s_temp_mv_pred.i2_mv[0] = pi2_final_mv0[0];
518
99.1k
        s_temp_mv_pred.i2_mv[1] = pi2_final_mv0[1];
519
99.1k
        s_temp_mv_pred.i2_mv[2] = pi2_final_mv1[0];
520
99.1k
        s_temp_mv_pred.i2_mv[3] = pi2_final_mv1[1];
521
522
        /* Calculating colocated zero information */
523
99.1k
        {
524
99.1k
            WORD16 i2_mv_x = 0, i2_mv_y = 0;
525
            /*************************************/
526
            /* If(bit2 and bit3 set)             */
527
            /* then                              */
528
            /*  (bit0 and bit1) => submmbmode    */
529
            /*  (bit2 and bit3) => mbmode        */
530
            /* else                              */
531
            /*  (bit0 and bit1) => mbmode        */
532
            /*************************************/
533
99.1k
            UWORD8 u1_packed_mb_sub_mb_mode =
534
99.1k
                            sub_partition ? (s_mvdirect.i1_partitionsize[i]) : ((s_mvdirect.i1_partitionsize[i])
535
86.3k
                                                            << 2);
536
537
99.1k
            if(i1_ref_frame0 >= 0)
538
86.7k
            {
539
86.7k
                i2_mv_x = pi2_final_mv0[0];
540
86.7k
                i2_mv_y = pi2_final_mv0[1];
541
86.7k
            }
542
12.4k
            else
543
12.4k
            {
544
12.4k
                i2_mv_x = pi2_final_mv1[0];
545
12.4k
                i2_mv_y = pi2_final_mv1[1];
546
12.4k
            }
547
548
99.1k
            u1_colz = (ps_cur_mb_info->u1_mb_field_decodingflag << 1)
549
99.1k
                            | ((u1_final_ref_idx == 0) && (ABS(i2_mv_x) <= 1)
550
92.2k
                                            && (ABS(i2_mv_y) <= 1));
551
99.1k
            u1_colz |= (u1_packed_mb_sub_mb_mode << 4);
552
99.1k
        }
553
99.1k
        ps_mv = ps_mv_nmb_start + u4_sub_mb_num;
554
99.1k
        ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u4_sub_mb_num, u1_colz,
555
99.1k
                           u1_mb_parth, u1_mb_partw);
556
99.1k
    }
557
53.0k
    i = 0;
558
53.0k
    if(i1_ref_frame0 >= 0)
559
48.3k
        ps_cur_mb_info->u2_mask[i++] = ui2_mask_fwd;
560
53.0k
    if(i1_ref_frame1 >= 0)
561
50.4k
        ps_cur_mb_info->u2_mask[i] = ui2_mask_bwd;
562
563
    /*if(u1_init)
564
     H264_DEC_DEBUG_PRINT("hit\n");
565
     else
566
     H264_DEC_DEBUG_PRINT("miss\n");*/
567
568
53.0k
    return OK;
569
1.66M
}
570
571
/*!
572
 **************************************************************************
573
 * \if Function name : ih264d_decode_temporal_direct \endif
574
 *
575
 * \brief
576
 *    Decodes temporal direct mode.
577
 *
578
 * \return
579
 *    None.
580
 *
581
 **************************************************************************
582
 */
583
WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
584
                                     UWORD8 u1_wd_x,
585
                                     dec_mb_info_t * ps_cur_mb_info,
586
                                     UWORD32 u4_mb_num)
587
4.16M
{
588
4.16M
    struct pic_buffer_t *ps_pic_buff0, *ps_pic_buff1, *ps_col_pic;
589
4.16M
    mv_pred_t *ps_mv, s_temp_mv_pred;
590
4.16M
    UWORD32 u4_sub_mb_num;
591
4.16M
    UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
592
4.16M
    WORD16 i2_mv_x0, i2_mv_y0, i2_mv_x1, i2_mv_y1;
593
4.16M
    UWORD8 u1_mb_partw, u1_mb_parth;
594
4.16M
    UWORD8 i, partition_size, sub_partition;
595
4.16M
    UWORD32 *pui32_weight_ofsts = NULL;
596
4.16M
    directmv_t s_mvdirect;
597
4.16M
    const UWORD8 *pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
598
4.16M
    const UWORD8 *pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw;
599
4.16M
    WORD8 c_refFrm0, c_refFrm1;
600
4.16M
    UWORD8 u1_ref_idx0, u1_is_cur_mb_fld;
601
4.16M
    WORD32 pic0_poc, pic1_poc, cur_poc;
602
4.16M
    WORD32 ret = 0;
603
604
4.16M
    u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
605
4.16M
    ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][0];
606
607
    /**********************************************************************/
608
    /* Call the function which gets the number of partitions and          */
609
    /* partition info of colocated Mb                                     */
610
    /**********************************************************************/
611
4.16M
    ps_dec->pf_parse_mvdirect(ps_dec, ps_dec->ps_col_pic, &s_mvdirect, u1_wd_x,
612
4.16M
                           ps_dec->i4_submb_ofst, ps_cur_mb_info);
613
4.16M
    ps_col_pic = ps_dec->ps_col_pic;
614
615
8.36M
    for(i = 0; i < s_mvdirect.i1_num_partitions; i++)
616
4.19M
    {
617
4.19M
        UWORD8 u1_colz;
618
4.19M
        partition_size = s_mvdirect.i1_partitionsize[i];
619
4.19M
        u4_sub_mb_num = s_mvdirect.i1_submb_num[i];
620
4.19M
        ps_mv = ps_col_pic->ps_mv + s_mvdirect.i4_mv_indices[i];
621
622
        /* This should be removed to catch unitialized memory read */
623
4.19M
        u1_ref_idx0 = 0;
624
625
4.19M
        sub_partition = partition_size >> 2;
626
4.19M
        partition_size &= 0x3;
627
4.19M
        u1_mb_partw = pu1_mb_partw[partition_size];
628
4.19M
        u1_mb_parth = pu1_mb_parth[partition_size];
629
4.19M
        if(sub_partition != 0)
630
18.2k
        {
631
18.2k
            u1_mb_partw >>= 1;
632
18.2k
            u1_mb_parth >>= 1;
633
18.2k
        }
634
4.19M
        c_refFrm0 = ps_mv->i1_ref_frame[0];
635
4.19M
        c_refFrm1 = ps_mv->i1_ref_frame[1];
636
637
4.19M
        if((c_refFrm0 == -1) && (c_refFrm1 == -1))
638
25.9k
        {
639
25.9k
            u1_ref_idx0 = 0;
640
25.9k
            ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][0];
641
25.9k
            if(u1_mbaff && u1_is_cur_mb_fld)
642
1
            {
643
1
                if(ps_cur_mb_info->u1_topmb)
644
0
                {
645
0
                    pic0_poc = ps_pic_buff0->i4_top_field_order_cnt;
646
0
                    pic1_poc = ps_pic_buff1->i4_top_field_order_cnt;
647
0
                    cur_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
648
0
                }
649
1
                else
650
1
                {
651
1
                    pic1_poc = ps_pic_buff1->i4_bottom_field_order_cnt;
652
1
                    cur_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
653
1
                    ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][MAX_REF_BUFS];
654
1
                    pic0_poc = ps_pic_buff0->i4_bottom_field_order_cnt;
655
1
                    ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][MAX_REF_BUFS];
656
1
                }
657
1
            }
658
25.9k
            else
659
25.9k
            {
660
25.9k
                pic0_poc = ps_pic_buff0->i4_avg_poc;
661
25.9k
                pic1_poc = ps_pic_buff1->i4_avg_poc;
662
25.9k
                cur_poc = ps_dec->ps_cur_pic->i4_poc;
663
25.9k
            }
664
25.9k
        }
665
4.16M
        else
666
4.16M
        {
667
4.16M
            UWORD8 uc_i, u1_num_frw_ref_pics;
668
4.16M
            UWORD8 buf_id, u1_pic_type;
669
4.16M
            buf_id = ps_mv->u1_col_ref_pic_idx;
670
4.16M
            u1_pic_type = ps_mv->u1_pic_type;
671
4.16M
            if(ps_dec->ps_cur_slice->u1_field_pic_flag)
672
1.05k
            {
673
1.05k
                if(s_mvdirect.u1_vert_mv_scale == FRM_TO_FLD)
674
951
                {
675
951
                    u1_pic_type = TOP_FLD;
676
951
                    if(ps_dec->ps_cur_slice->u1_bottom_field_flag)
677
845
                        u1_pic_type = BOT_FLD;
678
951
                }
679
1.05k
            }
680
4.16M
            u1_num_frw_ref_pics =
681
4.16M
                            ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0];
682
683
8.09M
            for(uc_i = 0; uc_i < u1_num_frw_ref_pics; uc_i++)
684
4.25M
            {
685
4.25M
                if(ps_dec->ps_cur_slice->u1_field_pic_flag)
686
3.08k
                {
687
3.08k
                    if(ps_dec->ps_ref_pic_buf_lx[0][uc_i]->u1_mv_buf_id == buf_id)
688
2.49k
                    {
689
2.49k
                        if(ps_dec->ps_ref_pic_buf_lx[0][uc_i]->u1_pic_type
690
2.49k
                                        == u1_pic_type)
691
21
                        {
692
21
                            u1_ref_idx0 = uc_i;
693
21
                            break;
694
21
                        }
695
2.49k
                    }
696
3.08k
                }
697
4.25M
                else
698
4.25M
                {
699
4.25M
                    if(ps_dec->ps_ref_pic_buf_lx[0][uc_i]->u1_mv_buf_id == buf_id)
700
324k
                    {
701
324k
                        u1_ref_idx0 = uc_i;
702
324k
                        break;
703
324k
                    }
704
4.25M
                }
705
4.25M
            }
706
707
4.16M
            ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][u1_ref_idx0];
708
4.16M
            ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][0];
709
710
4.16M
            if(u1_mbaff && u1_is_cur_mb_fld)
711
8.70k
            {
712
8.70k
                pic0_poc = ps_pic_buff0->i4_top_field_order_cnt;
713
8.70k
                u1_ref_idx0 <<= 1;
714
8.70k
                if(s_mvdirect.u1_vert_mv_scale == ONE_TO_ONE)
715
812
                {
716
812
                    if(u1_pic_type == BOT_FLD)
717
72
                    {
718
72
                        pic0_poc = ps_pic_buff0->i4_bottom_field_order_cnt;
719
72
                        ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][(u1_ref_idx0
720
72
                                        >> 1) + MAX_REF_BUFS];
721
72
                        if(ps_cur_mb_info->u1_topmb)
722
60
                            u1_ref_idx0++;
723
72
                    }
724
740
                    else
725
740
                    {
726
740
                        if(1 - ps_cur_mb_info->u1_topmb)
727
429
                            u1_ref_idx0++;
728
740
                    }
729
812
                }
730
8.70k
                if(s_mvdirect.u1_vert_mv_scale == FRM_TO_FLD)
731
7.89k
                {
732
7.89k
                    if(1 - ps_cur_mb_info->u1_topmb)
733
4.08k
                    {
734
4.08k
                        pic0_poc = ps_pic_buff0->i4_bottom_field_order_cnt;
735
4.08k
                        ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][(u1_ref_idx0
736
4.08k
                                        >> 1) + MAX_REF_BUFS];
737
4.08k
                    }
738
7.89k
                }
739
8.70k
                if(ps_cur_mb_info->u1_topmb)
740
4.17k
                {
741
4.17k
                    pic1_poc = ps_pic_buff1->i4_top_field_order_cnt;
742
4.17k
                    cur_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
743
4.17k
                }
744
4.52k
                else
745
4.52k
                {
746
4.52k
                    pic1_poc = ps_pic_buff1->i4_bottom_field_order_cnt;
747
4.52k
                    cur_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
748
4.52k
                    ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][MAX_REF_BUFS];
749
4.52k
                }
750
8.70k
            }
751
4.15M
            else
752
4.15M
            {
753
4.15M
                pic0_poc = ps_pic_buff0->i4_avg_poc;
754
4.15M
                pic1_poc = ps_pic_buff1->i4_avg_poc;
755
4.15M
                cur_poc = ps_dec->ps_cur_pic->i4_poc;
756
4.15M
            }
757
4.16M
        }
758
4.19M
        {
759
4.19M
            WORD16 i16_td;
760
4.19M
            WORD64 diff;
761
4.19M
            if(c_refFrm0 >= 0)
762
4.16M
            {
763
4.16M
                i2_mv_x0 = ps_mv->i2_mv[0];
764
4.16M
                i2_mv_y0 = ps_mv->i2_mv[1];
765
4.16M
            }
766
29.1k
            else if(c_refFrm1 >= 0)
767
3.21k
            {
768
3.21k
                i2_mv_x0 = ps_mv->i2_mv[2];
769
3.21k
                i2_mv_y0 = ps_mv->i2_mv[3];
770
3.21k
            }
771
25.9k
            else
772
25.9k
            {
773
25.9k
                i2_mv_x0 = 0;
774
25.9k
                i2_mv_y0 = 0;
775
25.9k
            }
776
            /* If FRM_TO_FLD or FLD_TO_FRM scale the "y" component of the colocated Mv*/
777
4.19M
            if(s_mvdirect.u1_vert_mv_scale == FRM_TO_FLD)
778
8.85k
            {
779
8.85k
                i2_mv_y0 /= 2;
780
8.85k
            }
781
4.18M
            else if(s_mvdirect.u1_vert_mv_scale == FLD_TO_FRM)
782
9.91k
            {
783
9.91k
                i2_mv_y0 *= 2;
784
9.91k
            }
785
786
4.19M
            diff = (WORD64)pic1_poc - pic0_poc;
787
4.19M
            i16_td = CLIP_S8(diff);
788
4.19M
            if((ps_pic_buff0->u1_is_short == 0) || (i16_td == 0))
789
4.01M
            {
790
4.01M
                i2_mv_x1 = 0;
791
4.01M
                i2_mv_y1 = 0;
792
4.01M
            }
793
182k
            else
794
182k
            {
795
182k
                WORD16 i2_tb, i2_tx, i2_dist_scale_factor, i2_temp;
796
797
182k
                diff = (WORD64)cur_poc - pic0_poc;
798
182k
                i2_tb = CLIP_S8(diff);
799
800
182k
                i2_tx = (16384 + ABS(SIGN_POW2_DIV(i16_td, 1))) / i16_td;
801
182k
                i2_dist_scale_factor = CLIP_S11(
802
182k
                                            (((i2_tb * i2_tx) + 32) >> 6));
803
182k
                i2_temp = (i2_mv_x0 * i2_dist_scale_factor + 128) >> 8;
804
182k
                i2_mv_x1 = i2_temp - i2_mv_x0;
805
182k
                i2_mv_x0 = i2_temp;
806
807
182k
                i2_temp = (i2_mv_y0 * i2_dist_scale_factor + 128) >> 8;
808
182k
                i2_mv_y1 = i2_temp - i2_mv_y0;
809
182k
                i2_mv_y0 = i2_temp;
810
182k
            }
811
4.19M
            {
812
4.19M
                mv_pred_t *ps_mv;
813
814
                /*u1_sub_mb_x = u4_sub_mb_num & 0x03;
815
                 uc_sub_mb_y = u4_sub_mb_num >> 2;*/
816
4.19M
                if(ps_dec->ps_cur_pps->u1_wted_bipred_idc)
817
3.99M
                {
818
3.99M
                    UWORD8 u1_idx =
819
3.99M
                                    u1_ref_idx0
820
3.99M
                                                    * ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1];
821
3.99M
                    UWORD8 u1_scale_ref = u1_mbaff && u1_is_cur_mb_fld;
822
3.99M
                    if(u1_scale_ref)
823
7.27k
                        u1_idx >>= 1;
824
3.99M
                    pui32_weight_ofsts = (UWORD32*)&ps_dec->pu4_wt_ofsts[2
825
3.99M
                                    * X3(u1_idx)];
826
3.99M
                    if(u1_scale_ref
827
7.27k
                                    && (ps_dec->ps_cur_pps->u1_wted_bipred_idc
828
7.27k
                                                    == 2))
829
7.27k
                    {
830
7.27k
                        WORD16 i2_ref_idx;
831
7.27k
                        i2_ref_idx = u1_ref_idx0;
832
7.27k
                        i2_ref_idx *=
833
7.27k
                                        (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1]
834
7.27k
                                                        << 1);
835
7.27k
                        if(!ps_cur_mb_info->u1_topmb)
836
3.79k
                            i2_ref_idx +=
837
3.79k
                                            (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0]
838
3.79k
                                                            << 1)
839
3.79k
                                                            * (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1]
840
3.79k
                                                                            << 1);
841
7.27k
                        pui32_weight_ofsts =
842
7.27k
                                        (UWORD32*)&ps_dec->pu4_mbaff_wt_mat[2
843
7.27k
                                                        * X3(i2_ref_idx)];
844
7.27k
                    }
845
3.99M
                }
846
4.19M
                {
847
4.19M
                    pred_info_pkd_t *ps_pred_pkd;
848
4.19M
                   WORD16 i2_mv[2];
849
4.19M
                   WORD8 i1_ref_idx= 0;
850
851
4.19M
                   i2_mv[0] = i2_mv_x0;
852
4.19M
                   i2_mv[1] = i2_mv_y0;
853
854
4.19M
                   ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
855
4.19M
                ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,PRED_L0 | PRED_L1,
856
4.19M
                                ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
857
4.19M
                                ps_pic_buff0->u1_pic_type);
858
4.19M
                ps_dec->u4_pred_info_pkd_idx++;
859
4.19M
                ps_cur_mb_info->u1_num_pred_parts++;
860
861
862
4.19M
                }
863
4.19M
                {
864
4.19M
                   pred_info_pkd_t *ps_pred_pkd;
865
4.19M
                   WORD16 i2_mv[2];
866
4.19M
                   WORD8 i1_ref_idx= 0;
867
868
4.19M
                   i2_mv[0] = i2_mv_x1;
869
4.19M
                   i2_mv[1] = i2_mv_y1;
870
871
4.19M
                   ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
872
4.19M
                ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,PRED_L0 | PRED_L1,
873
4.19M
                                ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
874
4.19M
                                ps_pic_buff1->u1_pic_type);
875
4.19M
                ps_dec->u4_pred_info_pkd_idx++;
876
4.19M
                ps_cur_mb_info->u1_num_pred_parts++;
877
878
879
4.19M
                }
880
881
                /* Replication optimisation */
882
4.19M
                s_temp_mv_pred.i2_mv[0] = i2_mv_x0;
883
4.19M
                s_temp_mv_pred.i2_mv[1] = i2_mv_y0;
884
4.19M
                s_temp_mv_pred.i2_mv[2] = i2_mv_x1;
885
4.19M
                s_temp_mv_pred.i2_mv[3] = i2_mv_y1;
886
4.19M
                s_temp_mv_pred.i1_ref_frame[0] = u1_ref_idx0;
887
4.19M
                s_temp_mv_pred.i1_ref_frame[1] = 0;
888
4.19M
                s_temp_mv_pred.u1_col_ref_pic_idx = ps_pic_buff0->u1_mv_buf_id;
889
4.19M
                s_temp_mv_pred.u1_pic_type = ps_pic_buff0->u1_pic_type;
890
4.19M
                ps_mv = ps_dec->ps_mv_cur + (u4_mb_num << 4) + u4_sub_mb_num;
891
892
4.19M
                {
893
4.19M
                    WORD16 i2_mv_x = 0, i2_mv_y = 0;
894
4.19M
                    UWORD8 u1_packed_mb_sub_mb_mode =
895
4.19M
                                    sub_partition ? (s_mvdirect.i1_partitionsize[i]) : ((s_mvdirect.i1_partitionsize[i])
896
4.17M
                                                                    << 2);
897
898
4.19M
                    if(c_refFrm0 >= 0)
899
4.16M
                    {
900
4.16M
                        i2_mv_x = i2_mv_x0;
901
4.16M
                        i2_mv_y = i2_mv_y0;
902
4.16M
                    }
903
29.1k
                    else
904
29.1k
                    {
905
29.1k
                        i2_mv_x = i2_mv_x1;
906
29.1k
                        i2_mv_y = i2_mv_y1;
907
29.1k
                    }
908
909
4.19M
                    u1_colz =
910
4.19M
                                    (ps_cur_mb_info->u1_mb_field_decodingflag << 1)
911
4.19M
                                                    | ((u1_ref_idx0 == 0)
912
4.13M
                                                                    && (ABS(i2_mv_x)
913
4.13M
                                                                                    <= 1)
914
4.11M
                                                                    && (ABS(i2_mv_y)
915
4.11M
                                                                                    <= 1));
916
4.19M
                    u1_colz |= (u1_packed_mb_sub_mb_mode << 4);
917
4.19M
                }
918
4.19M
                ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u4_sub_mb_num,
919
4.19M
                                   u1_colz, u1_mb_parth, u1_mb_partw);
920
4.19M
            }
921
4.19M
        }
922
4.19M
    }
923
    /* return value set to UWORD8 to make it homogeneous  */
924
    /* with decodespatialdirect                           */
925
4.16M
    return OK;
926
4.16M
}
927
928
void ih264d_convert_frm_to_fld_list(struct pic_buffer_t *ps_ref_pic_buf_lx,
929
                                    UWORD8 *pu1_L0,
930
                                    dec_struct_t *ps_dec,
931
                                    UWORD8 u1_num_short_term_bufs)
932
5.30k
{
933
5.30k
    UWORD8 uc_count = *pu1_L0, i, uc_l1, uc_lx, j;
934
5.30k
    struct pic_buffer_t *ps_ref_lx[2], *ps_ref_pic_lx;
935
5.30k
    UWORD8 u1_bottom_field_flag;
936
5.30k
    dec_slice_params_t *ps_cur_slice;
937
5.30k
    UWORD8 u1_ref[2], u1_fld[2], u1_same_fld, u1_op_fld;
938
5.30k
    UWORD32 ui_half_num_of_sub_mbs;
939
940
5.30k
    uc_l1 = 0;
941
5.30k
    uc_lx = 0;
942
5.30k
    ps_cur_slice = ps_dec->ps_cur_slice;
943
5.30k
    ps_ref_pic_lx = ps_ref_pic_buf_lx - MAX_REF_BUFS;
944
5.30k
    ps_ref_lx[0] = ps_ref_pic_buf_lx;
945
5.30k
    ps_ref_lx[1] = ps_ref_pic_buf_lx;
946
5.30k
    u1_bottom_field_flag = ps_cur_slice->u1_bottom_field_flag;
947
5.30k
    ui_half_num_of_sub_mbs = ((ps_dec->u2_pic_ht * ps_dec->u2_pic_wd) >> 5);
948
5.30k
    if(u1_bottom_field_flag)
949
679
    {
950
679
        u1_ref[0] = BOT_REF;
951
679
        u1_ref[1] = TOP_REF;
952
679
        u1_fld[0] = BOT_FLD;
953
679
        u1_fld[1] = TOP_FLD;
954
679
        u1_same_fld = BOT_FLD;
955
679
        u1_op_fld = TOP_FLD;
956
679
    }
957
4.62k
    else
958
4.62k
    {
959
4.62k
        u1_ref[0] = TOP_REF;
960
4.62k
        u1_ref[1] = BOT_REF;
961
4.62k
        u1_fld[0] = TOP_FLD;
962
4.62k
        u1_fld[1] = BOT_FLD;
963
4.62k
        u1_same_fld = TOP_FLD;
964
4.62k
        u1_op_fld = BOT_FLD;
965
4.62k
    }
966
967
    /* Create the field list starting with all the short term     */
968
    /* frames followed by all the long term frames. No long term  */
969
    /* reference field should have a list idx less than a short   */
970
    /* term reference field during initiailization.               */
971
972
15.9k
    for(j = 0; j < 2; j++)
973
10.6k
    {
974
10.6k
        i = ((j == 0) ? 0 : u1_num_short_term_bufs);
975
10.6k
        uc_count = ((j == 0) ? u1_num_short_term_bufs : *pu1_L0);
976
24.2k
        for(; i < uc_count; i++, ps_ref_lx[0]++)
977
13.6k
        {
978
            /* Search field of same parity in Frame list */
979
13.6k
            if((ps_ref_lx[0]->u1_pic_type & u1_ref[0])) // || ((ps_ref_lx[0]->u1_picturetype & 0x3) == 0))
980
6.01k
            {
981
                /* Insert PIC of same parity in RefPicList */
982
6.01k
                ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_lx, ps_ref_lx[0]);
983
6.01k
                ps_ref_pic_lx->i4_pic_num = (ps_ref_pic_lx->i4_pic_num * 2 + 1);
984
6.01k
                ps_ref_pic_lx->u1_long_term_pic_num =
985
6.01k
                                (ps_ref_pic_lx->u1_long_term_frm_idx * 2 + 1);
986
6.01k
                ps_ref_pic_lx->u1_pic_type = u1_same_fld;
987
6.01k
                if(u1_fld[0] & BOT_FLD)
988
586
                {
989
586
                    ps_ref_pic_lx->u1_pic_type = BOT_FLD;
990
586
                    ps_ref_pic_lx->pu1_buf1 += ps_ref_pic_lx->u2_frm_wd_y;
991
586
                    ps_ref_pic_lx->pu1_buf2 += ps_ref_pic_lx->u2_frm_wd_uv;
992
586
                    ps_ref_pic_lx->pu1_buf3 += ps_ref_pic_lx->u2_frm_wd_uv;
993
586
                    if(ps_ref_pic_lx->u1_picturetype & 0x3)
994
316
                    {
995
316
                        ps_ref_pic_lx->pu1_col_zero_flag += ui_half_num_of_sub_mbs;
996
316
                        ps_ref_pic_lx->ps_mv += ui_half_num_of_sub_mbs;
997
316
                    }
998
586
                    ps_ref_pic_lx->i4_poc =
999
586
                                    ps_ref_pic_lx->i4_bottom_field_order_cnt;
1000
586
                    ps_ref_pic_lx->i4_avg_poc =
1001
586
                                    ps_ref_pic_lx->i4_bottom_field_order_cnt;
1002
586
                }
1003
5.42k
                else
1004
5.42k
                {
1005
5.42k
                    ps_ref_pic_lx->u1_pic_type = TOP_FLD;
1006
5.42k
                    ps_ref_pic_lx->i4_poc = ps_ref_pic_lx->i4_top_field_order_cnt;
1007
5.42k
                    ps_ref_pic_lx->i4_avg_poc =
1008
5.42k
                                    ps_ref_pic_lx->i4_top_field_order_cnt;
1009
5.42k
                }
1010
1011
6.01k
                ps_ref_pic_lx++;
1012
6.01k
                uc_lx++;
1013
                /* Find field of opposite parity */
1014
6.01k
                if(uc_l1 < uc_count && ps_ref_lx[1])
1015
5.83k
                {
1016
7.30k
                    while(!(ps_ref_lx[1]->u1_pic_type & u1_ref[1]))
1017
1.89k
                    {
1018
1.89k
                        ps_ref_lx[1]++;
1019
1.89k
                        uc_l1++;
1020
1.89k
                        if(uc_l1 >= uc_count)
1021
419
                            ps_ref_lx[1] = 0;
1022
1.89k
                        if(!ps_ref_lx[1])
1023
419
                            break;
1024
1.89k
                    }
1025
1026
5.83k
                    if(ps_ref_lx[1])
1027
5.41k
                    {
1028
5.41k
                        uc_l1++;
1029
5.41k
                        ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_lx,
1030
5.41k
                                                           ps_ref_lx[1]);
1031
5.41k
                        ps_ref_pic_lx->u1_pic_type = u1_op_fld;
1032
5.41k
                        ps_ref_pic_lx->i4_pic_num = (ps_ref_pic_lx->i4_pic_num * 2);
1033
5.41k
                        ps_ref_pic_lx->u1_long_term_pic_num =
1034
5.41k
                                        (ps_ref_pic_lx->u1_long_term_frm_idx * 2);
1035
5.41k
                        if(u1_fld[1] & BOT_FLD)
1036
5.01k
                        {
1037
5.01k
                            ps_ref_pic_lx->u1_pic_type = BOT_FLD;
1038
5.01k
                            ps_ref_pic_lx->pu1_buf1 += ps_ref_pic_lx->u2_frm_wd_y;
1039
5.01k
                            ps_ref_pic_lx->pu1_buf2 += ps_ref_pic_lx->u2_frm_wd_uv;
1040
5.01k
                            ps_ref_pic_lx->pu1_buf3 += ps_ref_pic_lx->u2_frm_wd_uv;
1041
5.01k
                            if(ps_ref_pic_lx->u1_picturetype & 0x3)
1042
3.47k
                            {
1043
3.47k
                                ps_ref_pic_lx->pu1_col_zero_flag +=
1044
3.47k
                                                ui_half_num_of_sub_mbs;
1045
3.47k
                                ps_ref_pic_lx->ps_mv += ui_half_num_of_sub_mbs;
1046
3.47k
                            }
1047
5.01k
                            ps_ref_pic_lx->i4_poc =
1048
5.01k
                                            ps_ref_pic_lx->i4_bottom_field_order_cnt;
1049
5.01k
                            ps_ref_pic_lx->i4_avg_poc =
1050
5.01k
                                            ps_ref_pic_lx->i4_bottom_field_order_cnt;
1051
5.01k
                        }
1052
393
                        else
1053
393
                        {
1054
393
                            ps_ref_pic_lx->u1_pic_type = TOP_FLD;
1055
393
                            ps_ref_pic_lx->i4_poc =
1056
393
                                            ps_ref_pic_lx->i4_top_field_order_cnt;
1057
393
                            ps_ref_pic_lx->i4_avg_poc =
1058
393
                                            ps_ref_pic_lx->i4_top_field_order_cnt;
1059
393
                        }
1060
5.41k
                        ps_ref_pic_lx++;
1061
5.41k
                        uc_lx++;
1062
5.41k
                        ps_ref_lx[1]++;
1063
5.41k
                    }
1064
5.83k
                }
1065
6.01k
            }
1066
13.6k
        }
1067
1068
        /* Same parity fields are over, now insert left over opposite parity fields */
1069
        /** Added  if(ps_ref_lx[1]) for error checks */
1070
10.6k
        if(ps_ref_lx[1])
1071
9.76k
        {
1072
16.1k
            for(; uc_l1 < uc_count; uc_l1++)
1073
6.35k
            {
1074
6.35k
                if(ps_ref_lx[1]->u1_pic_type & u1_ref[1])
1075
4.91k
                {
1076
                    /* Insert PIC of opposite parity in RefPicList */
1077
4.91k
                    ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_lx,
1078
4.91k
                                                       ps_ref_lx[1]);
1079
4.91k
                    ps_ref_pic_lx->u1_pic_type = u1_op_fld;
1080
4.91k
                    ps_ref_pic_lx->i4_pic_num = (ps_ref_pic_lx->i4_pic_num * 2);
1081
4.91k
                    ps_ref_pic_lx->u1_long_term_pic_num =
1082
4.91k
                                    (ps_ref_pic_lx->u1_long_term_frm_idx * 2);
1083
4.91k
                    if(u1_op_fld == BOT_FLD)
1084
4.90k
                    {
1085
4.90k
                        ps_ref_pic_lx->u1_pic_type = BOT_FLD;
1086
4.90k
                        ps_ref_pic_lx->pu1_buf1 += ps_ref_pic_lx->u2_frm_wd_y;
1087
4.90k
                        ps_ref_pic_lx->pu1_buf2 += ps_ref_pic_lx->u2_frm_wd_uv;
1088
4.90k
                        ps_ref_pic_lx->pu1_buf3 += ps_ref_pic_lx->u2_frm_wd_uv;
1089
4.90k
                        if(ps_ref_pic_lx->u1_picturetype & 0x3)
1090
3.02k
                        {
1091
3.02k
                            ps_ref_pic_lx->pu1_col_zero_flag +=
1092
3.02k
                                            ui_half_num_of_sub_mbs;
1093
3.02k
                            ps_ref_pic_lx->ps_mv += ui_half_num_of_sub_mbs;
1094
3.02k
                        }
1095
4.90k
                        ps_ref_pic_lx->i4_poc =
1096
4.90k
                                        ps_ref_pic_lx->i4_bottom_field_order_cnt;
1097
4.90k
                        ps_ref_pic_lx->i4_avg_poc =
1098
4.90k
                                        ps_ref_pic_lx->i4_bottom_field_order_cnt;
1099
4.90k
                    }
1100
8
                    else
1101
8
                    {
1102
8
                        ps_ref_pic_lx->i4_poc =
1103
8
                                        ps_ref_pic_lx->i4_top_field_order_cnt;
1104
8
                        ps_ref_pic_lx->i4_avg_poc =
1105
8
                                        ps_ref_pic_lx->i4_top_field_order_cnt;
1106
8
                    }
1107
4.91k
                    ps_ref_pic_lx++;
1108
4.91k
                    uc_lx++;
1109
4.91k
                    ps_ref_lx[1]++;
1110
4.91k
                }
1111
6.35k
            }
1112
9.76k
        }
1113
10.6k
    }
1114
5.30k
    *pu1_L0 = uc_lx;
1115
5.30k
}
1116
1117
void ih264d_convert_frm_mbaff_list(dec_struct_t *ps_dec)
1118
1.35k
{
1119
1.35k
    struct pic_buffer_t **ps_ref_pic_lx;
1120
1.35k
    UWORD8 u1_max_ref_idx, idx;
1121
1.35k
    UWORD16 u2_frm_wd_y, u2_frm_wd_uv;
1122
1.35k
    struct pic_buffer_t **ps_ref_pic_buf_lx;
1123
1.35k
    UWORD32 u4_half_num_of_sub_mbs = ((ps_dec->u2_pic_ht * ps_dec->u2_pic_wd) >> 5);
1124
1125
1.35k
    ps_ref_pic_buf_lx = ps_dec->ps_ref_pic_buf_lx[0];
1126
1.35k
    ps_ref_pic_lx = ps_dec->ps_ref_pic_buf_lx[0];
1127
1.35k
    u1_max_ref_idx = ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0];
1128
9.23k
    for(idx = 0; idx < u1_max_ref_idx; idx++)
1129
7.87k
    {
1130
7.87k
        ps_ref_pic_lx[idx]->u1_pic_type = TOP_FLD;
1131
7.87k
        ps_ref_pic_lx[idx]->i4_poc = ps_ref_pic_lx[idx]->i4_top_field_order_cnt;
1132
1133
7.87k
    }
1134
1.35k
    u2_frm_wd_y = ps_dec->u2_frm_wd_y;
1135
1.35k
    u2_frm_wd_uv = ps_dec->u2_frm_wd_uv;
1136
1137
9.23k
    for(idx = 0; idx < u1_max_ref_idx; idx++)
1138
7.87k
    {
1139
7.87k
        *ps_ref_pic_lx[idx + MAX_REF_BUFS] = *ps_ref_pic_buf_lx[idx];
1140
7.87k
        ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf1 =
1141
7.87k
                        ps_ref_pic_buf_lx[idx]->pu1_buf1 + u2_frm_wd_y;
1142
7.87k
        ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf2 =
1143
7.87k
                        ps_ref_pic_buf_lx[idx]->pu1_buf2 + u2_frm_wd_uv;
1144
7.87k
        ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf3 =
1145
7.87k
                        ps_ref_pic_buf_lx[idx]->pu1_buf3 + u2_frm_wd_uv;
1146
1147
7.87k
        ps_ref_pic_lx[idx + MAX_REF_BUFS]->u1_pic_type = BOT_FLD;
1148
7.87k
        ps_ref_pic_lx[idx + MAX_REF_BUFS]->i4_poc =
1149
7.87k
                        ps_ref_pic_buf_lx[idx]->i4_bottom_field_order_cnt;
1150
7.87k
        if(ps_ref_pic_buf_lx[idx]->u1_picturetype & 0x3)
1151
172
        {
1152
172
            ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_col_zero_flag =
1153
172
                            ps_ref_pic_buf_lx[idx]->pu1_col_zero_flag
1154
172
                                            + u4_half_num_of_sub_mbs;
1155
172
            ps_ref_pic_lx[idx + MAX_REF_BUFS]->ps_mv =
1156
172
                            ps_ref_pic_buf_lx[idx]->ps_mv + u4_half_num_of_sub_mbs;
1157
172
        }
1158
7.87k
    }
1159
1160
1.35k
    if(ps_dec->u1_B)
1161
510
    {
1162
510
        ps_ref_pic_buf_lx = ps_dec->ps_ref_pic_buf_lx[1];
1163
510
        ps_ref_pic_lx = ps_dec->ps_ref_pic_buf_lx[1];
1164
510
        u1_max_ref_idx = ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1];
1165
1.33k
        for(idx = 0; idx < u1_max_ref_idx; idx++)
1166
829
        {
1167
829
            ps_ref_pic_lx[idx]->u1_pic_type = TOP_FLD;
1168
829
            ps_ref_pic_lx[idx]->i4_poc = ps_ref_pic_lx[idx]->i4_top_field_order_cnt;
1169
1170
829
        }
1171
1172
1.33k
        for(idx = 0; idx < u1_max_ref_idx; idx++)
1173
829
        {
1174
829
            *ps_ref_pic_lx[idx + MAX_REF_BUFS] = *ps_ref_pic_buf_lx[idx];
1175
829
            ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf1 =
1176
829
                            ps_ref_pic_buf_lx[idx]->pu1_buf1 + u2_frm_wd_y;
1177
829
            ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf2 =
1178
829
                            ps_ref_pic_buf_lx[idx]->pu1_buf2 + u2_frm_wd_uv;
1179
829
            ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf3 =
1180
829
                            ps_ref_pic_buf_lx[idx]->pu1_buf3 + u2_frm_wd_uv;
1181
829
            ps_ref_pic_lx[idx + MAX_REF_BUFS]->u1_pic_type = BOT_FLD;
1182
829
            ps_ref_pic_lx[idx + MAX_REF_BUFS]->i4_poc =
1183
829
                            ps_ref_pic_buf_lx[idx]->i4_bottom_field_order_cnt;
1184
1185
829
            if(ps_ref_pic_buf_lx[idx]->u1_picturetype & 0x3)
1186
101
            {
1187
101
                ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_col_zero_flag =
1188
101
                                ps_ref_pic_buf_lx[idx]->pu1_col_zero_flag
1189
101
                                                + u4_half_num_of_sub_mbs;
1190
101
                ps_ref_pic_lx[idx + MAX_REF_BUFS]->ps_mv =
1191
101
                                ps_ref_pic_buf_lx[idx]->ps_mv
1192
101
                                                + u4_half_num_of_sub_mbs;
1193
101
            }
1194
829
        }
1195
510
    }
1196
1.35k
}
1197
static int poc_compare(const void *pv_pic1, const void *pv_pic2)
1198
25.1k
{
1199
25.1k
    struct pic_buffer_t *ps_pic1 = *(struct pic_buffer_t **) pv_pic1;
1200
25.1k
    struct pic_buffer_t *ps_pic2 = *(struct pic_buffer_t **) pv_pic2;
1201
25.1k
    if (ps_pic1->i4_poc < ps_pic2->i4_poc)
1202
7.22k
    {
1203
7.22k
        return -1;
1204
7.22k
    }
1205
17.9k
    else if (ps_pic1->i4_poc > ps_pic2->i4_poc)
1206
16.5k
    {
1207
16.5k
        return 1;
1208
16.5k
    }
1209
1.42k
    else
1210
1.42k
    {
1211
1.42k
        return 0;
1212
1.42k
    }
1213
25.1k
}
1214
/*!
1215
 **************************************************************************
1216
 * \if Function name : ih264d_init_ref_idx_lx_b \endif
1217
 *
1218
 * \brief
1219
 *    Initializes forward and backward refernce lists for B slice decoding.
1220
 *
1221
 *
1222
 * \return
1223
 *    0 on Success and Error code otherwise
1224
 **************************************************************************
1225
 */
1226
void ih264d_init_ref_idx_lx_b(dec_struct_t *ps_dec)
1227
41.0k
{
1228
41.0k
    struct pic_buffer_t *ps_ref_pic_buf_lx;
1229
41.0k
    dpb_manager_t *ps_dpb_mgr;
1230
41.0k
    struct dpb_info_t *ps_next_dpb;
1231
41.0k
    WORD32 i_cur_poc, i_max_st_poc, i_min_st_poc, i_ref_poc, i_temp_poc;
1232
41.0k
    WORD8 i, j;
1233
41.0k
    UWORD8 u1_max_lt_index, u1_min_lt_index;
1234
41.0k
    UWORD32 u4_lt_index;
1235
41.0k
    WORD32 i_cur_idx;
1236
41.0k
    UWORD8 u1_field_pic_flag;
1237
41.0k
    dec_slice_params_t *ps_cur_slice;
1238
41.0k
    UWORD8 u1_L0, u1_L1;
1239
41.0k
    UWORD8 u1_num_short_term_bufs;
1240
41.0k
    UWORD8 u1_max_ref_idx_l0, u1_max_ref_idx_l1;
1241
41.0k
    struct pic_buffer_t *aps_st_pic_bufs[2 * MAX_REF_BUFS] = {NULL};
1242
41.0k
    ps_cur_slice = ps_dec->ps_cur_slice;
1243
41.0k
    u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
1244
41.0k
    u1_max_ref_idx_l0 = ps_cur_slice->u1_num_ref_idx_lx_active[0]
1245
41.0k
                    << u1_field_pic_flag;
1246
41.0k
    u1_max_ref_idx_l1 = ps_cur_slice->u1_num_ref_idx_lx_active[1]
1247
41.0k
                    << u1_field_pic_flag;
1248
1249
41.0k
    ps_dpb_mgr = ps_dec->ps_dpb_mgr;
1250
    /* Get the current POC */
1251
41.0k
    i_cur_poc = ps_dec->ps_cur_pic->i4_poc;
1252
1253
    /* Get MaxStPOC,MinStPOC,MaxLt,MinLt */
1254
41.0k
    i_max_st_poc = i_cur_poc;
1255
41.0k
    i_min_st_poc = i_cur_poc;
1256
41.0k
    u1_max_lt_index = MAX_REF_BUFS + 1;
1257
41.0k
    u1_min_lt_index = MAX_REF_BUFS + 1;
1258
    /* Start from ST head */
1259
41.0k
    ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head;
1260
81.5k
    for(i = 0; i < ps_dpb_mgr->u1_num_st_ref_bufs; i++)
1261
40.4k
    {
1262
40.4k
        i_ref_poc = ps_next_dpb->ps_pic_buf->i4_poc;
1263
40.4k
        if(i_ref_poc < i_cur_poc)
1264
16.5k
        {
1265
            /* RefPic Buf POC is before Current POC in display order */
1266
16.5k
            i_min_st_poc = MIN(i_min_st_poc, i_ref_poc);
1267
16.5k
        }
1268
23.9k
        else
1269
23.9k
        {
1270
            /* RefPic Buf POC is after Current POC in display order */
1271
23.9k
            i_max_st_poc = MAX(i_max_st_poc, i_ref_poc);
1272
23.9k
        }
1273
1274
        /* Chase the next link */
1275
40.4k
        ps_next_dpb = ps_next_dpb->ps_prev_short;
1276
40.4k
    }
1277
1278
    /* Sort ST ref pocs in ascending order */
1279
41.0k
    ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head;
1280
81.5k
    for (j = 0; j < ps_dpb_mgr->u1_num_st_ref_bufs; j++)
1281
40.4k
    {
1282
40.4k
        aps_st_pic_bufs[j] = ps_next_dpb->ps_pic_buf;
1283
40.4k
        ps_next_dpb = ps_next_dpb->ps_prev_short;
1284
40.4k
    }
1285
41.0k
    qsort(aps_st_pic_bufs, ps_dpb_mgr->u1_num_st_ref_bufs,
1286
41.0k
        sizeof(aps_st_pic_bufs[0]), poc_compare);
1287
1288
    /* Start from LT head */
1289
41.0k
    ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head;
1290
41.0k
    if(ps_next_dpb)
1291
3.93k
    {
1292
3.93k
        u1_max_lt_index = ps_next_dpb->u1_lt_idx;
1293
3.93k
        u1_min_lt_index = ps_next_dpb->u1_lt_idx;
1294
3.93k
    }
1295
45.8k
    for(i = 0; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++)
1296
4.78k
    {
1297
4.78k
        u4_lt_index = ps_next_dpb->u1_lt_idx;
1298
4.78k
        u1_max_lt_index = (UWORD8)(MAX(u1_max_lt_index, u4_lt_index));
1299
4.78k
        u1_min_lt_index = (UWORD8)(MIN(u1_min_lt_index, u4_lt_index));
1300
1301
        /* Chase the next link */
1302
4.78k
        ps_next_dpb = ps_next_dpb->ps_prev_long;
1303
4.78k
    }
1304
1305
    /* 1. Initialize refIdxL0 */
1306
41.0k
    u1_L0 = 0;
1307
41.0k
    i_temp_poc = i_cur_poc;
1308
41.0k
    if(u1_field_pic_flag)
1309
2.41k
    {
1310
2.41k
        ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0];
1311
2.41k
        ps_ref_pic_buf_lx += MAX_REF_BUFS;
1312
2.41k
    }
1313
38.6k
    else
1314
38.6k
    {
1315
38.6k
        ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0];
1316
        /* Avoid integer overflow while decrementing by one */
1317
38.6k
        if (i_temp_poc > INT32_MIN)
1318
38.6k
            i_temp_poc--;
1319
38.6k
    }
1320
1321
41.0k
    i_cur_idx = -1;
1322
81.5k
    for(j = 0; j < ps_dpb_mgr->u1_num_st_ref_bufs; j++)
1323
40.4k
    {
1324
40.4k
        if (NULL == aps_st_pic_bufs[j])
1325
0
        {
1326
0
            break;
1327
0
        }
1328
40.4k
        if (aps_st_pic_bufs[j]->i4_poc <= i_temp_poc)
1329
17.5k
        {
1330
17.5k
            i_cur_idx = j;
1331
17.5k
        }
1332
40.4k
    }
1333
    /* Arrange all short term buffers in output order as given by POC */
1334
    /* 1.1 Arrange POC's less than CurrPOC in the descending POC order starting
1335
     from (CurrPOC - 1)*/
1336
58.6k
    for(j = i_cur_idx; j >= 0; j--)
1337
17.5k
    {
1338
17.5k
        if(aps_st_pic_bufs[j])
1339
17.5k
        {
1340
            /* Copy info in pic buffer */
1341
17.5k
            ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1342
17.5k
                                               aps_st_pic_bufs[j]);
1343
17.5k
            ps_ref_pic_buf_lx++;
1344
17.5k
            u1_L0++;
1345
17.5k
        }
1346
17.5k
    }
1347
1348
    /* 1.2. Arrange POC's more than CurrPOC in the ascending POC order starting
1349
     from (CurrPOC + 1)*/
1350
63.9k
    for(j = i_cur_idx + 1; j < ps_dpb_mgr->u1_num_st_ref_bufs; j++)
1351
22.8k
    {
1352
22.8k
        if(aps_st_pic_bufs[j])
1353
22.8k
        {
1354
22.8k
            ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1355
22.8k
                                               aps_st_pic_bufs[j]);
1356
22.8k
            ps_ref_pic_buf_lx++;
1357
22.8k
            u1_L0++;
1358
22.8k
        }
1359
22.8k
    }
1360
1361
    /* 1.3 Arrange all Long term buffers in ascending order, in LongtermIndex */
1362
    /* Start from ST head */
1363
1364
41.0k
    u1_num_short_term_bufs = u1_L0;
1365
83.8k
    for(u4_lt_index = u1_min_lt_index; u4_lt_index <= u1_max_lt_index; u4_lt_index++)
1366
42.7k
    {
1367
42.7k
        ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head;
1368
45.7k
        for(i = 0; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++)
1369
7.77k
        {
1370
7.77k
            if(ps_next_dpb->u1_lt_idx == u4_lt_index)
1371
4.73k
            {
1372
4.73k
                ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1373
4.73k
                                                   ps_next_dpb->ps_pic_buf);
1374
4.73k
                ps_ref_pic_buf_lx->u1_long_term_pic_num =
1375
4.73k
                                ps_ref_pic_buf_lx->u1_long_term_frm_idx;
1376
1377
4.73k
                ps_ref_pic_buf_lx++;
1378
4.73k
                u1_L0++;
1379
4.73k
                break;
1380
4.73k
            }
1381
3.04k
            ps_next_dpb = ps_next_dpb->ps_prev_long;
1382
3.04k
        }
1383
42.7k
    }
1384
1385
41.0k
    if(u1_field_pic_flag)
1386
2.41k
    {
1387
        /* Initialize the rest of the entries in the */
1388
        /* reference list to handle of errors        */
1389
2.41k
        {
1390
2.41k
            UWORD8 u1_i;
1391
2.41k
            pic_buffer_t ref_pic;
1392
1393
2.41k
            ref_pic = *(ps_dpb_mgr->ps_init_dpb[0][0] + MAX_REF_BUFS);
1394
1395
2.41k
            if(NULL == ref_pic.pu1_buf1)
1396
0
            {
1397
0
                ref_pic = *ps_dec->ps_cur_pic;
1398
0
            }
1399
6.87k
            for(u1_i = u1_L0; u1_i < u1_max_ref_idx_l0; u1_i++)
1400
4.46k
            {
1401
4.46k
                *ps_ref_pic_buf_lx = ref_pic;
1402
4.46k
                ps_ref_pic_buf_lx++;
1403
4.46k
            }
1404
2.41k
        }
1405
2.41k
        ih264d_convert_frm_to_fld_list(
1406
2.41k
                        ps_dpb_mgr->ps_init_dpb[0][0] + MAX_REF_BUFS, &u1_L0,
1407
2.41k
                        ps_dec, u1_num_short_term_bufs);
1408
1409
2.41k
        ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0] + u1_L0;
1410
2.41k
    }
1411
1412
41.0k
    ps_dec->ps_cur_slice->u1_initial_list_size[0] = u1_L0;
1413
1414
    /* Initialize the rest of the entries in the */
1415
    /* reference list to handle of errors        */
1416
41.0k
    {
1417
41.0k
        UWORD8 u1_i;
1418
41.0k
        pic_buffer_t ref_pic;
1419
1420
41.0k
        ref_pic = *(ps_dpb_mgr->ps_init_dpb[0][0]);
1421
1422
41.0k
        if(NULL == ref_pic.pu1_buf1)
1423
0
        {
1424
0
            ref_pic = *ps_dec->ps_cur_pic;
1425
0
        }
1426
102k
        for(u1_i = u1_L0; u1_i < u1_max_ref_idx_l0; u1_i++)
1427
60.9k
        {
1428
60.9k
            *ps_ref_pic_buf_lx = ref_pic;
1429
60.9k
            ps_ref_pic_buf_lx++;
1430
60.9k
        }
1431
41.0k
    }
1432
41.0k
    {
1433
        /* 2. Initialize refIdxL1 */
1434
41.0k
        u1_L1 = 0;
1435
41.0k
        if(u1_field_pic_flag)
1436
2.41k
        {
1437
2.41k
            ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[1][0] + MAX_REF_BUFS;
1438
2.41k
        }
1439
38.6k
        else
1440
38.6k
        {
1441
38.6k
            ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[1][0];
1442
38.6k
        }
1443
1444
        /* 2.1. Arrange POC's more than CurrPOC in the ascending POC order starting
1445
         from (CurrPOC + 1)*/
1446
63.9k
        for(j = i_cur_idx + 1; j < ps_dpb_mgr->u1_num_st_ref_bufs; j++)
1447
22.8k
        {
1448
22.8k
            if(aps_st_pic_bufs[j])
1449
22.8k
            {
1450
                /* Start from ST head */
1451
22.8k
                ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1452
22.8k
                                                   aps_st_pic_bufs[j]);
1453
22.8k
                ps_ref_pic_buf_lx++;
1454
22.8k
                u1_L1++;
1455
22.8k
            }
1456
22.8k
        }
1457
1458
        /* Arrange all short term buffers in output order as given by POC */
1459
        /* 2.2 Arrange POC's less than CurrPOC in the descending POC order starting
1460
         from (CurrPOC - 1)*/
1461
58.6k
        for(j = i_cur_idx; j >= 0; j--)
1462
17.5k
        {
1463
17.5k
            if(aps_st_pic_bufs[j])
1464
17.5k
            {
1465
17.5k
                ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1466
17.5k
                                                   aps_st_pic_bufs[j]);
1467
17.5k
                ps_ref_pic_buf_lx++;
1468
17.5k
                u1_L1++;
1469
17.5k
            }
1470
17.5k
        }
1471
1472
        /* 2.3 Arrange all Long term buffers in ascending order, in LongtermIndex */
1473
        /* Start from ST head */
1474
41.0k
        u1_num_short_term_bufs = u1_L1;
1475
1476
83.8k
        for(u4_lt_index = u1_min_lt_index; u4_lt_index <= u1_max_lt_index;
1477
42.7k
                        u4_lt_index++)
1478
42.7k
        {
1479
42.7k
            ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head;
1480
45.7k
            for(i = 0; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++)
1481
7.77k
            {
1482
7.77k
                if(ps_next_dpb->u1_lt_idx == u4_lt_index)
1483
4.73k
                {
1484
4.73k
                    ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1485
4.73k
                                                       ps_next_dpb->ps_pic_buf);
1486
4.73k
                    ps_ref_pic_buf_lx->u1_long_term_pic_num =
1487
4.73k
                                    ps_ref_pic_buf_lx->u1_long_term_frm_idx;
1488
4.73k
                    ps_ref_pic_buf_lx++;
1489
4.73k
                    u1_L1++;
1490
4.73k
                    break;
1491
4.73k
                }
1492
3.04k
                ps_next_dpb = ps_next_dpb->ps_prev_long;
1493
3.04k
            }
1494
42.7k
        }
1495
1496
41.0k
        if(u1_field_pic_flag)
1497
2.41k
        {
1498
            /* Initialize the rest of the entries in the */
1499
            /* reference list to handle of errors        */
1500
2.41k
            {
1501
2.41k
                UWORD8 u1_i;
1502
2.41k
                pic_buffer_t ref_pic;
1503
1504
2.41k
                ref_pic = *(ps_dpb_mgr->ps_init_dpb[0][0] + MAX_REF_BUFS);
1505
1506
2.41k
                if(NULL == ref_pic.pu1_buf1)
1507
0
                {
1508
0
                    ref_pic = *ps_dec->ps_cur_pic;
1509
0
                }
1510
6.19k
                for(u1_i = u1_L1; u1_i < u1_max_ref_idx_l1; u1_i++)
1511
3.78k
                {
1512
3.78k
                    *ps_ref_pic_buf_lx = ref_pic;
1513
3.78k
                    ps_ref_pic_buf_lx++;
1514
3.78k
                }
1515
2.41k
            }
1516
1517
2.41k
            ih264d_convert_frm_to_fld_list(
1518
2.41k
                            ps_dpb_mgr->ps_init_dpb[1][0] + MAX_REF_BUFS,
1519
2.41k
                            &u1_L1, ps_dec, u1_num_short_term_bufs);
1520
2.41k
            ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[1][0] + u1_L1;
1521
2.41k
        }
1522
1523
41.0k
        ps_dec->ps_cur_slice->u1_initial_list_size[1] = u1_L1;
1524
1525
        /* Initialize the rest of the entries in the */
1526
        /* reference list to handle of errors        */
1527
41.0k
        {
1528
41.0k
            UWORD8 u1_i;
1529
41.0k
            pic_buffer_t ref_pic;
1530
1531
41.0k
            ref_pic = *(ps_dpb_mgr->ps_init_dpb[0][0]);
1532
1533
41.0k
            if(NULL == ref_pic.pu1_buf1)
1534
0
            {
1535
0
                ref_pic = *ps_dec->ps_cur_pic;
1536
0
            }
1537
97.0k
            for(u1_i = u1_L1; u1_i < u1_max_ref_idx_l1; u1_i++)
1538
55.9k
            {
1539
55.9k
                *ps_ref_pic_buf_lx = ref_pic;
1540
55.9k
                ps_ref_pic_buf_lx++;
1541
55.9k
            }
1542
41.0k
        }
1543
1544
        /* If list0 and list 1 ebtries are same then swap the 0th and 1st entry */
1545
        /* of list 1                                                            */
1546
41.0k
        {
1547
41.0k
            struct pic_buffer_t *ps_ref_pic1_buf_l0, *ps_ref_pic1_buf_l1;
1548
41.0k
            struct pic_buffer_t s_ref_pic1_buf_temp;
1549
1550
41.0k
            ps_ref_pic1_buf_l0 = ps_dpb_mgr->ps_init_dpb[0][0];
1551
41.0k
            ps_ref_pic1_buf_l1 = ps_dpb_mgr->ps_init_dpb[1][0];
1552
1553
41.0k
            if((u1_L0 == u1_L1) && (u1_L0 > 1))
1554
6.97k
            {
1555
6.97k
                WORD32 i_index, i_swap;
1556
1557
6.97k
                i_swap = 1;
1558
1559
23.4k
                for(i_index = 0; i_index < u1_L0; i_index++)
1560
18.4k
                {
1561
18.4k
                    if((ps_ref_pic1_buf_l0[i_index]).pu1_buf1
1562
18.4k
                                    != (ps_ref_pic1_buf_l1[i_index]).pu1_buf1)
1563
1.99k
                    {
1564
1.99k
                        i_swap = 0;
1565
1.99k
                        break;
1566
1.99k
                    }
1567
18.4k
                }
1568
6.97k
                if(1 == i_swap)
1569
4.97k
                {
1570
4.97k
                    memcpy(&s_ref_pic1_buf_temp, &ps_ref_pic1_buf_l1[1],
1571
4.97k
                           sizeof(struct pic_buffer_t));
1572
4.97k
                    memcpy(&ps_ref_pic1_buf_l1[1], &ps_ref_pic1_buf_l1[0],
1573
4.97k
                           sizeof(struct pic_buffer_t));
1574
4.97k
                    memcpy(&ps_ref_pic1_buf_l1[0], &s_ref_pic1_buf_temp,
1575
4.97k
                           sizeof(struct pic_buffer_t));
1576
4.97k
                }
1577
6.97k
            }
1578
41.0k
        }
1579
41.0k
    }
1580
41.0k
}
1581
1582
1583
1584
void ih264d_get_implicit_weights(dec_struct_t *ps_dec);
1585
1586
/*!
1587
 **************************************************************************
1588
 * \if Function name : ih264d_one_to_one \endif
1589
 *
1590
 * \brief
1591
 *    Initializes forward and backward refernce lists for B slice decoding.
1592
 *
1593
 *
1594
 * \return
1595
 *    0 on Success and Error code otherwise
1596
 **************************************************************************
1597
 */
1598
void ih264d_one_to_one(dec_struct_t *ps_dec,
1599
                       struct pic_buffer_t *ps_col_pic,
1600
                       directmv_t *ps_direct,
1601
                       UWORD8 u1_wd_x,
1602
                       WORD32 u2_sub_mb_ofst,
1603
                       dec_mb_info_t * ps_cur_mb_info)
1604
5.77M
{
1605
5.77M
    UWORD8 *pu1_col_zero_flag_start, u1_col_mb_pred_mode, u1_num_blks, u1_sub_mb_num;
1606
5.77M
    UWORD8 u1_init_colzero_flag;
1607
5.77M
    UNUSED(ps_cur_mb_info);
1608
5.77M
    pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
1609
5.77M
    u1_col_mb_pred_mode = pu1_col_zero_flag_start[ps_dec->u1_sub_mb_num];
1610
5.77M
    u1_init_colzero_flag = u1_col_mb_pred_mode & 1;
1611
5.77M
    u1_col_mb_pred_mode >>= 6;
1612
5.77M
    ps_direct->u1_vert_mv_scale = ONE_TO_ONE;
1613
5.77M
    ps_direct->u1_col_zeroflag_change = 0;
1614
1615
5.77M
    if(u1_wd_x == MB_SIZE)
1616
5.75M
    {
1617
5.75M
        ps_dec->u1_currB_type = (!!u1_col_mb_pred_mode);
1618
5.75M
        if(u1_col_mb_pred_mode == PRED_16x16)
1619
5.70M
        {
1620
5.70M
            ps_direct->i1_num_partitions = 1;
1621
5.70M
            ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
1622
5.70M
            ps_direct->i1_submb_num[0] = 0;
1623
5.70M
            ps_direct->i1_partitionsize[0] = PRED_16x16;
1624
1625
5.70M
            return;
1626
5.70M
        }
1627
50.0k
        else if(u1_col_mb_pred_mode < PRED_8x8)
1628
34.3k
        {
1629
34.3k
            ps_direct->i1_num_partitions = 2;
1630
34.3k
            ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
1631
34.3k
            ps_direct->i1_submb_num[0] = 0;
1632
34.3k
            ps_direct->i1_partitionsize[0] = u1_col_mb_pred_mode;
1633
34.3k
            u1_sub_mb_num = (u1_col_mb_pred_mode == PRED_16x8) ? 8 : 2;
1634
34.3k
            ps_direct->i1_submb_num[1] = u1_sub_mb_num;
1635
34.3k
            ps_direct->i4_mv_indices[1] = u2_sub_mb_ofst
1636
34.3k
                            + ps_direct->i1_submb_num[1];
1637
34.3k
            ps_direct->i1_partitionsize[1] = u1_col_mb_pred_mode;
1638
34.3k
            if((pu1_col_zero_flag_start[u1_sub_mb_num] & 1) != u1_init_colzero_flag)
1639
6.79k
                ps_direct->u1_col_zeroflag_change = 1;
1640
34.3k
            return;
1641
34.3k
        }
1642
15.7k
        else
1643
15.7k
        {
1644
15.7k
            u1_num_blks = 4;
1645
15.7k
        }
1646
5.75M
    }
1647
21.6k
    else
1648
21.6k
    {
1649
21.6k
        u1_num_blks = 1;
1650
21.6k
    }
1651
1652
37.4k
    {
1653
37.4k
        const UWORD8 *pu1_top_lt_mb_part_idx;
1654
37.4k
        UWORD8 u1_col_sub_mb_pred_mode, uc_blk, u1_sub_blk, u1_submb_col = 0;
1655
37.4k
        UWORD8 u1_num_sub_blks, uc_direct8x8inf, *pu1_col_zero_flag, u1_sub_mb_num;
1656
37.4k
        const UWORD8 *pu1_num_sub_mb_part =
1657
37.4k
                        (const UWORD8 *)gau1_ih264d_num_submb_part;
1658
37.4k
        UWORD8 i1_num_partitions = 0, partition_size;
1659
37.4k
        WORD32 mv_index;
1660
37.4k
        const UWORD8 *pu1_top_lt_sub_mb_idx = gau1_ih264d_submb_indx_mod_sp_drct;
1661
1662
37.4k
        u1_sub_mb_num = ps_dec->u1_sub_mb_num;
1663
37.4k
        uc_direct8x8inf = ps_dec->ps_cur_slice->u1_direct_8x8_inference_flag;
1664
37.4k
        pu1_top_lt_mb_part_idx = gau1_ih264d_top_left_mb_part_indx_mod
1665
37.4k
                        + (PRED_8x8 << 1) + 1;
1666
1667
122k
        for(uc_blk = 0; uc_blk < u1_num_blks; uc_blk++)
1668
84.7k
        {
1669
84.7k
            partition_size = PRED_8x8;
1670
84.7k
            pu1_top_lt_sub_mb_idx = gau1_ih264d_submb_indx_mod_sp_drct;
1671
84.7k
            if(uc_direct8x8inf == 1)
1672
54.9k
            {
1673
54.9k
                u1_submb_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
1674
54.9k
                mv_index = u2_sub_mb_ofst + u1_submb_col;
1675
54.9k
                u1_num_sub_blks = 1;
1676
54.9k
            }
1677
29.8k
            else
1678
29.8k
            {
1679
                /* colMbPart is either 8x8, 8x4, 4x8, 4x4 */
1680
29.8k
                pu1_col_zero_flag = pu1_col_zero_flag_start + u1_sub_mb_num;
1681
29.8k
                u1_col_sub_mb_pred_mode = *pu1_col_zero_flag;
1682
29.8k
                u1_col_sub_mb_pred_mode = (u1_col_sub_mb_pred_mode & 0x30) >> 4;
1683
29.8k
                partition_size = (UWORD8)((u1_col_sub_mb_pred_mode)
1684
29.8k
                                | (PRED_8x8 << 2));
1685
29.8k
                mv_index = u2_sub_mb_ofst + u1_sub_mb_num;
1686
29.8k
                pu1_top_lt_sub_mb_idx += (u1_col_sub_mb_pred_mode << 1);
1687
29.8k
                u1_num_sub_blks = pu1_num_sub_mb_part[u1_col_sub_mb_pred_mode];
1688
1689
29.8k
            }
1690
1691
182k
            for(u1_sub_blk = 0; u1_sub_blk < u1_num_sub_blks;
1692
97.4k
                            u1_sub_blk++, pu1_top_lt_sub_mb_idx++)
1693
97.4k
            {
1694
97.4k
                u1_sub_mb_num += *pu1_top_lt_sub_mb_idx;
1695
97.4k
                mv_index += *pu1_top_lt_sub_mb_idx;
1696
97.4k
                ps_direct->i4_mv_indices[i1_num_partitions] = mv_index;
1697
97.4k
                ps_direct->i1_submb_num[i1_num_partitions] = u1_sub_mb_num;
1698
97.4k
                ps_direct->i1_partitionsize[i1_num_partitions] = partition_size;
1699
97.4k
                i1_num_partitions++;
1700
97.4k
                if(!uc_direct8x8inf)
1701
42.4k
                    u1_submb_col = u1_sub_mb_num;
1702
97.4k
                if((pu1_col_zero_flag_start[u1_submb_col] & 1)
1703
97.4k
                                != u1_init_colzero_flag)
1704
13.5k
                    ps_direct->u1_col_zeroflag_change = 1;
1705
97.4k
            }
1706
84.7k
            u1_sub_mb_num = *pu1_top_lt_mb_part_idx++;
1707
84.7k
        }
1708
37.4k
        ps_direct->i1_num_partitions = i1_num_partitions;
1709
37.4k
    }
1710
37.4k
}
1711
/*!
1712
 **************************************************************************
1713
 * \if Function name : ih264d_mbaff_cross_pmbair \endif
1714
 *
1715
 * \brief
1716
 *    Initializes forward and backward refernce lists for B slice decoding.
1717
 *
1718
 *
1719
 * \return
1720
 *    0 on Success and Error code otherwise
1721
 **************************************************************************
1722
 */
1723
void ih264d_mbaff_cross_pmbair(dec_struct_t *ps_dec,
1724
                               struct pic_buffer_t *ps_col_pic,
1725
                               directmv_t *ps_direct,
1726
                               UWORD8 u1_wd_x,
1727
                               WORD32 u2_sub_mb_ofst,
1728
                               dec_mb_info_t * ps_cur_mb_info)
1729
11.4k
{
1730
11.4k
    UWORD8 *pu1_col_zero_flag_start, *pu1_col_zero_flag, u1_sub_mb_num,
1731
11.4k
                    uc_sub_mb_num_col;
1732
11.4k
    UWORD8 *pu1_col_zero_flag_right_half;
1733
11.4k
    WORD32 i4_force_8X8;
1734
11.4k
    UWORD8 u1_num_blks, u1_col_mb_pred_mode, uc_blk, u1_col_sub_mb_pred_mode,
1735
11.4k
                    u1_col_sub_mb_pred_mode_rt;
1736
11.4k
    UWORD8 i1_num_partitions = 0, partition_size;
1737
1738
11.4k
    WORD32 mv_index;
1739
1740
11.4k
    UWORD8 u1_num_sub_blks;
1741
11.4k
    UWORD8 u1_is_cur_mb_fld, i;
1742
11.4k
    UWORD8 u1_init_colzero_flag;
1743
1744
11.4k
    u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
1745
11.4k
    u1_sub_mb_num = ps_dec->u1_sub_mb_num;
1746
11.4k
    ps_direct->u1_col_zeroflag_change = 0;
1747
    /*pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
1748
     u1_col_mb_pred_mode = pu1_col_zero_flag_start[u1_sub_mb_num];
1749
     u1_init_colzero_flag = u1_col_mb_pred_mode & 1;
1750
     u1_col_mb_pred_mode >>= 6; */
1751
11.4k
    if(0 == u1_is_cur_mb_fld)
1752
6.55k
    {
1753
6.55k
        ps_direct->u1_vert_mv_scale = FLD_TO_FRM;
1754
6.55k
        if(u1_wd_x == MB_SIZE)
1755
6.55k
        {
1756
6.55k
            pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag
1757
6.55k
                            + u2_sub_mb_ofst;
1758
6.55k
            u1_col_mb_pred_mode = pu1_col_zero_flag_start[0];
1759
6.55k
            u1_init_colzero_flag = u1_col_mb_pred_mode & 1;
1760
6.55k
            u1_col_mb_pred_mode >>= 6;
1761
1762
1763
6.55k
            if(u1_col_mb_pred_mode & 0x2)
1764
1.12k
            {
1765
1.12k
                ps_dec->u1_currB_type = 1;
1766
1.12k
                if(u1_col_mb_pred_mode == PRED_8x16)
1767
51
                {
1768
51
                    ps_direct->i1_num_partitions = 2;
1769
51
                    ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
1770
51
                    ps_direct->i1_submb_num[0] = 0;
1771
51
                    ps_direct->i1_partitionsize[0] = PRED_8x16;
1772
51
                    ps_direct->i4_mv_indices[1] = u2_sub_mb_ofst + 2;
1773
51
                    ps_direct->i1_submb_num[1] = 2;
1774
51
                    ps_direct->i1_partitionsize[1] = PRED_8x16;
1775
51
                    if((pu1_col_zero_flag_start[2] & 1) != u1_init_colzero_flag)
1776
14
                        ps_direct->u1_col_zeroflag_change = 1;
1777
51
                }
1778
1.07k
                else
1779
1.07k
                {
1780
1.07k
                    pu1_col_zero_flag = pu1_col_zero_flag_start + u1_sub_mb_num;
1781
1.07k
                    u1_col_sub_mb_pred_mode = (*pu1_col_zero_flag & 0x10);/* 8x4 or 4x4 mode */
1782
1783
1.07k
                    pu1_col_zero_flag_right_half = pu1_col_zero_flag_start
1784
1.07k
                                    + u1_sub_mb_num + 2;
1785
1.07k
                    u1_col_sub_mb_pred_mode_rt =
1786
1.07k
                                    (*pu1_col_zero_flag_right_half & 0x10);/* 8x4 or 4x4 mode */
1787
1788
1.07k
                    i4_force_8X8 = (u1_col_sub_mb_pred_mode)
1789
758
                                    || (u1_col_sub_mb_pred_mode_rt);
1790
1.07k
                    if(i4_force_8X8)
1791
446
                    {
1792
446
                        u1_num_sub_blks = 2;
1793
446
                        partition_size = PRED_8x8;
1794
446
                    }
1795
629
                    else
1796
629
                    {
1797
629
                        partition_size = PRED_8x16;
1798
629
                        u1_num_sub_blks = 1;
1799
629
                    }
1800
1801
3.22k
                    for(i = 0; i < 2; i++)
1802
2.15k
                    {
1803
5.19k
                        for(uc_blk = 0; uc_blk < u1_num_sub_blks; uc_blk++)
1804
3.04k
                        {
1805
3.04k
                            uc_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
1806
3.04k
                            uc_sub_mb_num_col &= 0x7;
1807
3.04k
                            mv_index = u2_sub_mb_ofst + uc_sub_mb_num_col;
1808
1809
3.04k
                            ps_direct->i4_mv_indices[i1_num_partitions] =
1810
3.04k
                                            mv_index;
1811
3.04k
                            ps_direct->i1_submb_num[i1_num_partitions] =
1812
3.04k
                                            u1_sub_mb_num;
1813
3.04k
                            ps_direct->i1_partitionsize[i1_num_partitions] =
1814
3.04k
                                            partition_size;
1815
3.04k
                            i1_num_partitions++;
1816
3.04k
                            if((pu1_col_zero_flag_start[uc_sub_mb_num_col] & 1)
1817
3.04k
                                            != u1_init_colzero_flag)
1818
361
                                ps_direct->u1_col_zeroflag_change = 1;
1819
3.04k
                            u1_sub_mb_num += 8;
1820
3.04k
                        }
1821
2.15k
                        u1_sub_mb_num = 2; /* move to second half of Cur MB */
1822
2.15k
                    }
1823
1.07k
                    ps_direct->i1_num_partitions = i1_num_partitions;
1824
1.07k
                    return;
1825
1.07k
                }
1826
1.12k
            }
1827
5.42k
            else
1828
5.42k
            {
1829
5.42k
                ps_direct->i1_num_partitions = 1;
1830
5.42k
                ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
1831
5.42k
                ps_direct->i1_submb_num[0] = 0;
1832
5.42k
                ps_direct->i1_partitionsize[0] = PRED_16x16;
1833
5.42k
                ps_dec->u1_currB_type = 0;
1834
5.42k
                return;
1835
5.42k
            }
1836
6.55k
        }
1837
5
        else
1838
5
        {
1839
5
            uc_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
1840
5
            uc_sub_mb_num_col &= 0x7;
1841
1842
5
            ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst + uc_sub_mb_num_col;
1843
5
            ps_direct->i1_submb_num[0] = u1_sub_mb_num;
1844
5
            ps_direct->i1_partitionsize[0] = PRED_8x8;
1845
5
            ps_direct->i1_num_partitions = 1;
1846
5
        }
1847
6.55k
    }
1848
4.85k
    else
1849
4.85k
    {
1850
4.85k
        ps_direct->u1_vert_mv_scale = FRM_TO_FLD;
1851
4.85k
        pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
1852
4.85k
        u1_init_colzero_flag = pu1_col_zero_flag_start[0] & 1;
1853
1854
4.85k
        if(u1_wd_x == MB_SIZE)
1855
4.54k
        {
1856
4.54k
            UWORD8 u1_submb_col;
1857
4.54k
            UWORD8 *puc_colZeroFlagStart_bot_mb, uc_colMbPredMode_bot_mb;
1858
1859
4.54k
            pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag
1860
4.54k
                            + u2_sub_mb_ofst;
1861
4.54k
            u1_col_mb_pred_mode = pu1_col_zero_flag_start[u1_sub_mb_num] >> 6;
1862
1863
4.54k
            puc_colZeroFlagStart_bot_mb = ps_col_pic->pu1_col_zero_flag
1864
4.54k
                            + u2_sub_mb_ofst + 16;
1865
4.54k
            uc_colMbPredMode_bot_mb = puc_colZeroFlagStart_bot_mb[8] >> 6;
1866
1867
4.54k
            i4_force_8X8 = (u1_col_mb_pred_mode & 0x2)
1868
4.44k
                            || (uc_colMbPredMode_bot_mb & 0x2);
1869
4.54k
            if(i4_force_8X8)
1870
145
            {
1871
145
                u1_num_blks = 2;
1872
145
                partition_size = PRED_8x8;
1873
145
            }
1874
4.40k
            else
1875
4.40k
            {
1876
4.40k
                u1_num_blks = 1;
1877
4.40k
                partition_size = PRED_16x8;
1878
4.40k
            }
1879
1880
4.54k
            ps_dec->u1_currB_type = 1;
1881
            /*As this mb is derived from 2 Mbs min no of partitions = 2*/
1882
13.6k
            for(i = 0; i < 2; i++)
1883
9.09k
            {
1884
1885
9.09k
                pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag
1886
9.09k
                                + u2_sub_mb_ofst;
1887
9.09k
                u1_col_mb_pred_mode = pu1_col_zero_flag_start[u1_sub_mb_num] >> 6;
1888
1889
18.4k
                for(uc_blk = 0; uc_blk < u1_num_blks; uc_blk++)
1890
9.38k
                {
1891
9.38k
                    u1_submb_col = (u1_sub_mb_num & 0x7) ? 1 : 0;
1892
9.38k
                    u1_submb_col += u1_sub_mb_num;
1893
9.38k
                    mv_index = u2_sub_mb_ofst + u1_submb_col;
1894
1895
1896
9.38k
                    ps_direct->i4_mv_indices[i1_num_partitions] = mv_index;
1897
9.38k
                    ps_direct->i1_submb_num[i1_num_partitions] = u1_sub_mb_num;
1898
9.38k
                    ps_direct->i1_partitionsize[i1_num_partitions] =
1899
9.38k
                                    partition_size;
1900
9.38k
                    i1_num_partitions++;
1901
9.38k
                    if((pu1_col_zero_flag_start[u1_submb_col] & 1)
1902
9.38k
                                    != u1_init_colzero_flag)
1903
1.98k
                        ps_direct->u1_col_zeroflag_change = 1;
1904
9.38k
                    u1_sub_mb_num += 2;
1905
9.38k
                }
1906
9.09k
                u1_sub_mb_num = 8; /* move to second half of Cur MB */
1907
9.09k
                u2_sub_mb_ofst += 16;/* move to next Colocated MB */
1908
9.09k
            }
1909
4.54k
            ps_direct->i1_num_partitions = i1_num_partitions;
1910
4.54k
            return;
1911
4.54k
        }
1912
309
        else
1913
309
        {
1914
309
            uc_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
1915
309
            uc_sub_mb_num_col &= 0xb;
1916
309
            u2_sub_mb_ofst += (u1_sub_mb_num >> 3) ? 16 : 0;
1917
1918
309
            ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst + uc_sub_mb_num_col;
1919
309
            ps_direct->i1_submb_num[0] = u1_sub_mb_num;
1920
309
            ps_direct->i1_partitionsize[0] = PRED_8x8;
1921
309
            ps_direct->i1_num_partitions = 1;
1922
309
            return;
1923
309
        }
1924
4.85k
    }
1925
11.4k
}
1926
/*!
1927
 **************************************************************************
1928
 * \if Function name : ih264d_cal_col_pic \endif
1929
 *
1930
 * \brief
1931
 *    Finds the colocated picture.
1932
 *
1933
 *
1934
 * \return
1935
 *    0 on Success and Error code otherwise
1936
 **************************************************************************
1937
 */
1938
WORD32 ih264d_cal_col_pic(dec_struct_t *ps_dec)
1939
55.4k
{
1940
55.4k
    struct pic_buffer_t* ps_col_pic = ps_dec->ps_col_pic;
1941
55.4k
    UWORD8 uc_curpictype, uc_colpictype;
1942
55.4k
    ps_col_pic = ps_dec->ps_ref_pic_buf_lx[1][0];
1943
55.4k
    uc_curpictype = (ps_dec->ps_cur_pic->u1_picturetype & 0x7);
1944
55.4k
    uc_colpictype = (ps_col_pic->u1_picturetype & 0x7);
1945
55.4k
    if(uc_curpictype == FRM_PIC)
1946
52.8k
    {
1947
52.8k
        if(uc_colpictype == FRM_PIC)
1948
52.7k
            ps_dec->pf_parse_mvdirect = ih264d_one_to_one;
1949
96
        else if(uc_colpictype == COMP_FLD_PAIR)
1950
51
        {
1951
51
            ps_dec->pf_parse_mvdirect = ih264d_fld_to_frm;
1952
51
            if(ps_col_pic->i4_top_field_order_cnt
1953
51
                            >= ps_col_pic->i4_bottom_field_order_cnt)
1954
31
            {
1955
31
                struct pic_buffer_t* ps_tempPic = ps_col_pic;
1956
31
                UWORD32 ui_half_num_of_sub_mbs = ((ps_dec->u2_pic_ht
1957
31
                                * ps_dec->u2_pic_wd) >> 5);
1958
31
                ps_col_pic = ps_dec->ps_ref_pic_buf_lx[1][MAX_REF_BUFS];
1959
                /* memcpy ps_tempPic to ps_col_pic */
1960
31
                *ps_col_pic = *ps_tempPic;
1961
31
                ps_col_pic->pu1_buf1 = ps_tempPic->pu1_buf1
1962
31
                                + ps_tempPic->u2_frm_wd_y;
1963
31
                ps_col_pic->pu1_buf2 = ps_tempPic->pu1_buf2
1964
31
                                + ps_tempPic->u2_frm_wd_uv;
1965
31
                ps_col_pic->pu1_buf3 = ps_tempPic->pu1_buf3
1966
31
                                + ps_tempPic->u2_frm_wd_uv;
1967
31
                ps_col_pic->pu1_col_zero_flag = ps_tempPic->pu1_col_zero_flag
1968
31
                                + ui_half_num_of_sub_mbs;
1969
31
                ps_col_pic->ps_mv = ps_tempPic->ps_mv + ui_half_num_of_sub_mbs;
1970
1971
1972
31
                ps_col_pic->u1_pic_type = 0;/*complementary reference field pair-refering as frame */
1973
1974
1975
1976
31
            }
1977
51
        }
1978
45
        else
1979
45
        {
1980
45
            UWORD32 i4_error_code;
1981
45
            i4_error_code = ERROR_DBP_MANAGER_T;
1982
//          i4_error_code |= 1<<IVD_CORRUPTEDDATA;
1983
45
            return i4_error_code;
1984
45
        }
1985
52.8k
    }
1986
2.55k
    else if(uc_curpictype == AFRM_PIC)
1987
347
    {
1988
347
        ps_dec->pf_parse_mvdirect = ih264d_fld_to_mbaff;
1989
347
    }
1990
2.21k
    else /* must be a field*/
1991
2.21k
    {
1992
2.21k
        if(uc_colpictype == FRM_PIC)
1993
556
            ps_dec->pf_parse_mvdirect = ih264d_frm_to_fld;
1994
1.65k
        else if(uc_colpictype == AFRM_PIC)
1995
451
            ps_dec->pf_parse_mvdirect = ih264d_mbaff_to_fld;
1996
1.20k
        else
1997
1.20k
            ps_dec->pf_parse_mvdirect = ih264d_one_to_one;
1998
2.21k
    }
1999
55.3k
    ps_dec->ps_col_pic = ps_col_pic;
2000
55.3k
    return OK;
2001
55.4k
}
2002
2003
/*!
2004
 **************************************************************************
2005
 * \if Function name : ih264d_frm_to_fld \endif
2006
 *
2007
 * \brief
2008
 *    Initializes forward and backward refernce lists for B slice decoding.
2009
 *
2010
 *
2011
 * \return
2012
 *    0 on Success and Error code otherwise
2013
 **************************************************************************
2014
 */
2015
void ih264d_frm_to_fld(dec_struct_t *ps_dec,
2016
                       struct pic_buffer_t *ps_col_pic,
2017
                       directmv_t *ps_direct,
2018
                       UWORD8 u1_wd_x,
2019
                       WORD32 u2_sub_mb_ofst,
2020
                       dec_mb_info_t * ps_cur_mb_info)
2021
23.2k
{
2022
23.2k
    UWORD8 *pu1_col_zero_flag_start, u1_sub_mb_num;
2023
23.2k
    UWORD8 u1_num_blks, u1_col_mb_pred_mode, uc_blk;
2024
23.2k
    UWORD8 i1_num_partitions = 0, partition_size, i;
2025
23.2k
    WORD32 mv_index;
2026
23.2k
    UWORD32 increment;
2027
23.2k
    WORD32 i4_force_8X8;
2028
23.2k
    UNUSED(ps_cur_mb_info);
2029
23.2k
    ps_direct->u1_col_zeroflag_change = 1;
2030
23.2k
    ps_direct->u1_vert_mv_scale = FRM_TO_FLD;
2031
23.2k
    u1_sub_mb_num = ps_dec->u1_sub_mb_num;
2032
2033
    /* new calculation specific to this function */
2034
23.2k
    if((ps_col_pic->u1_picturetype & 0x7) == FRM_PIC)
2035
17.7k
    {
2036
17.7k
        UWORD16 u2_frm_wd_in_mbs = ps_dec->u2_frm_wd_in_mbs;
2037
17.7k
        increment = (u2_frm_wd_in_mbs << 4);
2038
        /*mbAddrCol = mbAddrCol1 */
2039
17.7k
        u2_sub_mb_ofst = (ps_dec->u2_mbx
2040
17.7k
                        + (2 * ps_dec->u2_mby * u2_frm_wd_in_mbs)) << 4;
2041
17.7k
    }
2042
5.54k
    else
2043
5.54k
        increment = 16;
2044
2045
23.2k
    if(u1_wd_x == MB_SIZE)
2046
23.2k
    {
2047
23.2k
        ps_dec->u1_currB_type = 1;
2048
2049
23.2k
        {
2050
23.2k
            UWORD8 *puc_colZeroFlagStart_bot_mb, uc_colMbPredMode_bot_mb;
2051
2052
23.2k
            pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag
2053
23.2k
                            + u2_sub_mb_ofst;
2054
23.2k
            u1_col_mb_pred_mode = (*pu1_col_zero_flag_start >> 6);
2055
2056
23.2k
            puc_colZeroFlagStart_bot_mb = ps_col_pic->pu1_col_zero_flag
2057
23.2k
                            + u2_sub_mb_ofst + increment;
2058
23.2k
            uc_colMbPredMode_bot_mb = (*puc_colZeroFlagStart_bot_mb >> 6);
2059
2060
23.2k
            i4_force_8X8 = (u1_col_mb_pred_mode & 0x2)
2061
23.1k
                            || (uc_colMbPredMode_bot_mb & 0x2);
2062
2063
23.2k
            if(i4_force_8X8)
2064
58
            {
2065
58
                u1_num_blks = 2;
2066
58
                partition_size = PRED_8x8;
2067
58
            }
2068
23.1k
            else
2069
23.1k
            {
2070
23.1k
                partition_size = PRED_16x8;
2071
23.1k
                u1_num_blks = 1;
2072
23.1k
            }
2073
23.2k
        }
2074
2075
        /*As this mb is derived from 2 Mbs, min no of partitions = 2*/
2076
69.6k
        for(i = 0; i < 2; i++)
2077
46.4k
        {
2078
93.0k
            for(uc_blk = 0; uc_blk < u1_num_blks; uc_blk++)
2079
46.5k
            {
2080
46.5k
                mv_index = u2_sub_mb_ofst + u1_sub_mb_num;
2081
46.5k
                mv_index += (u1_sub_mb_num & 0x7) ? 1 : 0;
2082
2083
46.5k
                ps_direct->i4_mv_indices[i1_num_partitions] = mv_index;
2084
46.5k
                ps_direct->i1_submb_num[i1_num_partitions] = u1_sub_mb_num;
2085
46.5k
                ps_direct->i1_partitionsize[i1_num_partitions] = partition_size;
2086
46.5k
                i1_num_partitions++;
2087
2088
46.5k
                u1_sub_mb_num += 2;
2089
46.5k
            }
2090
46.4k
            u1_sub_mb_num = 8; /* move to second half of Cur MB */
2091
46.4k
            u2_sub_mb_ofst += increment;/* move to next Colocated MB */
2092
46.4k
        }
2093
23.2k
        ps_direct->i1_num_partitions = i1_num_partitions;
2094
23.2k
        return;
2095
23.2k
    }
2096
34
    else
2097
34
    {
2098
34
        UWORD8 u1_sub_mb_num_col;
2099
34
        u1_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
2100
34
        u1_sub_mb_num_col &= 0xb;
2101
34
        u2_sub_mb_ofst += (u1_sub_mb_num >> 3) ? increment : 0;
2102
2103
34
        ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst + u1_sub_mb_num_col;
2104
34
        ps_direct->i1_submb_num[0] = u1_sub_mb_num;
2105
34
        ps_direct->i1_partitionsize[0] = PRED_8x8;
2106
34
        ps_direct->i1_num_partitions = 1;
2107
34
        return;
2108
34
    }
2109
23.2k
}
2110
/*!
2111
 **************************************************************************
2112
 * \if Function name : ih264d_fld_to_frm \endif
2113
 *
2114
 * \brief
2115
 *    Initializes forward and backward refernce lists for B slice decoding.
2116
 *
2117
 *
2118
 * \return
2119
 *    0 on Success and Error code otherwise
2120
 **************************************************************************
2121
 */
2122
void ih264d_fld_to_frm(dec_struct_t *ps_dec,
2123
                       struct pic_buffer_t *ps_col_pic,
2124
                       directmv_t *ps_direct,
2125
                       UWORD8 u1_wd_x,
2126
                       WORD32 u2_sub_mb_ofst,
2127
                       dec_mb_info_t * ps_cur_mb_info)
2128
23.8k
{
2129
23.8k
    UWORD8 *pu1_col_zero_flag_start, *pu1_col_zero_flag,
2130
23.8k
                    *pu1_col_zero_flag_right_half, u1_sub_mb_num, uc_sub_mb_num_col;
2131
23.8k
    UWORD8 u1_col_mb_pred_mode, uc_blk;
2132
23.8k
    WORD32 i4_force_8X8;
2133
2134
23.8k
    UNUSED(ps_cur_mb_info);
2135
23.8k
    ps_direct->u1_vert_mv_scale = FLD_TO_FRM;
2136
23.8k
    ps_direct->u1_col_zeroflag_change = 1;
2137
    /* new calculation specific to this function for u2_sub_mb_ofst*/
2138
23.8k
    u2_sub_mb_ofst = (ps_dec->u2_mbx
2139
23.8k
                    + ((ps_dec->u2_mby >> 1) * ps_dec->u2_frm_wd_in_mbs)) << 4;
2140
23.8k
    u2_sub_mb_ofst += ((ps_dec->u2_mby & 1) << 3);
2141
2142
23.8k
    if(u1_wd_x == MB_SIZE)
2143
23.5k
    {
2144
23.5k
        pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
2145
23.5k
        u1_col_mb_pred_mode = (*pu1_col_zero_flag_start >> 6);
2146
23.5k
        ps_dec->u1_currB_type = (!!u1_col_mb_pred_mode);
2147
2148
23.5k
        if(u1_col_mb_pred_mode & 0x2)
2149
217
        {
2150
217
            if(u1_col_mb_pred_mode == PRED_8x16)
2151
9
            {
2152
9
                ps_direct->i1_num_partitions = 2;
2153
9
                ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
2154
9
                ps_direct->i1_submb_num[0] = 0;
2155
9
                ps_direct->i1_partitionsize[0] = PRED_8x16;
2156
9
                ps_direct->i4_mv_indices[1] = u2_sub_mb_ofst + 2;
2157
9
                ps_direct->i1_submb_num[1] = 2;
2158
9
                ps_direct->i1_partitionsize[1] = PRED_8x16;
2159
9
            }
2160
208
            else
2161
208
            {
2162
208
                UWORD8 i1_num_partitions = 0, partition_size;
2163
208
                UWORD32 mv_index;
2164
208
                UWORD8 u1_num_sub_blks, i, u1_col_sub_mb_pred_mode,
2165
208
                                u1_col_sub_mb_pred_mode_rt;
2166
2167
208
                u1_sub_mb_num = ps_dec->u1_sub_mb_num;
2168
2169
208
                pu1_col_zero_flag = pu1_col_zero_flag_start + u1_sub_mb_num;
2170
208
                u1_col_sub_mb_pred_mode = (*pu1_col_zero_flag & 0x10);/* 8x4 or 4x4 mode */
2171
2172
208
                pu1_col_zero_flag_right_half = pu1_col_zero_flag_start + u1_sub_mb_num
2173
208
                                + 2;
2174
208
                u1_col_sub_mb_pred_mode_rt = (*pu1_col_zero_flag_right_half
2175
208
                                & 0x10);/* 8x4 or 4x4 mode */
2176
2177
208
                i4_force_8X8 = (u1_col_sub_mb_pred_mode)
2178
157
                                || (u1_col_sub_mb_pred_mode_rt);
2179
208
                if(i4_force_8X8)
2180
92
                {
2181
92
                    u1_num_sub_blks = 2;
2182
92
                    partition_size = PRED_8x8;
2183
92
                }
2184
116
                else
2185
116
                {
2186
116
                    partition_size = PRED_8x16;
2187
116
                    u1_num_sub_blks = 1;
2188
116
                }
2189
2190
624
                for(i = 0; i < 2; i++)
2191
416
                {
2192
1.01k
                    for(uc_blk = 0; uc_blk < u1_num_sub_blks; uc_blk++)
2193
600
                    {
2194
600
                        uc_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
2195
600
                        uc_sub_mb_num_col &= 0x7;
2196
600
                        mv_index = u2_sub_mb_ofst + uc_sub_mb_num_col;
2197
2198
600
                        ps_direct->i4_mv_indices[i1_num_partitions] = mv_index;
2199
600
                        ps_direct->i1_submb_num[i1_num_partitions] =
2200
600
                                        u1_sub_mb_num;
2201
600
                        ps_direct->i1_partitionsize[i1_num_partitions] =
2202
600
                                        partition_size;
2203
600
                        i1_num_partitions++;
2204
600
                        u1_sub_mb_num += 8;
2205
600
                    }
2206
2207
416
                    u1_sub_mb_num = 2; /* move to second half of Cur MB */
2208
2209
416
                }
2210
208
                ps_direct->i1_num_partitions = i1_num_partitions;
2211
208
                return;
2212
208
            }
2213
217
        }
2214
23.3k
        else
2215
23.3k
        {
2216
23.3k
            ps_direct->i1_num_partitions = 1;
2217
23.3k
            ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
2218
23.3k
            ps_direct->i1_submb_num[0] = 0;
2219
23.3k
            ps_direct->i1_partitionsize[0] = PRED_16x16;
2220
23.3k
            return;
2221
23.3k
        }
2222
23.5k
    }
2223
307
    else
2224
307
    {
2225
307
        u1_sub_mb_num = ps_dec->u1_sub_mb_num;
2226
307
        uc_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
2227
307
        uc_sub_mb_num_col &= 0x7;
2228
2229
307
        ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst + uc_sub_mb_num_col;
2230
307
        ps_direct->i1_submb_num[0] = u1_sub_mb_num;
2231
307
        ps_direct->i1_partitionsize[0] = PRED_8x8;
2232
307
        ps_direct->i1_num_partitions = 1;
2233
307
    }
2234
23.8k
}
2235
/*!
2236
 **************************************************************************
2237
 * \if Function name : ih264d_one_to_one \endif
2238
 *
2239
 * \brief
2240
 *    Initializes forward and backward refernce lists for B slice decoding.
2241
 *
2242
 *
2243
 * \return
2244
 *    0 on Success and Error code otherwise
2245
 **************************************************************************
2246
 */
2247
void ih264d_mbaff_to_fld(dec_struct_t *ps_dec,
2248
                         struct pic_buffer_t *ps_col_pic,
2249
                         directmv_t *ps_direct,
2250
                         UWORD8 u1_wd_x,
2251
                         WORD32 u2_sub_mb_ofst,
2252
                         dec_mb_info_t * ps_cur_mb_info)
2253
6.04k
{
2254
6.04k
    UWORD8* pu1_col_zero_flag, u1_iscol_mb_fld;
2255
6.04k
    u2_sub_mb_ofst <<= 1;
2256
6.04k
    pu1_col_zero_flag = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
2257
6.04k
    u1_iscol_mb_fld = (*pu1_col_zero_flag & 0x2) >> 1;
2258
6.04k
    if(u1_iscol_mb_fld)
2259
496
    {
2260
496
        u2_sub_mb_ofst += (ps_dec->ps_cur_slice->u1_bottom_field_flag << 4);
2261
496
        ih264d_one_to_one(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2262
496
                          u2_sub_mb_ofst, ps_cur_mb_info);
2263
496
    }
2264
5.54k
    else
2265
5.54k
        ih264d_frm_to_fld(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2266
5.54k
                          u2_sub_mb_ofst, ps_cur_mb_info);
2267
6.04k
}
2268
/*!
2269
 **************************************************************************
2270
 * \if Function name : ih264d_one_to_one \endif
2271
 *
2272
 * \brief
2273
 *    Initializes forward and backward refernce lists for B slice decoding.
2274
 *
2275
 *
2276
 * \return
2277
 *    0 on Success and Error code otherwise
2278
 **************************************************************************
2279
 */
2280
void ih264d_fld_to_mbaff(dec_struct_t *ps_dec,
2281
                         struct pic_buffer_t *ps_col_pic,
2282
                         directmv_t *ps_direct,
2283
                         UWORD8 u1_wd_x,
2284
                         WORD32 u2_sub_mb_ofst,
2285
                         dec_mb_info_t * ps_cur_mb_info)
2286
15.9k
{
2287
15.9k
    if((ps_col_pic->u1_picturetype & 0x7) == COMP_FLD_PAIR)
2288
6.96k
    {
2289
        /* first calculate the colocated picture which varies with Mb */
2290
6.96k
        UWORD8 u1_is_cur_mb_fld;
2291
6.96k
        u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
2292
6.96k
        u2_sub_mb_ofst = (u2_sub_mb_ofst & 0xffe0); /* mbaddrCol5 = curmbaddr/2;*/
2293
6.96k
        u2_sub_mb_ofst >>= 1;
2294
2295
6.96k
        ps_col_pic = ps_dec->ps_ref_pic_buf_lx[1][0];
2296
6.96k
        if(u1_is_cur_mb_fld)
2297
457
        {
2298
457
            if(1 - ps_cur_mb_info->u1_topmb)
2299
223
                ps_col_pic = ps_dec->ps_ref_pic_buf_lx[1][MAX_REF_BUFS];
2300
2301
457
            ih264d_one_to_one(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2302
457
                              u2_sub_mb_ofst, ps_cur_mb_info);
2303
457
        }
2304
6.50k
        else
2305
6.50k
        {
2306
2307
6.50k
            if(ABS(ps_col_pic->i4_top_field_order_cnt
2308
6.50k
                            - (WORD64)ps_dec->ps_cur_pic->i4_poc) >=
2309
6.50k
                            ABS((WORD64)ps_dec->ps_cur_pic->i4_poc
2310
6.50k
                                                - ps_col_pic->i4_bottom_field_order_cnt))
2311
6.49k
            {
2312
6.49k
                ps_col_pic = ps_dec->ps_ref_pic_buf_lx[1][MAX_REF_BUFS];
2313
6.49k
            }
2314
2315
6.50k
            if(ps_cur_mb_info->u1_topmb == 0)
2316
3.22k
                u2_sub_mb_ofst += 8;
2317
6.50k
            ih264d_mbaff_cross_pmbair(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2318
6.50k
                                      u2_sub_mb_ofst, ps_cur_mb_info);
2319
6.50k
        }
2320
6.96k
        ps_dec->ps_col_pic = ps_col_pic;
2321
6.96k
    }
2322
8.97k
    else
2323
8.97k
    {
2324
8.97k
        UWORD8* pu1_col_zero_flag = ps_col_pic->pu1_col_zero_flag
2325
8.97k
                        + u2_sub_mb_ofst;
2326
8.97k
        UWORD8 temp, u1_is_cur_mb_fld, u1_iscol_mb_fld;
2327
2328
8.97k
        u1_iscol_mb_fld = (*pu1_col_zero_flag & 0x2) >> 1;
2329
8.97k
        u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
2330
8.97k
        temp = (u1_iscol_mb_fld ^ u1_is_cur_mb_fld);
2331
2332
8.97k
        if(temp == 0)
2333
4.06k
            ih264d_one_to_one(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2334
4.06k
                              u2_sub_mb_ofst, ps_cur_mb_info);
2335
4.91k
        else
2336
4.91k
        {
2337
4.91k
            u2_sub_mb_ofst &= 0xffef;
2338
4.91k
            if(u1_is_cur_mb_fld == 0)
2339
53
            {
2340
53
                if(ABS(ps_col_pic->i4_top_field_order_cnt
2341
53
                                - (WORD64)ps_dec->ps_cur_pic->i4_poc) >=
2342
53
                                ABS((WORD64)ps_dec->ps_cur_pic->i4_poc
2343
53
                                                    - ps_col_pic->i4_bottom_field_order_cnt))
2344
37
                {
2345
37
                    u2_sub_mb_ofst += 0x10;
2346
37
                }
2347
53
                if(ps_cur_mb_info->u1_topmb == 0)
2348
29
                    u2_sub_mb_ofst += 8;
2349
53
            }
2350
4.91k
            ih264d_mbaff_cross_pmbair(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2351
4.91k
                                      u2_sub_mb_ofst, ps_cur_mb_info);
2352
4.91k
        }
2353
8.97k
    }
2354
15.9k
}
2355