diff options
Diffstat (limited to 'media/libstagefright/codecs/avc/dec/src/slice.cpp')
| -rw-r--r-- | media/libstagefright/codecs/avc/dec/src/slice.cpp | 772 |
1 files changed, 772 insertions, 0 deletions
diff --git a/media/libstagefright/codecs/avc/dec/src/slice.cpp b/media/libstagefright/codecs/avc/dec/src/slice.cpp new file mode 100644 index 0000000..7a2ef3d --- /dev/null +++ b/media/libstagefright/codecs/avc/dec/src/slice.cpp @@ -0,0 +1,772 @@ +/* ------------------------------------------------------------------ + * Copyright (C) 1998-2009 PacketVideo + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. + * See the License for the specific language governing permissions + * and limitations under the License. + * ------------------------------------------------------------------- + */ +/* Note for optimization: syntax decoding or operations related to B_SLICE should be +commented out by macro definition or function pointers. */ + +#include <string.h> + +#include "avcdec_lib.h" +#include "avcdec_bitstream.h" + +const static int mbPart2raster[3][4] = {{0, 0, 0, 0}, {1, 1, 0, 0}, {1, 0, 1, 0}}; +/* decode_frame_slice() */ +/* decode_one_slice() */ +AVCDec_Status DecodeSlice(AVCDecObject *decvid) +{ + AVCDec_Status status; + AVCCommonObj *video = decvid->common; + AVCSliceHeader *sliceHdr = video->sliceHdr; + AVCMacroblock *currMB ; + AVCDecBitstream *stream = decvid->bitstream; + uint slice_group_id; + uint CurrMbAddr, moreDataFlag; + + /* set the first mb in slice */ + CurrMbAddr = sliceHdr->first_mb_in_slice; + slice_group_id = video->MbToSliceGroupMap[CurrMbAddr]; + + if ((CurrMbAddr && (CurrMbAddr != (uint)(video->mbNum + 1))) && video->currSeqParams->constrained_set1_flag == 1) + { + ConcealSlice(decvid, video->mbNum, CurrMbAddr); + } + + moreDataFlag = 1; + video->mb_skip_run = -1; + + + /* while loop , see subclause 7.3.4 */ + do + { + if (CurrMbAddr >= video->PicSizeInMbs) + { + return AVCDEC_FAIL; + } + + currMB = video->currMB = &(video->mblock[CurrMbAddr]); + video->mbNum = CurrMbAddr; + currMB->slice_id = video->slice_id; // slice + + /* we can remove this check if we don't support Mbaff. */ + /* we can wrap below into an initMB() function which will also + do necessary reset of macroblock related parameters. */ + + video->mb_x = CurrMbAddr % video->PicWidthInMbs; + video->mb_y = CurrMbAddr / video->PicWidthInMbs; + + /* check the availability of neighboring macroblocks */ + InitNeighborAvailability(video, CurrMbAddr); + + /* read_macroblock and decode_one_macroblock() */ + status = DecodeMB(decvid); + if (status != AVCDEC_SUCCESS) + { + return status; + } +#ifdef MB_BASED_DEBLOCK + if (video->currPicParams->num_slice_groups_minus1 == 0) + { + MBInLoopDeblock(video); /* MB-based deblocking */ + } + else /* this mode cannot be used if the number of slice group is not one. */ + { + return AVCDEC_FAIL; + } +#endif + video->numMBs--; + + moreDataFlag = more_rbsp_data(stream); + + + /* go to next MB */ + while (++CurrMbAddr < video->PicSizeInMbs && video->MbToSliceGroupMap[CurrMbAddr] != (int)slice_group_id) + { + } + + } + while ((moreDataFlag && video->numMBs > 0) || video->mb_skip_run > 0); /* even if no more data, but last few MBs are skipped */ + + if (video->numMBs == 0) + { + video->newPic = TRUE; + video->mbNum = 0; // _Conceal + return AVCDEC_PICTURE_READY; + } + + return AVCDEC_SUCCESS; +} + +/* read MB mode and motion vectors */ +/* perform Intra/Inter prediction and residue */ +/* update video->mb_skip_run */ +AVCDec_Status DecodeMB(AVCDecObject *decvid) +{ + AVCDec_Status status; + AVCCommonObj *video = decvid->common; + AVCDecBitstream *stream = decvid->bitstream; + AVCMacroblock *currMB = video->currMB; + uint mb_type; + int slice_type = video->slice_type; + int temp; + + currMB->QPy = video->QPy; + currMB->QPc = video->QPc; + + if (slice_type == AVC_P_SLICE) + { + if (video->mb_skip_run < 0) + { + ue_v(stream, (uint *)&(video->mb_skip_run)); + } + + if (video->mb_skip_run == 0) + { + /* this will not handle the case where the slice ends with a mb_skip_run == 0 and no following MB data */ + ue_v(stream, &mb_type); + if (mb_type > 30) + { + return AVCDEC_FAIL; + } + InterpretMBModeP(currMB, mb_type); + video->mb_skip_run = -1; + } + else + { + /* see subclause 7.4.4 for more details on how + mb_field_decoding_flag is derived in case of skipped MB */ + + currMB->mb_intra = FALSE; + + currMB->mbMode = AVC_SKIP; + currMB->MbPartWidth = currMB->MbPartHeight = 16; + currMB->NumMbPart = 1; + currMB->NumSubMbPart[0] = currMB->NumSubMbPart[1] = + currMB->NumSubMbPart[2] = currMB->NumSubMbPart[3] = 1; // + currMB->SubMbPartWidth[0] = currMB->SubMbPartWidth[1] = + currMB->SubMbPartWidth[2] = currMB->SubMbPartWidth[3] = currMB->MbPartWidth; + currMB->SubMbPartHeight[0] = currMB->SubMbPartHeight[1] = + currMB->SubMbPartHeight[2] = currMB->SubMbPartHeight[3] = currMB->MbPartHeight; + + memset(currMB->nz_coeff, 0, sizeof(uint8)*NUM_BLKS_IN_MB); + + currMB->CBP = 0; + video->cbp4x4 = 0; + /* for skipped MB, always look at the first entry in RefPicList */ + currMB->RefIdx[0] = currMB->RefIdx[1] = + currMB->RefIdx[2] = currMB->RefIdx[3] = video->RefPicList0[0]->RefIdx; + InterMBPrediction(video); + video->mb_skip_run--; + return AVCDEC_SUCCESS; + } + + } + else + { + /* Then decode mode and MV */ + ue_v(stream, &mb_type); + if (mb_type > 25) + { + return AVCDEC_FAIL; + } + InterpretMBModeI(currMB, mb_type); + } + + + if (currMB->mbMode != AVC_I_PCM) + { + + if (currMB->mbMode == AVC_P8 || currMB->mbMode == AVC_P8ref0) + { + status = sub_mb_pred(video, currMB, stream); + } + else + { + status = mb_pred(video, currMB, stream) ; + } + + if (status != AVCDEC_SUCCESS) + { + return status; + } + + if (currMB->mbMode != AVC_I16) + { + /* decode coded_block_pattern */ + status = DecodeCBP(currMB, stream); + if (status != AVCDEC_SUCCESS) + { + return status; + } + } + + if (currMB->CBP > 0 || currMB->mbMode == AVC_I16) + { + se_v(stream, &temp); + if (temp) + { + temp += (video->QPy + 52); + currMB->QPy = video->QPy = temp - 52 * (temp * 79 >> 12); + if (currMB->QPy > 51 || currMB->QPy < 0) + { + video->QPy = AVC_CLIP3(0, 51, video->QPy); +// return AVCDEC_FAIL; + } + video->QPy_div_6 = (video->QPy * 43) >> 8; + video->QPy_mod_6 = video->QPy - 6 * video->QPy_div_6; + currMB->QPc = video->QPc = mapQPi2QPc[AVC_CLIP3(0, 51, video->QPy + video->currPicParams->chroma_qp_index_offset)]; + video->QPc_div_6 = (video->QPc * 43) >> 8; + video->QPc_mod_6 = video->QPc - 6 * video->QPc_div_6; + } + } + /* decode residue and inverse transform */ + status = residual(decvid, currMB); + if (status != AVCDEC_SUCCESS) + { + return status; + } + } + else + { + if (stream->bitcnt & 7) + { + BitstreamByteAlign(stream); + } + /* decode pcm_byte[i] */ + DecodeIntraPCM(video, stream); + + currMB->QPy = 0; /* necessary for deblocking */ // _OPTIMIZE + currMB->QPc = mapQPi2QPc[AVC_CLIP3(0, 51, video->currPicParams->chroma_qp_index_offset)]; + + /* default values, don't know if really needed */ + currMB->CBP = 0x3F; + video->cbp4x4 = 0xFFFF; + currMB->mb_intra = TRUE; + memset(currMB->nz_coeff, 16, sizeof(uint8)*NUM_BLKS_IN_MB); + return AVCDEC_SUCCESS; + } + + + /* do Intra/Inter prediction, together with the residue compensation */ + /* This part should be common between the skip and no-skip */ + if (currMB->mbMode == AVC_I4 || currMB->mbMode == AVC_I16) + { + IntraMBPrediction(video); + } + else + { + InterMBPrediction(video); + } + + + + return AVCDEC_SUCCESS; +} + +/* see subclause 7.3.5.1 */ +AVCDec_Status mb_pred(AVCCommonObj *video, AVCMacroblock *currMB, AVCDecBitstream *stream) +{ + int mbPartIdx; + AVCSliceHeader *sliceHdr = video->sliceHdr; + uint max_ref_idx; + const int *temp_0; + int16 *temp_1; + uint code; + + if (currMB->mbMode == AVC_I4 || currMB->mbMode == AVC_I16) + { + + video->intraAvailA = video->intraAvailB = video->intraAvailC = video->intraAvailD = 0; + + if (!video->currPicParams->constrained_intra_pred_flag) + { + video->intraAvailA = video->mbAvailA; + video->intraAvailB = video->mbAvailB; + video->intraAvailC = video->mbAvailC; + video->intraAvailD = video->mbAvailD; + } + else + { + if (video->mbAvailA) + { + video->intraAvailA = video->mblock[video->mbAddrA].mb_intra; + } + if (video->mbAvailB) + { + video->intraAvailB = video->mblock[video->mbAddrB].mb_intra ; + } + if (video->mbAvailC) + { + video->intraAvailC = video->mblock[video->mbAddrC].mb_intra; + } + if (video->mbAvailD) + { + video->intraAvailD = video->mblock[video->mbAddrD].mb_intra; + } + } + + + if (currMB->mbMode == AVC_I4) + { + /* perform prediction to get the actual intra 4x4 pred mode */ + DecodeIntra4x4Mode(video, currMB, stream); + /* output will be in currMB->i4Mode[4][4] */ + } + + ue_v(stream, &code); + + if (code > 3) + { + return AVCDEC_FAIL; /* out of range */ + } + currMB->intra_chroma_pred_mode = (AVCIntraChromaPredMode)code; + } + else + { + + memset(currMB->ref_idx_L0, 0, sizeof(int16)*4); + + /* see subclause 7.4.5.1 for the range of ref_idx_lX */ +// max_ref_idx = sliceHdr->num_ref_idx_l0_active_minus1; + max_ref_idx = video->refList0Size - 1; + + /* decode ref index for L0 */ + if (sliceHdr->num_ref_idx_l0_active_minus1 > 0) + { + for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++) + { + te_v(stream, &code, max_ref_idx); + if (code > (uint)max_ref_idx) + { + return AVCDEC_FAIL; + } + currMB->ref_idx_L0[mbPartIdx] = code; + } + } + + /* populate ref_idx_L0 */ + temp_0 = &mbPart2raster[currMB->mbMode-AVC_P16][0]; + temp_1 = &currMB->ref_idx_L0[3]; + + *temp_1-- = currMB->ref_idx_L0[*temp_0++]; + *temp_1-- = currMB->ref_idx_L0[*temp_0++]; + *temp_1-- = currMB->ref_idx_L0[*temp_0++]; + *temp_1-- = currMB->ref_idx_L0[*temp_0++]; + + /* Global reference index, these values are used in deblock */ + currMB->RefIdx[0] = video->RefPicList0[currMB->ref_idx_L0[0]]->RefIdx; + currMB->RefIdx[1] = video->RefPicList0[currMB->ref_idx_L0[1]]->RefIdx; + currMB->RefIdx[2] = video->RefPicList0[currMB->ref_idx_L0[2]]->RefIdx; + currMB->RefIdx[3] = video->RefPicList0[currMB->ref_idx_L0[3]]->RefIdx; + + /* see subclause 7.4.5.1 for the range of ref_idx_lX */ + max_ref_idx = sliceHdr->num_ref_idx_l1_active_minus1; + /* decode mvd_l0 */ + for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++) + { + se_v(stream, &(video->mvd_l0[mbPartIdx][0][0])); + se_v(stream, &(video->mvd_l0[mbPartIdx][0][1])); + } + } + + return AVCDEC_SUCCESS; +} + +/* see subclause 7.3.5.2 */ +AVCDec_Status sub_mb_pred(AVCCommonObj *video, AVCMacroblock *currMB, AVCDecBitstream *stream) +{ + int mbPartIdx, subMbPartIdx; + AVCSliceHeader *sliceHdr = video->sliceHdr; + uint max_ref_idx; + uint sub_mb_type[4]; + uint code; + + memset(currMB->ref_idx_L0, 0, sizeof(int16)*4); + + for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) + { + ue_v(stream, &(sub_mb_type[mbPartIdx])); + if (sub_mb_type[mbPartIdx] > 3) + { + return AVCDEC_FAIL; + } + + } + /* we have to check the values to make sure they are valid */ + /* assign values to currMB->sub_mb_type[], currMB->MBPartPredMode[][x] */ + + InterpretSubMBModeP(currMB, sub_mb_type); + + + /* see subclause 7.4.5.1 for the range of ref_idx_lX */ +// max_ref_idx = sliceHdr->num_ref_idx_l0_active_minus1; + max_ref_idx = video->refList0Size - 1; + + if (sliceHdr->num_ref_idx_l0_active_minus1 > 0 && currMB->mbMode != AVC_P8ref0) + { + for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) + { + te_v(stream, (uint*)&code, max_ref_idx); + if (code > max_ref_idx) + { + return AVCDEC_FAIL; + } + currMB->ref_idx_L0[mbPartIdx] = code; + } + } + /* see subclause 7.4.5.1 for the range of ref_idx_lX */ + + max_ref_idx = sliceHdr->num_ref_idx_l1_active_minus1; + /* if(video->MbaffFrameFlag && currMB->mb_field_decoding_flag) + max_ref_idx = 2*sliceHdr->num_ref_idx_l1_active_minus1 + 1;*/ + for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) + { + for (subMbPartIdx = 0; subMbPartIdx < currMB->NumSubMbPart[mbPartIdx]; subMbPartIdx++) + { + se_v(stream, &(video->mvd_l0[mbPartIdx][subMbPartIdx][0])); + se_v(stream, &(video->mvd_l0[mbPartIdx][subMbPartIdx][1])); + } + /* used in deblocking */ + currMB->RefIdx[mbPartIdx] = video->RefPicList0[currMB->ref_idx_L0[mbPartIdx]]->RefIdx; + } + return AVCDEC_SUCCESS; +} + +void InterpretMBModeI(AVCMacroblock *mblock, uint mb_type) +{ + mblock->NumMbPart = 1; + + mblock->mb_intra = TRUE; + + if (mb_type == 0) /* I_4x4 */ + { + mblock->mbMode = AVC_I4; + } + else if (mb_type < 25) /* I_PCM */ + { + mblock->mbMode = AVC_I16; + mblock->i16Mode = (AVCIntra16x16PredMode)((mb_type - 1) & 0x3); + if (mb_type > 12) + { + mblock->CBP = (((mb_type - 13) >> 2) << 4) + 0x0F; + } + else + { + mblock->CBP = ((mb_type - 1) >> 2) << 4; + } + } + else + { + mblock->mbMode = AVC_I_PCM; + } + + return ; +} + +void InterpretMBModeP(AVCMacroblock *mblock, uint mb_type) +{ + const static int map2PartWidth[5] = {16, 16, 8, 8, 8}; + const static int map2PartHeight[5] = {16, 8, 16, 8, 8}; + const static int map2NumPart[5] = {1, 2, 2, 4, 4}; + const static AVCMBMode map2mbMode[5] = {AVC_P16, AVC_P16x8, AVC_P8x16, AVC_P8, AVC_P8ref0}; + + mblock->mb_intra = FALSE; + if (mb_type < 5) + { + mblock->mbMode = map2mbMode[mb_type]; + mblock->MbPartWidth = map2PartWidth[mb_type]; + mblock->MbPartHeight = map2PartHeight[mb_type]; + mblock->NumMbPart = map2NumPart[mb_type]; + mblock->NumSubMbPart[0] = mblock->NumSubMbPart[1] = + mblock->NumSubMbPart[2] = mblock->NumSubMbPart[3] = 1; + mblock->SubMbPartWidth[0] = mblock->SubMbPartWidth[1] = + mblock->SubMbPartWidth[2] = mblock->SubMbPartWidth[3] = mblock->MbPartWidth; + mblock->SubMbPartHeight[0] = mblock->SubMbPartHeight[1] = + mblock->SubMbPartHeight[2] = mblock->SubMbPartHeight[3] = mblock->MbPartHeight; + } + else + { + InterpretMBModeI(mblock, mb_type - 5); + /* set MV and Ref_Idx codes of Intra blocks in P-slices */ + memset(mblock->mvL0, 0, sizeof(int32)*16); + mblock->ref_idx_L0[0] = mblock->ref_idx_L0[1] = mblock->ref_idx_L0[2] = mblock->ref_idx_L0[3] = -1; + } + return ; +} + +void InterpretMBModeB(AVCMacroblock *mblock, uint mb_type) +{ + const static int map2PartWidth[23] = {8, 16, 16, 16, 16, 8, 16, 8, 16, 8, + 16, 8, 16, 8, 16, 8, 16, 8, 16, 8, 16, 8, 8 + }; + const static int map2PartHeight[23] = {8, 16, 16, 16, 8, 16, 8, 16, 8, + 16, 8, 16, 8, 16, 8, 16, 8, 16, 8, 16, 8, 16, 8 + }; + /* see enum AVCMBType declaration */ + const static AVCMBMode map2mbMode[23] = {AVC_BDirect16, AVC_P16, AVC_P16, AVC_P16, + AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16, + AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16, + AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16, AVC_P16x8, AVC_P8x16, AVC_P8 + }; + 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}; + 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}; + 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}; + + mblock->mb_intra = FALSE; + + if (mb_type < 23) + { + mblock->mbMode = map2mbMode[mb_type]; + mblock->NumMbPart = map2NumPart[mb_type]; + mblock->MBPartPredMode[0][0] = (AVCPredMode)map2PredMode1[mb_type]; + if (mblock->NumMbPart > 1) + { + mblock->MBPartPredMode[1][0] = (AVCPredMode)map2PredMode2[mb_type]; + } + mblock->MbPartWidth = map2PartWidth[mb_type]; + mblock->MbPartHeight = map2PartHeight[mb_type]; + } + else + { + InterpretMBModeI(mblock, mb_type - 23); + } + + return ; +} + +void InterpretMBModeSI(AVCMacroblock *mblock, uint mb_type) +{ + mblock->mb_intra = TRUE; + + if (mb_type == 0) + { + mblock->mbMode = AVC_SI4; + /* other values are N/A */ + } + else + { + InterpretMBModeI(mblock, mb_type - 1); + } + return ; +} + +/* input is mblock->sub_mb_type[] */ +void InterpretSubMBModeP(AVCMacroblock *mblock, uint *sub_mb_type) +{ + int i, sub_type; + /* see enum AVCMBType declaration */ +// const static AVCSubMBMode map2subMbMode[4] = {AVC_8x8,AVC_8x4,AVC_4x8,AVC_4x4}; + const static int map2subPartWidth[4] = {8, 8, 4, 4}; + const static int map2subPartHeight[4] = {8, 4, 8, 4}; + const static int map2numSubPart[4] = {1, 2, 2, 4}; + + for (i = 0; i < 4 ; i++) + { + sub_type = (int) sub_mb_type[i]; + // mblock->subMbMode[i] = map2subMbMode[sub_type]; + mblock->NumSubMbPart[i] = map2numSubPart[sub_type]; + mblock->SubMbPartWidth[i] = map2subPartWidth[sub_type]; + mblock->SubMbPartHeight[i] = map2subPartHeight[sub_type]; + } + + return ; +} + +void InterpretSubMBModeB(AVCMacroblock *mblock, uint *sub_mb_type) +{ + int i, j, sub_type; + /* see enum AVCMBType declaration */ + const static AVCSubMBMode map2subMbMode[13] = {AVC_BDirect8, AVC_8x8, AVC_8x8, + AVC_8x8, AVC_8x4, AVC_4x8, AVC_8x4, AVC_4x8, AVC_8x4, AVC_4x8, AVC_4x4, AVC_4x4, AVC_4x4 + }; + const static int map2subPartWidth[13] = {4, 8, 8, 8, 8, 4, 8, 4, 8, 4, 4, 4, 4}; + const static int map2subPartHeight[13] = {4, 8, 8, 8, 4, 8, 4, 8, 4, 8, 4, 4, 4}; + const static int map2numSubPart[13] = {1, 1, 1, 2, 2, 2, 2, 2, 2, 4, 4, 4}; + const static int map2predMode[13] = {3, 0, 1, 2, 0, 0, 1, 1, 2, 2, 0, 1, 2}; + + for (i = 0; i < 4 ; i++) + { + sub_type = (int) sub_mb_type[i]; + mblock->subMbMode[i] = map2subMbMode[sub_type]; + mblock->NumSubMbPart[i] = map2numSubPart[sub_type]; + mblock->SubMbPartWidth[i] = map2subPartWidth[sub_type]; + mblock->SubMbPartHeight[i] = map2subPartHeight[sub_type]; + for (j = 0; j < 4; j++) + { + mblock->MBPartPredMode[i][j] = (AVCPredMode)map2predMode[sub_type]; + } + } + + return ; +} + +/* see subclause 8.3.1 */ +AVCDec_Status DecodeIntra4x4Mode(AVCCommonObj *video, AVCMacroblock *currMB, AVCDecBitstream *stream) +{ + int intra4x4PredModeA = 0, intra4x4PredModeB = 0, predIntra4x4PredMode = 0; + int component, SubBlock_indx, block_x, block_y; + int dcOnlyPredictionFlag; + uint prev_intra4x4_pred_mode_flag[16]; + int rem_intra4x4_pred_mode[16]; + int bindx = 0; + + for (component = 0; component < 4; component++) /* partition index */ + { + block_x = ((component & 1) << 1); + block_y = ((component >> 1) << 1); + + for (SubBlock_indx = 0; SubBlock_indx < 4; SubBlock_indx++) /* sub-partition index */ + { + BitstreamRead1Bit(stream, &(prev_intra4x4_pred_mode_flag[bindx])); + + if (!prev_intra4x4_pred_mode_flag[bindx]) + { + BitstreamReadBits(stream, 3, (uint*)&(rem_intra4x4_pred_mode[bindx])); + } + + dcOnlyPredictionFlag = 0; + if (block_x > 0) + { + intra4x4PredModeA = currMB->i4Mode[(block_y << 2) + block_x - 1 ]; + } + else + { + if (video->intraAvailA) + { + if (video->mblock[video->mbAddrA].mbMode == AVC_I4) + { + intra4x4PredModeA = video->mblock[video->mbAddrA].i4Mode[(block_y << 2) + 3]; + } + else + { + intra4x4PredModeA = AVC_I4_DC; + } + } + else + { + dcOnlyPredictionFlag = 1; + } + } + + if (block_y > 0) + { + intra4x4PredModeB = currMB->i4Mode[((block_y-1) << 2) + block_x]; + } + else + { + if (video->intraAvailB) + { + if (video->mblock[video->mbAddrB].mbMode == AVC_I4) + { + intra4x4PredModeB = video->mblock[video->mbAddrB].i4Mode[(3 << 2) + block_x]; + } + else + { + intra4x4PredModeB = AVC_I4_DC; + } + } + else + { + dcOnlyPredictionFlag = 1; + } + } + + if (dcOnlyPredictionFlag) + { + intra4x4PredModeA = intra4x4PredModeB = AVC_I4_DC; + } + + predIntra4x4PredMode = AVC_MIN(intra4x4PredModeA, intra4x4PredModeB); + if (prev_intra4x4_pred_mode_flag[bindx]) + { + currMB->i4Mode[(block_y<<2)+block_x] = (AVCIntra4x4PredMode)predIntra4x4PredMode; + } + else + { + if (rem_intra4x4_pred_mode[bindx] < predIntra4x4PredMode) + { + currMB->i4Mode[(block_y<<2)+block_x] = (AVCIntra4x4PredMode)rem_intra4x4_pred_mode[bindx]; + } + else + { + currMB->i4Mode[(block_y<<2)+block_x] = (AVCIntra4x4PredMode)(rem_intra4x4_pred_mode[bindx] + 1); + } + } + bindx++; + block_y += (SubBlock_indx & 1) ; + block_x += (1 - 2 * (SubBlock_indx & 1)) ; + } + } + return AVCDEC_SUCCESS; +} +AVCDec_Status ConcealSlice(AVCDecObject *decvid, int mbnum_start, int mbnum_end) +{ + AVCCommonObj *video = decvid->common; + AVCMacroblock *currMB ; + + int CurrMbAddr; + + if (video->RefPicList0[0] == NULL) + { + return AVCDEC_FAIL; + } + + for (CurrMbAddr = mbnum_start; CurrMbAddr < mbnum_end; CurrMbAddr++) + { + currMB = video->currMB = &(video->mblock[CurrMbAddr]); + video->mbNum = CurrMbAddr; + currMB->slice_id = video->slice_id++; // slice + + /* we can remove this check if we don't support Mbaff. */ + /* we can wrap below into an initMB() function which will also + do necessary reset of macroblock related parameters. */ + + video->mb_x = CurrMbAddr % video->PicWidthInMbs; + video->mb_y = CurrMbAddr / video->PicWidthInMbs; + + /* check the availability of neighboring macroblocks */ + InitNeighborAvailability(video, CurrMbAddr); + + currMB->mb_intra = FALSE; + + currMB->mbMode = AVC_SKIP; + currMB->MbPartWidth = currMB->MbPartHeight = 16; + + currMB->NumMbPart = 1; + currMB->NumSubMbPart[0] = currMB->NumSubMbPart[1] = + currMB->NumSubMbPart[2] = currMB->NumSubMbPart[3] = 1; + currMB->SubMbPartWidth[0] = currMB->SubMbPartWidth[1] = + currMB->SubMbPartWidth[2] = currMB->SubMbPartWidth[3] = currMB->MbPartWidth; + currMB->SubMbPartHeight[0] = currMB->SubMbPartHeight[1] = + currMB->SubMbPartHeight[2] = currMB->SubMbPartHeight[3] = currMB->MbPartHeight; + currMB->QPy = 26; + currMB->QPc = 26; + memset(currMB->nz_coeff, 0, sizeof(uint8)*NUM_BLKS_IN_MB); + + currMB->CBP = 0; + video->cbp4x4 = 0; + /* for skipped MB, always look at the first entry in RefPicList */ + currMB->RefIdx[0] = currMB->RefIdx[1] = + currMB->RefIdx[2] = currMB->RefIdx[3] = video->RefPicList0[0]->RefIdx; + InterMBPrediction(video); + + video->numMBs--; + + } + + return AVCDEC_SUCCESS; +} + |