PageRenderTime 150ms CodeModel.GetById 45ms app.highlight 95ms RepoModel.GetById 1ms app.codeStats 0ms

/Avc/slice.cpp

http://github.com/mbebenita/Broadway
C++ | 772 lines | 589 code | 106 blank | 77 comment | 106 complexity | d7c2bec3907542468414ae91a27496a1 MD5 | raw file
  1/* ------------------------------------------------------------------
  2 * Copyright (C) 1998-2009 PacketVideo
  3 *
  4 * Licensed under the Apache License, Version 2.0 (the "License");
  5 * you may not use this file except in compliance with the License.
  6 * You may obtain a copy of the License at
  7 *
  8 *      http://www.apache.org/licenses/LICENSE-2.0
  9 *
 10 * Unless required by applicable law or agreed to in writing, software
 11 * distributed under the License is distributed on an "AS IS" BASIS,
 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 13 * express or implied.
 14 * See the License for the specific language governing permissions
 15 * and limitations under the License.
 16 * -------------------------------------------------------------------
 17 */
 18/* Note for optimization: syntax decoding or operations related to B_SLICE should be
 19commented out by macro definition or function pointers. */
 20
 21#include <string.h>
 22
 23#include "avcdec_lib.h"
 24#include "avcdec_bitstream.h"
 25
 26const static int mbPart2raster[3][4] = {{0, 0, 0, 0}, {1, 1, 0, 0}, {1, 0, 1, 0}};
 27/* decode_frame_slice() */
 28/* decode_one_slice() */
 29AVCDec_Status DecodeSlice(AVCDecObject *decvid)
 30{
 31    AVCDec_Status status;
 32    AVCCommonObj *video = decvid->common;
 33    AVCSliceHeader *sliceHdr = video->sliceHdr;
 34    AVCMacroblock *currMB ;
 35    AVCDecBitstream *stream = decvid->bitstream;
 36    uint slice_group_id;
 37    uint CurrMbAddr, moreDataFlag;
 38
 39    /* set the first mb in slice */
 40    CurrMbAddr = sliceHdr->first_mb_in_slice;
 41    slice_group_id = video->MbToSliceGroupMap[CurrMbAddr];
 42
 43    if ((CurrMbAddr && (CurrMbAddr != (uint)(video->mbNum + 1))) && video->currSeqParams->constrained_set1_flag == 1)
 44    {
 45        ConcealSlice(decvid, video->mbNum, CurrMbAddr);
 46    }
 47
 48    moreDataFlag = 1;
 49    video->mb_skip_run = -1;
 50
 51
 52    /* while loop , see subclause 7.3.4 */
 53    do
 54    {
 55        if (CurrMbAddr >= video->PicSizeInMbs)
 56        {
 57            return AVCDEC_FAIL;
 58        }
 59
 60        currMB = video->currMB = &(video->mblock[CurrMbAddr]);
 61        video->mbNum = CurrMbAddr;
 62        currMB->slice_id = video->slice_id;  //  slice
 63
 64        /* we can remove this check if we don't support Mbaff. */
 65        /* we can wrap below into an initMB() function which will also
 66        do necessary reset of macroblock related parameters. */
 67
 68        video->mb_x = CurrMbAddr % video->PicWidthInMbs;
 69        video->mb_y = CurrMbAddr / video->PicWidthInMbs;
 70
 71        /* check the availability of neighboring macroblocks */
 72        InitNeighborAvailability(video, CurrMbAddr);
 73
 74        /* read_macroblock and decode_one_macroblock() */
 75        status = DecodeMB(decvid);
 76        if (status != AVCDEC_SUCCESS)
 77        {
 78            return status;
 79        }
 80#ifdef MB_BASED_DEBLOCK
 81        if (video->currPicParams->num_slice_groups_minus1 == 0)
 82        {
 83            MBInLoopDeblock(video); /* MB-based deblocking */
 84        }
 85        else    /* this mode cannot be used if the number of slice group is not one. */
 86        {
 87            return AVCDEC_FAIL;
 88        }
 89#endif
 90        video->numMBs--;
 91
 92        moreDataFlag = more_rbsp_data(stream);
 93
 94
 95        /* go to next MB */
 96        while (++CurrMbAddr < video->PicSizeInMbs && video->MbToSliceGroupMap[CurrMbAddr] != (int)slice_group_id)
 97        {
 98        }
 99
100    }
101    while ((moreDataFlag && video->numMBs > 0) || video->mb_skip_run > 0); /* even if no more data, but last few MBs are skipped */
102
103    if (video->numMBs == 0)
104    {
105        video->newPic = TRUE;
106        video->mbNum = 0;  // _Conceal
107        return AVCDEC_PICTURE_READY;
108    }
109
110    return AVCDEC_SUCCESS;
111}
112
113/* read MB mode and motion vectors */
114/* perform Intra/Inter prediction and residue */
115/* update video->mb_skip_run */
116AVCDec_Status DecodeMB(AVCDecObject *decvid)
117{
118    AVCDec_Status status;
119    AVCCommonObj *video = decvid->common;
120    AVCDecBitstream *stream = decvid->bitstream;
121    AVCMacroblock *currMB = video->currMB;
122    uint mb_type;
123    int slice_type = video->slice_type;
124    int temp;
125
126    currMB->QPy = video->QPy;
127    currMB->QPc = video->QPc;
128
129    if (slice_type == AVC_P_SLICE)
130    {
131        if (video->mb_skip_run < 0)
132        {
133            ue_v(stream, (uint *)&(video->mb_skip_run));
134        }
135
136        if (video->mb_skip_run == 0)
137        {
138            /* this will not handle the case where the slice ends with a mb_skip_run == 0 and no following MB data  */
139            ue_v(stream, &mb_type);
140            if (mb_type > 30)
141            {
142                return AVCDEC_FAIL;
143            }
144            InterpretMBModeP(currMB, mb_type);
145            video->mb_skip_run = -1;
146        }
147        else
148        {
149            /* see subclause 7.4.4 for more details on how
150            mb_field_decoding_flag is derived in case of skipped MB */
151
152            currMB->mb_intra = FALSE;
153
154            currMB->mbMode = AVC_SKIP;
155            currMB->MbPartWidth = currMB->MbPartHeight = 16;
156            currMB->NumMbPart = 1;
157            currMB->NumSubMbPart[0] = currMB->NumSubMbPart[1] =
158                                          currMB->NumSubMbPart[2] = currMB->NumSubMbPart[3] = 1; //
159            currMB->SubMbPartWidth[0] = currMB->SubMbPartWidth[1] =
160                                            currMB->SubMbPartWidth[2] = currMB->SubMbPartWidth[3] = currMB->MbPartWidth;
161            currMB->SubMbPartHeight[0] = currMB->SubMbPartHeight[1] =
162                                             currMB->SubMbPartHeight[2] = currMB->SubMbPartHeight[3] = currMB->MbPartHeight;
163
164            memset(currMB->nz_coeff, 0, sizeof(uint8)*NUM_BLKS_IN_MB);
165
166            currMB->CBP = 0;
167            video->cbp4x4 = 0;
168            /* for skipped MB, always look at the first entry in RefPicList */
169            currMB->RefIdx[0] = currMB->RefIdx[1] =
170                                    currMB->RefIdx[2] = currMB->RefIdx[3] = video->RefPicList0[0]->RefIdx;
171            InterMBPrediction(video);
172            video->mb_skip_run--;
173            return AVCDEC_SUCCESS;
174        }
175
176    }
177    else
178    {
179        /* Then decode mode and MV */
180        ue_v(stream, &mb_type);
181        if (mb_type > 25)
182        {
183            return AVCDEC_FAIL;
184        }
185        InterpretMBModeI(currMB, mb_type);
186    }
187
188
189    if (currMB->mbMode != AVC_I_PCM)
190    {
191
192        if (currMB->mbMode == AVC_P8 || currMB->mbMode == AVC_P8ref0)
193        {
194            status = sub_mb_pred(video, currMB, stream);
195        }
196        else
197        {
198            status = mb_pred(video, currMB, stream) ;
199        }
200
201        if (status != AVCDEC_SUCCESS)
202        {
203            return status;
204        }
205
206        if (currMB->mbMode != AVC_I16)
207        {
208            /* decode coded_block_pattern */
209            status = DecodeCBP(currMB, stream);
210            if (status != AVCDEC_SUCCESS)
211            {
212                return status;
213            }
214        }
215
216        if (currMB->CBP > 0 || currMB->mbMode == AVC_I16)
217        {
218            se_v(stream, &temp);
219            if (temp)
220            {
221                temp += (video->QPy + 52);
222                currMB->QPy = video->QPy = temp - 52 * (temp * 79 >> 12);
223                if (currMB->QPy > 51 || currMB->QPy < 0)
224                {
225                    video->QPy = AVC_CLIP3(0, 51, video->QPy);
226//                  return AVCDEC_FAIL;
227                }
228                video->QPy_div_6 = (video->QPy * 43) >> 8;
229                video->QPy_mod_6 = video->QPy - 6 * video->QPy_div_6;
230                currMB->QPc = video->QPc = mapQPi2QPc[AVC_CLIP3(0, 51, video->QPy + video->currPicParams->chroma_qp_index_offset)];
231                video->QPc_div_6 = (video->QPc * 43) >> 8;
232                video->QPc_mod_6 = video->QPc - 6 * video->QPc_div_6;
233            }
234        }
235        /* decode residue and inverse transform */
236        status = residual(decvid, currMB);
237        if (status != AVCDEC_SUCCESS)
238        {
239            return status;
240        }
241    }
242    else
243    {
244        if (stream->bitcnt & 7)
245        {
246            BitstreamByteAlign(stream);
247        }
248        /* decode pcm_byte[i] */
249        DecodeIntraPCM(video, stream);
250
251        currMB->QPy = 0;  /* necessary for deblocking */ // _OPTIMIZE
252        currMB->QPc = mapQPi2QPc[AVC_CLIP3(0, 51, video->currPicParams->chroma_qp_index_offset)];
253
254        /* default values, don't know if really needed */
255        currMB->CBP = 0x3F;
256        video->cbp4x4 = 0xFFFF;
257        currMB->mb_intra = TRUE;
258        memset(currMB->nz_coeff, 16, sizeof(uint8)*NUM_BLKS_IN_MB);
259        return AVCDEC_SUCCESS;
260    }
261
262
263    /* do Intra/Inter prediction, together with the residue compensation */
264    /* This part should be common between the skip and no-skip */
265    if (currMB->mbMode == AVC_I4 || currMB->mbMode == AVC_I16)
266    {
267        IntraMBPrediction(video);
268    }
269    else
270    {
271        InterMBPrediction(video);
272    }
273
274
275
276    return AVCDEC_SUCCESS;
277}
278
279/* see subclause 7.3.5.1 */
280AVCDec_Status mb_pred(AVCCommonObj *video, AVCMacroblock *currMB, AVCDecBitstream *stream)
281{
282    int mbPartIdx;
283    AVCSliceHeader *sliceHdr = video->sliceHdr;
284    uint max_ref_idx;
285    const int *temp_0;
286    int16 *temp_1;
287    uint code;
288
289    if (currMB->mbMode == AVC_I4 || currMB->mbMode == AVC_I16)
290    {
291
292        video->intraAvailA = video->intraAvailB = video->intraAvailC = video->intraAvailD = 0;
293
294        if (!video->currPicParams->constrained_intra_pred_flag)
295        {
296            video->intraAvailA = video->mbAvailA;
297            video->intraAvailB = video->mbAvailB;
298            video->intraAvailC = video->mbAvailC;
299            video->intraAvailD = video->mbAvailD;
300        }
301        else
302        {
303            if (video->mbAvailA)
304            {
305                video->intraAvailA = video->mblock[video->mbAddrA].mb_intra;
306            }
307            if (video->mbAvailB)
308            {
309                video->intraAvailB = video->mblock[video->mbAddrB].mb_intra ;
310            }
311            if (video->mbAvailC)
312            {
313                video->intraAvailC = video->mblock[video->mbAddrC].mb_intra;
314            }
315            if (video->mbAvailD)
316            {
317                video->intraAvailD = video->mblock[video->mbAddrD].mb_intra;
318            }
319        }
320
321
322        if (currMB->mbMode == AVC_I4)
323        {
324            /* perform prediction to get the actual intra 4x4 pred mode */
325            DecodeIntra4x4Mode(video, currMB, stream);
326            /* output will be in currMB->i4Mode[4][4] */
327        }
328
329        ue_v(stream, &code);
330
331        if (code > 3)
332        {
333            return AVCDEC_FAIL; /* out of range */
334        }
335        currMB->intra_chroma_pred_mode = (AVCIntraChromaPredMode)code;
336    }
337    else
338    {
339
340        memset(currMB->ref_idx_L0, 0, sizeof(int16)*4);
341
342        /* see subclause 7.4.5.1 for the range of ref_idx_lX */
343//      max_ref_idx = sliceHdr->num_ref_idx_l0_active_minus1;
344        max_ref_idx = video->refList0Size - 1;
345
346        /* decode ref index for L0 */
347        if (sliceHdr->num_ref_idx_l0_active_minus1 > 0)
348        {
349            for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++)
350            {
351                te_v(stream, &code, max_ref_idx);
352                if (code > (uint)max_ref_idx)
353                {
354                    return AVCDEC_FAIL;
355                }
356                currMB->ref_idx_L0[mbPartIdx] = code;
357            }
358        }
359
360        /* populate ref_idx_L0 */
361        temp_0 = &mbPart2raster[currMB->mbMode-AVC_P16][0];
362        temp_1 = &currMB->ref_idx_L0[3];
363
364        *temp_1-- = currMB->ref_idx_L0[*temp_0++];
365        *temp_1-- = currMB->ref_idx_L0[*temp_0++];
366        *temp_1-- = currMB->ref_idx_L0[*temp_0++];
367        *temp_1-- = currMB->ref_idx_L0[*temp_0++];
368
369        /* Global reference index, these values are used in deblock */
370        currMB->RefIdx[0] = video->RefPicList0[currMB->ref_idx_L0[0]]->RefIdx;
371        currMB->RefIdx[1] = video->RefPicList0[currMB->ref_idx_L0[1]]->RefIdx;
372        currMB->RefIdx[2] = video->RefPicList0[currMB->ref_idx_L0[2]]->RefIdx;
373        currMB->RefIdx[3] = video->RefPicList0[currMB->ref_idx_L0[3]]->RefIdx;
374
375        /* see subclause 7.4.5.1 for the range of ref_idx_lX */
376        max_ref_idx = sliceHdr->num_ref_idx_l1_active_minus1;
377        /* decode mvd_l0 */
378        for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++)
379        {
380            se_v(stream, &(video->mvd_l0[mbPartIdx][0][0]));
381            se_v(stream, &(video->mvd_l0[mbPartIdx][0][1]));
382        }
383    }
384
385    return AVCDEC_SUCCESS;
386}
387
388/* see subclause 7.3.5.2 */
389AVCDec_Status sub_mb_pred(AVCCommonObj *video, AVCMacroblock *currMB, AVCDecBitstream *stream)
390{
391    int mbPartIdx, subMbPartIdx;
392    AVCSliceHeader *sliceHdr = video->sliceHdr;
393    uint max_ref_idx;
394    uint sub_mb_type[4];
395    uint code;
396
397    memset(currMB->ref_idx_L0, 0, sizeof(int16)*4);
398
399    for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++)
400    {
401        ue_v(stream, &(sub_mb_type[mbPartIdx]));
402        if (sub_mb_type[mbPartIdx] > 3)
403        {
404            return AVCDEC_FAIL;
405        }
406
407    }
408    /* we have to check the values to make sure they are valid  */
409    /* assign values to currMB->sub_mb_type[], currMB->MBPartPredMode[][x] */
410
411    InterpretSubMBModeP(currMB, sub_mb_type);
412
413
414    /* see subclause 7.4.5.1 for the range of ref_idx_lX */
415//      max_ref_idx = sliceHdr->num_ref_idx_l0_active_minus1;
416    max_ref_idx = video->refList0Size - 1;
417
418    if (sliceHdr->num_ref_idx_l0_active_minus1 > 0 && currMB->mbMode != AVC_P8ref0)
419    {
420        for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++)
421        {
422            te_v(stream, (uint*)&code, max_ref_idx);
423            if (code > max_ref_idx)
424            {
425                return AVCDEC_FAIL;
426            }
427            currMB->ref_idx_L0[mbPartIdx] = code;
428        }
429    }
430    /* see subclause 7.4.5.1 for the range of ref_idx_lX */
431
432    max_ref_idx = sliceHdr->num_ref_idx_l1_active_minus1;
433    /*  if(video->MbaffFrameFlag && currMB->mb_field_decoding_flag)
434            max_ref_idx = 2*sliceHdr->num_ref_idx_l1_active_minus1 + 1;*/
435    for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++)
436    {
437        for (subMbPartIdx = 0; subMbPartIdx < currMB->NumSubMbPart[mbPartIdx]; subMbPartIdx++)
438        {
439            se_v(stream, &(video->mvd_l0[mbPartIdx][subMbPartIdx][0]));
440            se_v(stream, &(video->mvd_l0[mbPartIdx][subMbPartIdx][1]));
441        }
442        /* used in deblocking */
443        currMB->RefIdx[mbPartIdx] = video->RefPicList0[currMB->ref_idx_L0[mbPartIdx]]->RefIdx;
444    }
445    return AVCDEC_SUCCESS;
446}
447
448void InterpretMBModeI(AVCMacroblock *mblock, uint mb_type)
449{
450    mblock->NumMbPart = 1;
451
452    mblock->mb_intra = TRUE;
453
454    if (mb_type == 0) /* I_4x4 */
455    {
456        mblock->mbMode = AVC_I4;
457    }
458    else if (mb_type < 25) /* I_PCM */
459    {
460        mblock->mbMode = AVC_I16;
461        mblock->i16Mode = (AVCIntra16x16PredMode)((mb_type - 1) & 0x3);
462        if (mb_type > 12)
463        {
464            mblock->CBP = (((mb_type - 13) >> 2) << 4) + 0x0F;
465        }
466        else
467        {
468            mblock->CBP = ((mb_type - 1) >> 2) << 4;
469        }
470    }
471    else
472    {
473        mblock->mbMode = AVC_I_PCM;
474    }
475
476    return ;
477}
478
479void InterpretMBModeP(AVCMacroblock *mblock, uint mb_type)
480{
481    const static int map2PartWidth[5] = {16, 16, 8, 8, 8};
482    const static int map2PartHeight[5] = {16, 8, 16, 8, 8};
483    const static int map2NumPart[5] = {1, 2, 2, 4, 4};
484    const static AVCMBMode map2mbMode[5] = {AVC_P16, AVC_P16x8, AVC_P8x16, AVC_P8, AVC_P8ref0};
485
486    mblock->mb_intra = FALSE;
487    if (mb_type < 5)
488    {
489        mblock->mbMode = map2mbMode[mb_type];
490        mblock->MbPartWidth = map2PartWidth[mb_type];
491        mblock->MbPartHeight = map2PartHeight[mb_type];
492        mblock->NumMbPart = map2NumPart[mb_type];
493        mblock->NumSubMbPart[0] = mblock->NumSubMbPart[1] =
494                                      mblock->NumSubMbPart[2] = mblock->NumSubMbPart[3] = 1;
495        mblock->SubMbPartWidth[0] = mblock->SubMbPartWidth[1] =
496                                        mblock->SubMbPartWidth[2] = mblock->SubMbPartWidth[3] = mblock->MbPartWidth;
497        mblock->SubMbPartHeight[0] = mblock->SubMbPartHeight[1] =
498                                         mblock->SubMbPartHeight[2] = mblock->SubMbPartHeight[3] = mblock->MbPartHeight;
499    }
500    else
501    {
502        InterpretMBModeI(mblock, mb_type - 5);
503        /* set MV and Ref_Idx codes of Intra blocks in P-slices  */
504        memset(mblock->mvL0, 0, sizeof(int32)*16);
505        mblock->ref_idx_L0[0] = mblock->ref_idx_L0[1] = mblock->ref_idx_L0[2] = mblock->ref_idx_L0[3] = -1;
506    }
507    return ;
508}
509
510void InterpretMBModeB(AVCMacroblock *mblock, uint mb_type)
511{
512    const static int map2PartWidth[23] = {8, 16, 16, 16, 16, 8, 16, 8, 16, 8,
513                                          16, 8, 16, 8, 16, 8, 16, 8, 16, 8, 16, 8, 8
514                                         };
515    const static int map2PartHeight[23] = {8, 16, 16, 16, 8, 16, 8, 16, 8,
516                                           16, 8, 16, 8, 16, 8, 16, 8, 16, 8, 16, 8, 16, 8
517                                          };
518    /* see enum AVCMBType declaration */
519    const static AVCMBMode map2mbMode[23] = {AVC_BDirect16, AVC_P16, AVC_P16, AVC_P16,
520                                            AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16,
521                                            AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16,
522                                            AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16, AVC_P8
523                                            };
524    const static int map2PredMode1[23] = {3, 0, 1, 2, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, -1};
525    const static int map2PredMode2[23] = { -1, -1, -1, -1, 0, 0, 1, 1, 1, 1, 0, 0, 2, 2, 2, 2, 0, 0, 1, 1, 2, 2, -1};
526    const static int map2NumPart[23] = { -1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4};
527
528    mblock->mb_intra = FALSE;
529
530    if (mb_type < 23)
531    {
532        mblock->mbMode = map2mbMode[mb_type];
533        mblock->NumMbPart = map2NumPart[mb_type];
534        mblock->MBPartPredMode[0][0] = (AVCPredMode)map2PredMode1[mb_type];
535        if (mblock->NumMbPart > 1)
536        {
537            mblock->MBPartPredMode[1][0] = (AVCPredMode)map2PredMode2[mb_type];
538        }
539        mblock->MbPartWidth = map2PartWidth[mb_type];
540        mblock->MbPartHeight = map2PartHeight[mb_type];
541    }
542    else
543    {
544        InterpretMBModeI(mblock, mb_type - 23);
545    }
546
547    return ;
548}
549
550void InterpretMBModeSI(AVCMacroblock *mblock, uint mb_type)
551{
552    mblock->mb_intra = TRUE;
553
554    if (mb_type == 0)
555    {
556        mblock->mbMode = AVC_SI4;
557        /* other values are N/A */
558    }
559    else
560    {
561        InterpretMBModeI(mblock, mb_type - 1);
562    }
563    return ;
564}
565
566/* input is mblock->sub_mb_type[] */
567void InterpretSubMBModeP(AVCMacroblock *mblock, uint *sub_mb_type)
568{
569    int i,  sub_type;
570    /* see enum AVCMBType declaration */
571//  const static AVCSubMBMode map2subMbMode[4] = {AVC_8x8,AVC_8x4,AVC_4x8,AVC_4x4};
572    const static int map2subPartWidth[4] = {8, 8, 4, 4};
573    const static int map2subPartHeight[4] = {8, 4, 8, 4};
574    const static int map2numSubPart[4] = {1, 2, 2, 4};
575
576    for (i = 0; i < 4 ; i++)
577    {
578        sub_type = (int) sub_mb_type[i];
579        //  mblock->subMbMode[i] = map2subMbMode[sub_type];
580        mblock->NumSubMbPart[i] = map2numSubPart[sub_type];
581        mblock->SubMbPartWidth[i] = map2subPartWidth[sub_type];
582        mblock->SubMbPartHeight[i] = map2subPartHeight[sub_type];
583    }
584
585    return ;
586}
587
588void InterpretSubMBModeB(AVCMacroblock *mblock, uint *sub_mb_type)
589{
590    int i, j, sub_type;
591    /* see enum AVCMBType declaration */
592    const static AVCSubMBMode map2subMbMode[13] = {AVC_BDirect8, AVC_8x8, AVC_8x8,
593            AVC_8x8, AVC_8x4, AVC_4x8, AVC_8x4, AVC_4x8, AVC_8x4, AVC_4x8, AVC_4x4, AVC_4x4, AVC_4x4
594                                                  };
595    const static int map2subPartWidth[13] = {4, 8, 8, 8, 8, 4, 8, 4, 8, 4, 4, 4, 4};
596    const static int map2subPartHeight[13] = {4, 8, 8, 8, 4, 8, 4, 8, 4, 8, 4, 4, 4};
597    const static int map2numSubPart[13] = {1, 1, 1, 2, 2, 2, 2, 2, 2, 4, 4, 4};
598    const static int map2predMode[13] = {3, 0, 1, 2, 0, 0, 1, 1, 2, 2, 0, 1, 2};
599
600    for (i = 0; i < 4 ; i++)
601    {
602        sub_type = (int) sub_mb_type[i];
603        mblock->subMbMode[i] = map2subMbMode[sub_type];
604        mblock->NumSubMbPart[i] = map2numSubPart[sub_type];
605        mblock->SubMbPartWidth[i] = map2subPartWidth[sub_type];
606        mblock->SubMbPartHeight[i] = map2subPartHeight[sub_type];
607        for (j = 0; j < 4; j++)
608        {
609            mblock->MBPartPredMode[i][j] = (AVCPredMode)map2predMode[sub_type];
610        }
611    }
612
613    return ;
614}
615
616/* see subclause 8.3.1 */
617AVCDec_Status DecodeIntra4x4Mode(AVCCommonObj *video, AVCMacroblock *currMB, AVCDecBitstream *stream)
618{
619    int intra4x4PredModeA = 0, intra4x4PredModeB = 0, predIntra4x4PredMode = 0;
620    int component, SubBlock_indx, block_x, block_y;
621    int dcOnlyPredictionFlag;
622    uint    prev_intra4x4_pred_mode_flag[16];
623    int     rem_intra4x4_pred_mode[16];
624    int bindx = 0;
625
626    for (component = 0; component < 4; component++) /* partition index */
627    {
628        block_x = ((component & 1) << 1);
629        block_y = ((component >> 1) << 1);
630
631        for (SubBlock_indx = 0; SubBlock_indx < 4; SubBlock_indx++) /* sub-partition index */
632        {
633            BitstreamRead1Bit(stream, &(prev_intra4x4_pred_mode_flag[bindx]));
634
635            if (!prev_intra4x4_pred_mode_flag[bindx])
636            {
637                BitstreamReadBits(stream, 3, (uint*)&(rem_intra4x4_pred_mode[bindx]));
638            }
639
640            dcOnlyPredictionFlag = 0;
641            if (block_x > 0)
642            {
643                intra4x4PredModeA = currMB->i4Mode[(block_y << 2) + block_x - 1 ];
644            }
645            else
646            {
647                if (video->intraAvailA)
648                {
649                    if (video->mblock[video->mbAddrA].mbMode == AVC_I4)
650                    {
651                        intra4x4PredModeA = video->mblock[video->mbAddrA].i4Mode[(block_y << 2) + 3];
652                    }
653                    else
654                    {
655                        intra4x4PredModeA = AVC_I4_DC;
656                    }
657                }
658                else
659                {
660                    dcOnlyPredictionFlag = 1;
661                }
662            }
663
664            if (block_y > 0)
665            {
666                intra4x4PredModeB = currMB->i4Mode[((block_y-1) << 2) + block_x];
667            }
668            else
669            {
670                if (video->intraAvailB)
671                {
672                    if (video->mblock[video->mbAddrB].mbMode == AVC_I4)
673                    {
674                        intra4x4PredModeB = video->mblock[video->mbAddrB].i4Mode[(3 << 2) + block_x];
675                    }
676                    else
677                    {
678                        intra4x4PredModeB = AVC_I4_DC;
679                    }
680                }
681                else
682                {
683                    dcOnlyPredictionFlag = 1;
684                }
685            }
686
687            if (dcOnlyPredictionFlag)
688            {
689                intra4x4PredModeA = intra4x4PredModeB = AVC_I4_DC;
690            }
691
692            predIntra4x4PredMode = AVC_MIN(intra4x4PredModeA, intra4x4PredModeB);
693            if (prev_intra4x4_pred_mode_flag[bindx])
694            {
695                currMB->i4Mode[(block_y<<2)+block_x] = (AVCIntra4x4PredMode)predIntra4x4PredMode;
696            }
697            else
698            {
699                if (rem_intra4x4_pred_mode[bindx] < predIntra4x4PredMode)
700                {
701                    currMB->i4Mode[(block_y<<2)+block_x] = (AVCIntra4x4PredMode)rem_intra4x4_pred_mode[bindx];
702                }
703                else
704                {
705                    currMB->i4Mode[(block_y<<2)+block_x] = (AVCIntra4x4PredMode)(rem_intra4x4_pred_mode[bindx] + 1);
706                }
707            }
708            bindx++;
709            block_y += (SubBlock_indx & 1) ;
710            block_x += (1 - 2 * (SubBlock_indx & 1)) ;
711        }
712    }
713    return AVCDEC_SUCCESS;
714}
715AVCDec_Status ConcealSlice(AVCDecObject *decvid, int mbnum_start, int mbnum_end)
716{
717    AVCCommonObj *video = decvid->common;
718    AVCMacroblock *currMB ;
719
720    int CurrMbAddr;
721
722    if (video->RefPicList0[0] == NULL)
723    {
724        return AVCDEC_FAIL;
725    }
726
727    for (CurrMbAddr = mbnum_start; CurrMbAddr < mbnum_end; CurrMbAddr++)
728    {
729        currMB = video->currMB = &(video->mblock[CurrMbAddr]);
730        video->mbNum = CurrMbAddr;
731        currMB->slice_id = video->slice_id++;  //  slice
732
733        /* we can remove this check if we don't support Mbaff. */
734        /* we can wrap below into an initMB() function which will also
735        do necessary reset of macroblock related parameters. */
736
737        video->mb_x = CurrMbAddr % video->PicWidthInMbs;
738        video->mb_y = CurrMbAddr / video->PicWidthInMbs;
739
740        /* check the availability of neighboring macroblocks */
741        InitNeighborAvailability(video, CurrMbAddr);
742
743        currMB->mb_intra = FALSE;
744
745        currMB->mbMode = AVC_SKIP;
746        currMB->MbPartWidth = currMB->MbPartHeight = 16;
747
748        currMB->NumMbPart = 1;
749        currMB->NumSubMbPart[0] = currMB->NumSubMbPart[1] =
750                                      currMB->NumSubMbPart[2] = currMB->NumSubMbPart[3] = 1;
751        currMB->SubMbPartWidth[0] = currMB->SubMbPartWidth[1] =
752                                        currMB->SubMbPartWidth[2] = currMB->SubMbPartWidth[3] = currMB->MbPartWidth;
753        currMB->SubMbPartHeight[0] = currMB->SubMbPartHeight[1] =
754                                         currMB->SubMbPartHeight[2] = currMB->SubMbPartHeight[3] = currMB->MbPartHeight;
755        currMB->QPy = 26;
756        currMB->QPc = 26;
757        memset(currMB->nz_coeff, 0, sizeof(uint8)*NUM_BLKS_IN_MB);
758
759        currMB->CBP = 0;
760        video->cbp4x4 = 0;
761        /* for skipped MB, always look at the first entry in RefPicList */
762        currMB->RefIdx[0] = currMB->RefIdx[1] =
763                                currMB->RefIdx[2] = currMB->RefIdx[3] = video->RefPicList0[0]->RefIdx;
764        InterMBPrediction(video);
765
766        video->numMBs--;
767
768    }
769
770    return AVCDEC_SUCCESS;
771}
772