| /* ------------------------------------------------------------------ |
| * 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. |
| * ------------------------------------------------------------------- |
| */ |
| #include "mp4dec_lib.h" |
| #include "vlc_decode.h" |
| #include "bitstream.h" |
| #include "scaling.h" |
| #include "mbtype_mode.h" |
| #include "idct.h" |
| |
| #define OSCL_DISABLE_WARNING_CONDITIONAL_IS_CONSTANT |
| /* ======================================================================== */ |
| /* Function : DecodeFrameDataPartMode() */ |
| /* Purpose : Decode a frame of MPEG4 bitstream in datapartitioning mode. */ |
| /* In/out : */ |
| /* Return : */ |
| /* Modified : */ |
| /* */ |
| /* 04/25/2000 : Rewrite the data partitioning path completely */ |
| /* according to the pseudo codes in MPEG-4 */ |
| /* standard. */ |
| /* Modified : 09/18/2000 add fast VlcDecode+Dequant */ |
| /* 04/17/2001 cleanup */ |
| /* ======================================================================== */ |
| PV_STATUS DecodeFrameDataPartMode(VideoDecData *video) |
| { |
| PV_STATUS status; |
| Vop *currVop = video->currVop; |
| BitstreamDecVideo *stream = video->bitstream; |
| |
| int nMBPerRow = video->nMBPerRow; |
| |
| int vopType = currVop->predictionType; |
| int mbnum; |
| int nTotalMB = video->nTotalMB; |
| int slice_counter; |
| int resync_marker_length; |
| |
| /* copy and pad to prev_Vop for INTER coding */ |
| switch (vopType) |
| { |
| case I_VOP : |
| // oscl_memset(Mode, MODE_INTRA, sizeof(uint8)*nTotalMB); |
| resync_marker_length = 17; |
| break; |
| case P_VOP : |
| oscl_memset(video->motX, 0, sizeof(MOT)*4*nTotalMB); |
| oscl_memset(video->motY, 0, sizeof(MOT)*4*nTotalMB); |
| // oscl_memset(Mode, MODE_INTER, sizeof(uint8)*nTotalMB); |
| resync_marker_length = 16 + currVop->fcodeForward; |
| break; |
| default : |
| mp4dec_log("DecodeFrameDataPartMode(): Vop type not supported.\n"); |
| return PV_FAIL; |
| } |
| |
| /** Initialize sliceNo ***/ |
| mbnum = slice_counter = 0; |
| // oscl_memset(video->sliceNo, 0, sizeof(uint8)*nTotalMB); |
| |
| do |
| { |
| /* This section is equivalent to motion_shape_texture() */ |
| /* in the MPEG-4 standard. 04/13/2000 */ |
| video->mbnum = mbnum; |
| video->mbnum_row = PV_GET_ROW(mbnum, nMBPerRow); /* This is needed if nbnum is read from the packet header */ |
| video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow; |
| |
| switch (vopType) |
| { |
| case I_VOP : |
| status = DecodeDataPart_I_VideoPacket(video, slice_counter); |
| break; |
| |
| case P_VOP : |
| status = DecodeDataPart_P_VideoPacket(video, slice_counter); |
| break; |
| |
| default : |
| mp4dec_log("DecodeFrameDataPartMode(): Vop type not supported.\n"); |
| return PV_FAIL; |
| } |
| |
| while ((status = PV_ReadVideoPacketHeader(video, &mbnum)) == PV_FAIL) |
| { |
| if ((status = quickSearchVideoPacketHeader(stream, resync_marker_length)) != PV_SUCCESS) |
| { |
| break; |
| } |
| } |
| |
| if (status == PV_END_OF_VOP) |
| { |
| mbnum = nTotalMB; |
| } |
| |
| if (mbnum > video->mbnum + 1) |
| { |
| ConcealPacket(video, video->mbnum, mbnum, slice_counter); |
| } |
| slice_counter++; |
| if (mbnum >= nTotalMB) |
| { |
| break; |
| } |
| |
| |
| } |
| while (TRUE); |
| |
| return PV_SUCCESS; |
| } |
| |
| |
| /* ======================================================================== */ |
| /* Function : DecodeDataPart_I_VideoPacket() */ |
| /* Date : 04/25/2000 */ |
| /* Purpose : Decode Data Partitioned Mode Video Packet in I-VOP */ |
| /* In/out : */ |
| /* Return : PV_SUCCESS if successed, PV_FAIL if failed. */ |
| /* Modified : 09/18/2000 add fast VlcDecode+Dequant */ |
| /* 04/01/2001 fixed MB_stuffing, removed unnecessary code */ |
| /* ======================================================================== */ |
| PV_STATUS DecodeDataPart_I_VideoPacket(VideoDecData *video, int slice_counter) |
| { |
| PV_STATUS status; |
| uint8 *Mode = video->headerInfo.Mode; |
| BitstreamDecVideo *stream = video->bitstream; |
| int nTotalMB = video->nTotalMB; |
| int mbnum, mb_start, mb_end; |
| int16 QP, *QPMB = video->QPMB; |
| int MBtype, MCBPC, CBPY; |
| uint32 tmpvar; |
| uint code; |
| int nMBPerRow = video->nMBPerRow; |
| Bool valid_stuffing; |
| int32 startSecondPart, startFirstPart = getPointer(stream); |
| |
| /* decode the first partition */ |
| QP = video->currVop->quantizer; |
| mb_start = mbnum = video->mbnum; |
| video->usePrevQP = 0; /* 04/27/01 */ |
| |
| |
| BitstreamShowBits16(stream, 9, &code); |
| while (code == 1) |
| { |
| PV_BitstreamFlushBits(stream, 9); |
| BitstreamShowBits16(stream, 9, &code); |
| } |
| |
| do |
| { |
| /* decode COD, MCBPC, ACpred_flag, CPBY and DQUANT */ |
| MCBPC = PV_VlcDecMCBPC_com_intra(stream); |
| |
| if (!VLC_ERROR_DETECTED(MCBPC)) |
| { |
| Mode[mbnum] = (uint8)(MBtype = MBtype_mode[MCBPC & 7]); |
| video->headerInfo.CBP[mbnum] = (uint8)((MCBPC >> 4) & 3); |
| status = GetMBheaderDataPart_DQUANT_DC(video, &QP); |
| video->usePrevQP = 1; /* set it after the first coded MB 04/27/01 */ |
| } |
| else |
| { |
| /* Report the error to the application. 06/20/2000 */ |
| VideoDecoderErrorDetected(video); |
| video->mbnum = mb_start; |
| movePointerTo(stream, startFirstPart); |
| return PV_FAIL; |
| } |
| |
| video->sliceNo[mbnum] = (uint8) slice_counter; |
| QPMB[mbnum] = QP; |
| video->mbnum = ++mbnum; |
| |
| BitstreamShowBits16(stream, 9, &code); |
| while (code == 1) |
| { |
| PV_BitstreamFlushBits(stream, 9); |
| BitstreamShowBits16(stream, 9, &code); |
| } |
| /* have we reached the end of the video packet or vop? */ |
| status = BitstreamShowBits32(stream, DC_MARKER_LENGTH, &tmpvar); |
| |
| } |
| while (tmpvar != DC_MARKER && video->mbnum < nTotalMB); |
| |
| if (tmpvar == DC_MARKER) |
| { |
| PV_BitstreamFlushBits(stream, DC_MARKER_LENGTH); |
| } |
| else |
| { |
| status = quickSearchDCM(stream); |
| if (status == PV_SUCCESS) |
| { |
| /* only way you can end up being here is in the last packet,and there is stuffing at |
| the end of the first partition */ |
| PV_BitstreamFlushBits(stream, DC_MARKER_LENGTH); |
| } |
| else |
| { |
| /* Report the error to the application. 06/20/2000 */ |
| VideoDecoderErrorDetected(video); |
| movePointerTo(stream, startFirstPart); |
| video->mbnum = mb_start; |
| /* concealment will be taken care of in the upper layer */ |
| return PV_FAIL; |
| } |
| } |
| |
| /* decode the second partition */ |
| startSecondPart = getPointer(stream); |
| |
| mb_end = video->mbnum; |
| |
| for (mbnum = mb_start; mbnum < mb_end; mbnum++) |
| { |
| MBtype = Mode[mbnum]; |
| /* No skipped mode in I-packets 3/1/2001 */ |
| video->mbnum = mbnum; |
| |
| video->mbnum_row = PV_GET_ROW(mbnum, nMBPerRow); /* This is needed if nbnum is read from the packet header */ |
| video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow; |
| /* there is always acdcpred in DataPart mode 04/10/01 */ |
| video->acPredFlag[mbnum] = (uint8) BitstreamRead1Bits(stream); |
| |
| CBPY = PV_VlcDecCBPY(stream, MBtype & INTRA_MASK); /* MODE_INTRA || MODE_INTRA_Q */ |
| if (CBPY < 0) |
| { |
| /* Report the error to the application. 06/20/2000 */ |
| VideoDecoderErrorDetected(video); |
| movePointerTo(stream, startSecondPart); /* */ |
| /* Conceal packet, 05/15/2000 */ |
| ConcealTexture_I(video, startFirstPart, mb_start, mb_end, slice_counter); |
| return PV_FAIL; |
| } |
| |
| video->headerInfo.CBP[mbnum] |= (uint8)(CBPY << 2); |
| } |
| |
| video->usePrevQP = 0; |
| |
| for (mbnum = mb_start; mbnum < mb_end; mbnum++) |
| { |
| video->mbnum = mbnum; |
| |
| video->mbnum_row = PV_GET_ROW(mbnum , nMBPerRow); /* This is needed if nbnum is read from the packet header */ |
| video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow; |
| /* No skipped mode in I-packets 3/1/2001 */ |
| /* decode the DCT coeficients for the MB */ |
| status = GetMBData_DataPart(video); |
| if (status != PV_SUCCESS) |
| { |
| /* Report the error to the application. 06/20/2000 */ |
| VideoDecoderErrorDetected(video); |
| movePointerTo(stream, startSecondPart); /* */ |
| /* Conceal packet, 05/15/2000 */ |
| ConcealTexture_I(video, startFirstPart, mb_start, mb_end, slice_counter); |
| return status; |
| } |
| video->usePrevQP = 1; /* 04/27/01 should be set after decoding first MB */ |
| } |
| |
| valid_stuffing = validStuffing(stream); |
| if (!valid_stuffing) |
| { |
| VideoDecoderErrorDetected(video); |
| movePointerTo(stream, startSecondPart); |
| ConcealTexture_I(video, startFirstPart, mb_start, mb_end, slice_counter); |
| return PV_FAIL; |
| } |
| return PV_SUCCESS; |
| } |
| |
| |
| /* ======================================================================== */ |
| /* Function : DecodeDataPart_P_VideoPacket() */ |
| /* Date : 04/25/2000 */ |
| /* Purpose : Decode Data Partitioned Mode Video Packet in P-VOP */ |
| /* In/out : */ |
| /* Return : PV_SUCCESS if successed, PV_FAIL if failed. */ |
| /* Modified : 09/18/2000, fast VlcDecode+Dequant */ |
| /* 04/13/2001, fixed MB_stuffing, new ACDC pred structure, */ |
| /* cleanup */ |
| /* 08/07/2001, remove MBzero */ |
| /* ======================================================================== */ |
| PV_STATUS DecodeDataPart_P_VideoPacket(VideoDecData *video, int slice_counter) |
| { |
| PV_STATUS status; |
| uint8 *Mode = video->headerInfo.Mode; |
| BitstreamDecVideo *stream = video->bitstream; |
| int nTotalMB = video->nTotalMB; |
| int mbnum, mb_start, mb_end; |
| int16 QP, *QPMB = video->QPMB; |
| int MBtype, CBPY; |
| Bool valid_stuffing; |
| int intra_MB; |
| uint32 tmpvar; |
| uint code; |
| int32 startFirstPart, startSecondPart; |
| int nMBPerRow = video->nMBPerRow; |
| uint8 *pbyte; |
| /* decode the first partition */ |
| startFirstPart = getPointer(stream); |
| mb_start = video->mbnum; |
| video->usePrevQP = 0; /* 04/27/01 */ |
| |
| BitstreamShowBits16(stream, 10, &code); |
| while (code == 1) |
| { |
| PV_BitstreamFlushBits(stream, 10); |
| BitstreamShowBits16(stream, 10, &code); |
| } |
| |
| do |
| { |
| /* decode COD, MCBPC, ACpred_flag, CPBY and DQUANT */ |
| /* We have to discard stuffed MB header */ |
| |
| status = GetMBheaderDataPart_P(video); |
| |
| if (status != PV_SUCCESS) |
| { |
| /* Report the error to the application. 06/20/2000 */ |
| VideoDecoderErrorDetected(video); |
| movePointerTo(stream, startFirstPart); |
| video->mbnum = mb_start; |
| return PV_FAIL; |
| } |
| |
| /* we must update slice_counter before motion vector decoding. */ |
| video->sliceNo[video->mbnum] = (uint8) slice_counter; |
| |
| if (Mode[video->mbnum] & INTER_MASK) /* INTER || INTER_Q || INTER_4V */ |
| { |
| /* decode the motion vector (if there are any) */ |
| status = PV_GetMBvectors(video, Mode[video->mbnum]); |
| if (status != PV_SUCCESS) |
| { |
| /* Report the error to the application. 06/20/2000 */ |
| VideoDecoderErrorDetected(video); |
| movePointerTo(stream, startFirstPart); |
| video->mbnum = mb_start; |
| return PV_FAIL; |
| } |
| } |
| video->mbnum++; |
| |
| video->mbnum_row = PV_GET_ROW(video->mbnum, nMBPerRow); /* This is needed if mbnum is read from the packet header */ |
| video->mbnum_col = video->mbnum - video->mbnum_row * nMBPerRow; |
| |
| BitstreamShowBits16(stream, 10, &code); |
| while (code == 1) |
| { |
| PV_BitstreamFlushBits(stream, 10); |
| BitstreamShowBits16(stream, 10, &code); |
| } |
| /* have we reached the end of the video packet or vop? */ |
| status = BitstreamShowBits32(stream, MOTION_MARKER_COMB_LENGTH, &tmpvar); |
| /* if (status != PV_SUCCESS && status != PV_END_OF_BUFFER) return status; */ |
| } |
| while (tmpvar != MOTION_MARKER_COMB && video->mbnum < nTotalMB); |
| |
| if (tmpvar == MOTION_MARKER_COMB) |
| { |
| PV_BitstreamFlushBits(stream, MOTION_MARKER_COMB_LENGTH); |
| } |
| else |
| { |
| status = quickSearchMotionMarker(stream); |
| if (status == PV_SUCCESS) |
| { |
| /* only way you can end up being here is in the last packet,and there is stuffing at |
| the end of the first partition */ |
| PV_BitstreamFlushBits(stream, MOTION_MARKER_COMB_LENGTH); |
| } |
| else |
| { |
| /* Report the error to the application. 06/20/2000 */ |
| VideoDecoderErrorDetected(video); |
| movePointerTo(stream, startFirstPart); |
| video->mbnum = mb_start; |
| /* concealment will be taken care of in the upper layer */ |
| return PV_FAIL; |
| } |
| } |
| |
| /* decode the second partition */ |
| startSecondPart = getPointer(stream); |
| QP = video->currVop->quantizer; |
| |
| mb_end = video->mbnum; |
| |
| for (mbnum = mb_start; mbnum < mb_end; mbnum++) |
| { |
| MBtype = Mode[mbnum]; |
| |
| if (MBtype == MODE_SKIPPED) |
| { |
| QPMB[mbnum] = QP; /* 03/01/01 */ |
| continue; |
| } |
| intra_MB = (MBtype & INTRA_MASK); /* (MBtype == MODE_INTRA || MBtype == MODE_INTRA_Q) */ |
| video->mbnum = mbnum; |
| video->mbnum_row = PV_GET_ROW(mbnum, nMBPerRow); /* This is needed if nbnum is read from the packet header */ |
| video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow; |
| |
| /* there is always acdcprediction in DataPart mode 04/10/01 */ |
| if (intra_MB) |
| { |
| video->acPredFlag[mbnum] = (uint8) BitstreamRead1Bits_INLINE(stream); |
| } |
| |
| CBPY = PV_VlcDecCBPY(stream, intra_MB); |
| if (CBPY < 0) |
| { |
| /* Report the error to the application. 06/20/2000 */ |
| VideoDecoderErrorDetected(video); |
| /* Conceal second partition, 5/15/2000 */ |
| movePointerTo(stream, startSecondPart); |
| ConcealTexture_P(video, mb_start, mb_end, slice_counter); |
| return PV_FAIL; |
| } |
| |
| video->headerInfo.CBP[mbnum] |= (uint8)(CBPY << 2); |
| if (intra_MB || MBtype == MODE_INTER_Q) /* 04/26/01 */ |
| { |
| status = GetMBheaderDataPart_DQUANT_DC(video, &QP); |
| if (status != PV_SUCCESS) return status; |
| } |
| video->usePrevQP = 1; /* 04/27/01 */ |
| QPMB[mbnum] = QP; |
| } |
| |
| video->usePrevQP = 0; /* 04/27/01 */ |
| |
| for (mbnum = mb_start; mbnum < mb_end; mbnum++) |
| { |
| video->mbnum = mbnum; |
| video->mbnum_row = PV_GET_ROW(mbnum, nMBPerRow); /* This is needed if nbnum is read from the packet header */ |
| video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow; |
| |
| |
| if (Mode[mbnum] != MODE_SKIPPED) |
| { |
| /* decode the DCT coeficients for the MB */ |
| status = GetMBData_DataPart(video); |
| if (status != PV_SUCCESS) |
| { |
| /* Report the error to the application. 06/20/2000 */ |
| VideoDecoderErrorDetected(video); |
| |
| /* Conceal second partition, 5/15/2000 */ |
| movePointerTo(stream, startSecondPart); |
| ConcealTexture_P(video, mb_start, mb_end, slice_counter); |
| return status; |
| } |
| video->usePrevQP = 1; /* 04/27/01 */ |
| } |
| else |
| { // SKIPPED |
| |
| /* Motion compensation and put it to video->mblock->pred_block */ |
| SkippedMBMotionComp(video); |
| |
| //oscl_memset(video->predDCAC_row + video->mbnum_col, 0, sizeof(typeDCACStore)); /* SKIPPED_ACDC */ |
| //oscl_memset(video->predDCAC_col, 0, sizeof(typeDCACStore)); |
| /* 08/08/2005 */ |
| pbyte = (uint8*)(video->predDCAC_row + video->mbnum_col); |
| ZERO_OUT_64BYTES(pbyte); |
| pbyte = (uint8*)(video->predDCAC_col); |
| ZERO_OUT_64BYTES(pbyte); |
| |
| } |
| } |
| |
| valid_stuffing = validStuffing(stream); /* */ |
| if (!valid_stuffing) |
| { |
| VideoDecoderErrorDetected(video); |
| movePointerTo(stream, startSecondPart); /* */ |
| ConcealTexture_P(video, mb_start, mb_end, slice_counter); |
| |
| return PV_FAIL; |
| } |
| return PV_SUCCESS; |
| } |
| |
| |
| /* ======================================================================== */ |
| /* Function : GetMBheaderDataPart_DQUANT_DC() */ |
| /* Date : 04/26/2000 */ |
| /* Purpose : Decode DQUANT and DC in Data Partitioned Mode for both */ |
| /* I-VOP and P-VOP. */ |
| /* In/out : */ |
| /* Return : PV_SUCCESS if successed, PV_FAIL if failed. */ |
| /* Modified : 02/13/2001 new ACDC prediction structure, */ |
| /* cleanup */ |
| /* ======================================================================== */ |
| PV_STATUS GetMBheaderDataPart_DQUANT_DC(VideoDecData *video, int16 *QP) |
| { |
| PV_STATUS status = PV_SUCCESS; |
| BitstreamDecVideo *stream = video->bitstream; |
| int mbnum = video->mbnum; |
| int intra_dc_vlc_thr = video->currVop->intraDCVlcThr; |
| uint8 *Mode = video->headerInfo.Mode; |
| int MBtype = Mode[mbnum]; |
| typeDCStore *DC = video->predDC + mbnum; |
| int comp; |
| Bool switched; |
| uint DQUANT; |
| int16 QP_tmp; |
| |
| const static int DQ_tab[4] = { -1, -2, 1, 2}; |
| |
| if (MBtype & Q_MASK) /* INTRA_Q || INTER_Q */ |
| { |
| DQUANT = BitstreamReadBits16(stream, 2); |
| *QP += DQ_tab[DQUANT]; |
| |
| if (*QP < 1) *QP = 1; |
| else if (*QP > 31) *QP = 31; |
| } |
| if (MBtype & INTRA_MASK) /* INTRA || INTRA_Q */ /* no switch, code DC separately */ |
| { |
| QP_tmp = *QP; /* running QP 04/26/01*/ |
| switched = 0; |
| if (intra_dc_vlc_thr) /* 04/27/01 */ |
| { |
| if (video->usePrevQP) |
| QP_tmp = video->QPMB[mbnum-1]; |
| switched = (intra_dc_vlc_thr == 7 || QP_tmp >= intra_dc_vlc_thr * 2 + 11); |
| } |
| if (!switched) |
| { |
| for (comp = 0; comp < 6; comp++) |
| { |
| status = PV_DecodePredictedIntraDC(comp, stream, (*DC + comp)); /* 03/01/01 */ |
| if (status != PV_SUCCESS) return PV_FAIL; |
| } |
| } |
| else |
| { |
| for (comp = 0; comp < 6; comp++) |
| { |
| (*DC)[comp] = 0; /* 04/26/01 needed for switched case*/ |
| } |
| } |
| } |
| return status; |
| } |
| |
| |
| /***********************************************************CommentBegin****** |
| * 04/25/2000 : Initial modification to the new PV Lib format. |
| * 04/17/2001 : new ACDC pred structure |
| ***********************************************************CommentEnd********/ |
| PV_STATUS GetMBheaderDataPart_P(VideoDecData *video) |
| { |
| BitstreamDecVideo *stream = video->bitstream; |
| int mbnum = video->mbnum; |
| uint8 *Mode = video->headerInfo.Mode; |
| typeDCStore *DC = video->predDC + mbnum; |
| uint no_dct_flag; |
| int comp; |
| int MCBPC; |
| |
| no_dct_flag = BitstreamRead1Bits_INLINE(stream); |
| |
| if (no_dct_flag) |
| { |
| /* skipped macroblock */ |
| Mode[mbnum] = MODE_SKIPPED; |
| |
| for (comp = 0; comp < 6; comp++) |
| { |
| (*DC)[comp] = mid_gray; |
| /* ACDC REMOVE AC coefs are set in DecodeDataPart_P */ |
| } |
| } |
| else |
| { |
| /* coded macroblock */ |
| MCBPC = PV_VlcDecMCBPC_com_inter(stream); |
| |
| if (VLC_ERROR_DETECTED(MCBPC)) |
| { |
| return PV_FAIL; |
| } |
| |
| Mode[mbnum] = (uint8)MBtype_mode[MCBPC & 7]; |
| video->headerInfo.CBP[mbnum] = (uint8)((MCBPC >> 4) & 3); |
| } |
| |
| return PV_SUCCESS; |
| } |
| |
| |
| /***********************************************************CommentBegin****** |
| * 04/17/01 new ACDC pred structure, reorganized code, cleanup |
| ***********************************************************CommentEnd********/ |
| PV_STATUS GetMBData_DataPart(VideoDecData *video) |
| { |
| int mbnum = video->mbnum; |
| int16 *dataBlock; |
| MacroBlock *mblock = video->mblock; |
| int QP = video->QPMB[mbnum]; |
| int32 offset; |
| PIXEL *c_comp; |
| int width = video->width; |
| int intra_dc_vlc_thr = video->currVop->intraDCVlcThr; |
| uint CBP = video->headerInfo.CBP[mbnum]; |
| uint8 mode = video->headerInfo.Mode[mbnum]; |
| int x_pos = video->mbnum_col; |
| typeDCStore *DC = video->predDC + mbnum; |
| int ncoeffs[6], *no_coeff = mblock->no_coeff; |
| int comp; |
| Bool switched; |
| int QP_tmp = QP; |
| |
| int y_pos = video->mbnum_row; |
| #ifdef PV_POSTPROC_ON |
| uint8 *pp_mod[6]; |
| int TotalMB = video->nTotalMB; |
| int MB_in_width = video->nMBPerRow; |
| #endif |
| |
| |
| |
| /***** |
| * Decoding of the 6 blocks (depending on transparent pattern) |
| *****/ |
| #ifdef PV_POSTPROC_ON |
| if (video->postFilterType != PV_NO_POST_PROC) |
| { |
| /** post-processing ***/ |
| pp_mod[0] = video->pstprcTypCur + (y_pos << 1) * (MB_in_width << 1) + (x_pos << 1); |
| pp_mod[1] = pp_mod[0] + 1; |
| pp_mod[2] = pp_mod[0] + (MB_in_width << 1); |
| pp_mod[3] = pp_mod[2] + 1; |
| pp_mod[4] = video->pstprcTypCur + (TotalMB << 2) + mbnum; |
| pp_mod[5] = pp_mod[4] + TotalMB; |
| } |
| #endif |
| |
| /* oscl_memset(mblock->block, 0, sizeof(typeMBStore)); Aug 9,2005 */ |
| |
| if (mode & INTRA_MASK) /* MODE_INTRA || mode == MODE_INTRA_Q */ |
| { |
| switched = 0; |
| if (intra_dc_vlc_thr) |
| { |
| if (video->usePrevQP) |
| QP_tmp = video->QPMB[mbnum-1]; /* running QP 04/26/01 */ |
| |
| switched = (intra_dc_vlc_thr == 7 || QP_tmp >= intra_dc_vlc_thr * 2 + 11); |
| } |
| |
| mblock->DCScalarLum = cal_dc_scaler(QP, LUMINANCE_DC_TYPE); /* ACDC 03/01/01 */ |
| mblock->DCScalarChr = cal_dc_scaler(QP, CHROMINANCE_DC_TYPE); |
| |
| for (comp = 0; comp < 6; comp++) |
| { |
| dataBlock = mblock->block[comp]; /*, 10/20/2000 */ |
| |
| dataBlock[0] = (*DC)[comp]; |
| |
| ncoeffs[comp] = VlcDequantH263IntraBlock(video, comp, |
| switched, mblock->bitmapcol[comp], &mblock->bitmaprow[comp]); |
| |
| if (VLC_ERROR_DETECTED(ncoeffs[comp])) /* */ |
| { |
| if (switched) |
| return PV_FAIL; |
| else |
| { |
| ncoeffs[comp] = 1; |
| oscl_memset((dataBlock + 1), 0, sizeof(int16)*63); |
| } |
| } |
| no_coeff[comp] = ncoeffs[comp]; |
| /* modified to new semaphore for post-proc */ |
| // Future work:: can be combined in the dequant function |
| // @todo Deblocking Semaphore for INTRA block |
| #ifdef PV_POSTPROC_ON |
| if (video->postFilterType != PV_NO_POST_PROC) |
| *pp_mod[comp] = (uint8) PostProcSemaphore(dataBlock); |
| #endif |
| } |
| MBlockIDCT(video); |
| } |
| else /* MODE INTER*/ |
| { |
| |
| |
| |
| |
| MBMotionComp(video, CBP); |
| offset = (int32)(y_pos << 4) * width + (x_pos << 4); |
| c_comp = video->currVop->yChan + offset; |
| |
| |
| for (comp = 0; comp < 4; comp++) |
| { |
| (*DC)[comp] = mid_gray; |
| |
| if (CBP & (1 << (5 - comp))) |
| { |
| ncoeffs[comp] = VlcDequantH263InterBlock(video, comp, |
| mblock->bitmapcol[comp], &mblock->bitmaprow[comp]); |
| if (VLC_ERROR_DETECTED(ncoeffs[comp])) |
| return PV_FAIL; |
| |
| |
| BlockIDCT(c_comp + (comp&2)*(width << 2) + 8*(comp&1), mblock->pred_block + (comp&2)*64 + 8*(comp&1), mblock->block[comp], width, ncoeffs[comp], |
| mblock->bitmapcol[comp], mblock->bitmaprow[comp]); |
| |
| } |
| else |
| { |
| ncoeffs[comp] = 0; |
| } |
| |
| /* @todo Deblocking Semaphore for INTRA block, for inter just test for ringing */ |
| #ifdef PV_POSTPROC_ON |
| if (video->postFilterType != PV_NO_POST_PROC) |
| *pp_mod[comp] = (uint8)((ncoeffs[comp] > 3) ? 4 : 0); |
| #endif |
| } |
| |
| (*DC)[4] = mid_gray; |
| if (CBP & 2) |
| { |
| ncoeffs[4] = VlcDequantH263InterBlock(video, 4, |
| mblock->bitmapcol[4], &mblock->bitmaprow[4]); |
| if (VLC_ERROR_DETECTED(ncoeffs[4])) |
| return PV_FAIL; |
| |
| BlockIDCT(video->currVop->uChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 256, mblock->block[4], width >> 1, ncoeffs[4], |
| mblock->bitmapcol[4], mblock->bitmaprow[4]); |
| |
| } |
| else |
| { |
| ncoeffs[4] = 0; |
| } |
| #ifdef PV_POSTPROC_ON |
| if (video->postFilterType != PV_NO_POST_PROC) |
| *pp_mod[4] = (uint8)((ncoeffs[4] > 3) ? 4 : 0); |
| #endif |
| (*DC)[5] = mid_gray; |
| if (CBP & 1) |
| { |
| ncoeffs[5] = VlcDequantH263InterBlock(video, 5, |
| mblock->bitmapcol[5], &mblock->bitmaprow[5]); |
| if (VLC_ERROR_DETECTED(ncoeffs[5])) |
| return PV_FAIL; |
| |
| BlockIDCT(video->currVop->vChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 264, mblock->block[5], width >> 1, ncoeffs[5], |
| mblock->bitmapcol[5], mblock->bitmaprow[5]); |
| |
| } |
| else |
| { |
| ncoeffs[5] = 0; |
| } |
| #ifdef PV_POSTPROC_ON |
| if (video->postFilterType != PV_NO_POST_PROC) |
| *pp_mod[5] = (uint8)((ncoeffs[5] > 3) ? 4 : 0); |
| #endif |
| |
| |
| |
| |
| /* Motion compensation and put it to video->mblock->pred_block */ |
| } |
| return PV_SUCCESS; |
| } |
