/*! * \param *dc The current DecodingContext. * \param mb_type The macroblock prediction type. * \param *sub_mb_type The sub macroblock prediction type. * * Find the sub macroblock prediction type (intra prediction mode or motion vectors exctraction). */ static void sub_mb_pred(DecodingContext_t *dc, const unsigned int mb_type, unsigned int *sub_mb_type) { TRACE_INFO(MB, " > " BLD_GREEN "sub_mb_pred()\n" CLR_RESET); // Shortcut Macroblock_t *mb = dc->mb_array[dc->CurrMbAddr]; slice_t *slice = dc->active_slice; // Read sub_mb_type int mbPartIdx = 0; for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) { if (dc->entropy_coding_mode_flag) sub_mb_type[mbPartIdx] = read_ae(dc, SE_sub_mb_type); else sub_mb_type[mbPartIdx] = read_ue(dc->bitstr); } // ref_idx_l0 for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) { if ((slice->num_ref_idx_l0_active_minus1 > 0 || slice->mb_field_decoding_flag != slice->field_pic_flag) && mb_type != P_8x8ref0 && sub_mb_type[mbPartIdx] != B_Direct_8x8 && SubMbPredMode(slice->slice_type, sub_mb_type[mbPartIdx]) != Pred_L1) { if (dc->entropy_coding_mode_flag) mb->ref_idx_l0[mbPartIdx] = read_ae(dc, SE_ref_idx_lx); else mb->ref_idx_l0[mbPartIdx] = read_te(dc->bitstr, 0); } } // ref_idx_l1 for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) { if ((slice->num_ref_idx_l1_active_minus1 > 0 || slice->mb_field_decoding_flag != slice->field_pic_flag) && sub_mb_type[mbPartIdx] != B_Direct_8x8 && SubMbPredMode(slice->slice_type, sub_mb_type[mbPartIdx]) != Pred_L0) { if (dc->entropy_coding_mode_flag) mb->ref_idx_l1[mbPartIdx] = read_ae(dc, SE_ref_idx_lx); else mb->ref_idx_l1[mbPartIdx] = read_te(dc->bitstr, 0); } } // mvd_l0 for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) { if (sub_mb_type[mbPartIdx] != B_Direct_8x8 && SubMbPredMode(slice->slice_type, sub_mb_type[mbPartIdx]) != Pred_L1) { int subMbPartIdx = 0; for (subMbPartIdx = 0; subMbPartIdx < NumSubMbPart(slice->slice_type, sub_mb_type[mbPartIdx]); subMbPartIdx++) { if (dc->entropy_coding_mode_flag) { mb->mvd_l0[mbPartIdx][subMbPartIdx][0] = read_ae(dc, SE_mvd_lx0); mb->mvd_l0[mbPartIdx][subMbPartIdx][1] = read_ae(dc, SE_mvd_lx1); } else { mb->mvd_l0[mbPartIdx][subMbPartIdx][0] = read_se(dc->bitstr); mb->mvd_l0[mbPartIdx][subMbPartIdx][1] = read_se(dc->bitstr); } } } } // mvd_l1 for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) { if (sub_mb_type[mbPartIdx] != B_Direct_8x8 && SubMbPredMode(slice->slice_type, sub_mb_type[mbPartIdx]) != Pred_L0) { int subMbPartIdx = 0; for (subMbPartIdx = 0; subMbPartIdx < NumSubMbPart(slice->slice_type, sub_mb_type[mbPartIdx]); subMbPartIdx++) { if (dc->entropy_coding_mode_flag) { mb->mvd_l1[mbPartIdx][subMbPartIdx][0] = read_ae(dc, SE_mvd_lx0); mb->mvd_l1[mbPartIdx][subMbPartIdx][1] = read_ae(dc, SE_mvd_lx1); } else { mb->mvd_l1[mbPartIdx][subMbPartIdx][0] = read_se(dc->bitstr); mb->mvd_l1[mbPartIdx][subMbPartIdx][1] = read_se(dc->bitstr); } } } } }
/*! * \param *dc The current DecodingContext. * \param mbAddr The current macroblock address. * \return 0 if macroblock decoding fail, 1 otherwise. * * This function extract one macroblock from the bitstream, handle intra/inter * prediction for its blocks. */ int macroblock_layer(DecodingContext_t *dc, const int mbAddr) { TRACE_INFO(MB, "<> " BLD_GREEN "macroblock_layer(" CLR_RESET "%i" BLD_GREEN ")\n" CLR_RESET, mbAddr); int retcode = FAILURE; // Macroblock allocation //////////////////////////////////////////////////////////////////////////// dc->mb_array[mbAddr] = (Macroblock_t*)calloc(1, sizeof(Macroblock_t)); if (dc->mb_array[mbAddr] == NULL) { TRACE_ERROR(MB, "Unable to alloc new macroblock!\n"); } else { // Set macroblock address dc->mb_array[mbAddr]->mbAddr = mbAddr; // Shortcuts pps_t *pps = dc->pps_array[dc->active_slice->pic_parameter_set_id]; sps_t *sps = dc->sps_array[pps->seq_parameter_set_id]; slice_t *slice = dc->active_slice; Macroblock_t *mb = dc->mb_array[mbAddr]; // Macroblock decoding //////////////////////////////////////////////////////////////////////// #if ENABLE_DEBUG mb->mbFileAddrStart = bitstream_get_absolute_bit_offset(dc->bitstr); #endif // ENABLE_DEBUG deriv_macroblockneighbours_availability(dc, mbAddr); MbPosition(mb, sps); if (pps->entropy_coding_mode_flag) mb->mb_type = read_ae(dc, SE_mb_type); else mb->mb_type = read_ue(dc->bitstr); mb->MbPartPredMode[0] = MbPartPredMode(mb, slice->slice_type, 0); mb->NumMbPart = NumMbPart(slice->slice_type, mb->mb_type); if (mb->mb_type == I_PCM) { #if ENABLE_IPCM TRACE_3(MB, "---- macroblock_layer - I PCM macroblock\n"); while (bitstream_check_alignment(dc->bitstr) == false) { if (read_bit(dc->bitstr) != 0) // pcm_alignment_zero_bit { TRACE_ERROR(MB, " Error while reading pcm_alignment_zero_bit: must be 0!\n"); return FAILURE; } } // CABAC initialization process //FIXME needed? See 'ITU-T H.264' recommendation 9.3.1.2 initCabacDecodingEngine(dc); int i = 0; for (i = 0; i < 256; i++) { mb->pcm_sample_luma[i] = (uint8_t)read_bits(dc->bitstr, sps->BitDepthY); } // CABAC initialization process //FIXME needed? See 'ITU-T H.264' recommendation 9.3.1.2 initCabacDecodingEngine(dc); for (i = 0; i < 2 * sps->MbWidthC * sps->MbHeightC; i++) { mb->pcm_sample_chroma[i] = (uint8_t)read_bits(dc->bitstr, sps->BitDepthC); } // CABAC initialization process //FIXME needed? See 'ITU-T H.264' recommendation 9.3.1.2 initCabacDecodingEngine(dc); #else // ENABLE_IPCM TRACE_ERROR(MB, "I_PCM decoding is currently disabled!\n"); return UNSUPPORTED; #endif // ENABLE_IPCM } else { #if ENABLE_INTER_PRED bool noSubMbPartSizeLessThan8x8Flag = true; if (mb->mb_type != I_NxN && mb->MbPartPredMode[0] != Intra_16x16 && mb->NumMbPart == 4) { TRACE_3(MB, "---- macroblock_layer - mb partition & related\n"); int mbPartIdx = 0; for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) { if (mb->sub_mb_type[mbPartIdx] != B_Direct_8x8) { if (NumSubMbPart(slice->slice_type, mb->sub_mb_type[mbPartIdx]) > 1) { noSubMbPartSizeLessThan8x8Flag = false; } } else if (sps->direct_8x8_inference_flag == false) { noSubMbPartSizeLessThan8x8Flag = false; } } // Read sub macroblock prediction mode sub_mb_pred(dc, mb->mb_type, mb->sub_mb_type); } else #endif // ENABLE_INTER_PRED { TRACE_3(MB, "---- macroblock_layer - transform_size_8x8_flag & prediction modes\n"); if (pps->transform_8x8_mode_flag == true && mb->mb_type == I_NxN) { if (pps->entropy_coding_mode_flag) mb->transform_size_8x8_flag = read_ae(dc, SE_transform_size_8x8_flag); else mb->transform_size_8x8_flag = read_bit(dc->bitstr); // Need to update MbPartPredMode in order to detect I_8x8 prediction mode mb->MbPartPredMode[0] = MbPartPredMode(mb, slice->slice_type, 0); } // Read macroblock prediction mode mb_pred(dc, mb); } if (mb->MbPartPredMode[0] != Intra_16x16) { TRACE_3(MB, "---- macroblock_layer - coded block pattern & transform_size_8x8_flag\n"); if (pps->entropy_coding_mode_flag) mb->coded_block_pattern = read_ae(dc, SE_coded_block_pattern); else mb->coded_block_pattern = read_me(dc->bitstr, sps->ChromaArrayType, dc->IdrPicFlag); mb->CodedBlockPatternLuma = mb->coded_block_pattern % 16; mb->CodedBlockPatternChroma = mb->coded_block_pattern / 16; #if ENABLE_INTER_PRED if (mb->CodedBlockPatternLuma > 0 && pps->transform_8x8_mode_flag == true && mb->mb_type != I_NxN && noSubMbPartSizeLessThan8x8Flag == true && (mb->mb_type != B_Direct_16x16 || sps->direct_8x8_inference_flag == true)) { if (pps->entropy_coding_mode_flag) mb->transform_size_8x8_flag = read_ae(dc, SE_transform_size_8x8_flag); else mb->transform_size_8x8_flag = read_bit(dc->bitstr); // Need to update MbPartPredMode in order to account for I_8x8 prediction mode if (transform_size_8x8_flag) mb->MbPartPredMode[0] = MbPartPredMode(mb, slice->slice_type, 0); } #endif // ENABLE_INTER_PRED } if (mb->CodedBlockPatternLuma > 0 || mb->CodedBlockPatternChroma > 0 || mb->MbPartPredMode[0] == Intra_16x16) { TRACE_3(MB, "---- macroblock_layer - quantization parameter & residual datas\n"); // Read QP delta if (pps->entropy_coding_mode_flag) mb->mb_qp_delta = read_ae(dc, SE_mb_qp_delta); else mb->mb_qp_delta = read_se(dc->bitstr); // Parse the residual coefficients //////////////////////////////////////////////////////////////// // Luma levels residual_luma(dc, 0, 15); // Chroma levels residual_chroma(dc, 0, 15); } else { TRACE_3(MB, "---- macroblock_layer - No residual datas to decode in this macroblock\n"); } // Compute luma Quantization Parameters if (mb->mb_qp_delta) mb->QPY = ((slice->QPYprev + mb->mb_qp_delta + 52 + sps->QpBdOffsetY*2) % (52 + sps->QpBdOffsetY)) - sps->QpBdOffsetY; else mb->QPY = slice->QPYprev; mb->QPprimeY = mb->QPY + sps->QpBdOffsetY; slice->QPYprev = mb->QPY; // Set Transform Bypass Mode if (sps->qpprime_y_zero_transform_bypass_flag == true && mb->QPprimeY == 0) mb->TransformBypassModeFlag = true; // Prediction process (include quantization and transformation stages) //////////////////////////////////////////////////////////////// if (dc->IdrPicFlag) { retcode = intra_prediction_process(dc, mb); } else { retcode = inter_prediction_process(dc, mb); } // Print macroblock(s) header and block data ? //////////////////////////////////////////////////////////////// #if ENABLE_DEBUG mb->mbFileAddrStop = bitstream_get_absolute_bit_offset(dc->bitstr) - 1; int frame_debug_range[2] = {-1, -1}; // Range of (idr) frame(s) to debug/analyse int mb_debug_range[2] = {-1, -1}; // Range of macroblock(s) to debug/analyse if (dc->idrCounter >= frame_debug_range[0] && dc->idrCounter <= frame_debug_range[1]) { if (mb->mbAddr >= mb_debug_range[0] && mb->mbAddr <= mb_debug_range[1]) { print_macroblock_layer(dc, mb); print_macroblock_pixel_residual(mb); print_macroblock_pixel_predicted(mb); print_macroblock_pixel_final(mb); } } #endif // ENABLE_DEBUG } TRACE_3(MB, "---- macroblock_layer - the end\n\n"); } return retcode; }
void RBSP_decode(NALunit nal_unit) { static int nalBrojac=0; static int idr_frame_number=0; printf("Entering RBPS_decode #%d\n",nalBrojac++); initRawReader(nal_unit.rbsp_byte, nal_unit.NumBytesInRBSP); //TYPE 7 = Sequence parameter set TODO: Provjera postoji li veæ SPS //READ SPS if (nal_unit.nal_unit_type==NAL_UNIT_TYPE_SEI) { printf("RBSP_decode -> Not supported NAL unit type: SEI (type 6)\n"); } else if (nal_unit.nal_unit_type==NAL_UNIT_TYPE_SPS) { fill_sps(&nal_unit); init_h264_structures(); AllocateMemory(); } //TYPE 8 = Picture parameter set TODO: Provjera postoji li veæ PPS i SPS else if (nal_unit.nal_unit_type==NAL_UNIT_TYPE_PPS) { fill_pps(&nal_unit); } //IDR or NOT IDR slice data //////////////////////////////////////////////////////////////////// //Actual picture decoding takes place here //The main loop works macroblock by macroblock until the end of the slice //Macroblock skipping is implemented else if ((nal_unit.nal_unit_type==NAL_UNIT_TYPE_IDR) || (nal_unit.nal_unit_type==NAL_UNIT_TYPE_NOT_IDR)) { frameCount++; //Read slice header fill_shd(&nal_unit); printf("Working on frame #%d...\n", frameCount); int MbCount=shd.PicSizeInMbs; //Norm: firstMbAddr=first_mb_in_slice * ( 1 + MbaffFrameFlag ); int firstMbAddr = 0; CurrMbAddr = firstMbAddr; //Norm: moreDataFlag = 1 bool moreDataFlag = true; //Norm: prevMbSkipped = 0 int prevMbSkipped = 0; //Used later on int mb_skip_run; // Prediction samples formed by either intra or inter prediction. int predL[16][16], predCb[8][8], predCr[8][8]; QPy = shd.SliceQPy; while (moreDataFlag && CurrMbAddr<MbCount) { /*for (int i = 0; i < 4; i++) ChromaDCLevel[0][i] = ChromaDCLevel[1][i] = 0; for (int i = 0; i < 16; i++) LumaDCLevel[i] = 0;*/ if ((shd.slice_type%5)!=I_SLICE && (shd.slice_type%5)!=SI_SLICE) { //First decode various data at the beggining of each slice/frame //Norm: if( !entropy_coding_mode_flag ) ... this "if clause" is skipped. mb_skip_run=expGolomb_UD(); prevMbSkipped = (mb_skip_run > 0); for(int i=0; i<mb_skip_run; i++ ) { if (CurrMbAddr >= MbCount) { break; } mb_type = P_Skip; mb_type_array[CurrMbAddr]=P_Skip; // Inter prediction: DeriveMVs(); Decode(predL, predCr, predCb); // Norm: QpBdOffsetY == 0 in baseline QPy = (QPy + mb_qp_delta + 52) % 52; // Inverse transformation and decoded sample construction: transformDecodingP_Skip(predL, predCb, predCr, QPy); //Norm: CurrMbAddr = NextMbAddress( CurrMbAddr ) CurrMbAddr++; } if ((CurrMbAddr != firstMbAddr) || (mb_skip_run > 0)) { moreDataFlag = more_rbsp_data(); } } if(moreDataFlag) { // Norm: start macroblock_layer() mb_pos_array[CurrMbAddr]=(RBSP_current_bit+1)&7; mb_type = expGolomb_UD(); mb_type_array[CurrMbAddr]=mb_type; if ((mb_type > 31) || ((shd.slice_type == I_SLICE) && (mb_type > 24))) { printf("Fatal error: Unexpected mb_type value (%d)\n", mb_type); printf("Slice type: %d\n", shd.slice_type); printf("Frame #%d, CurrMbAddr = %d\n", frameCount, CurrMbAddr); system("pause"); writeToPPM("errorFrame"); // dump the current frame exit(1); } //Norm: if( mb_type != I_NxN && MbPartPredMode( mb_type, 0 ) != Intra_16x16 && NumMbPart( mb_type ) == 4 ) // I_NxN is an alias for Intra_4x4 and Intra_8x8 MbPartPredMode (mb_type in both cases equal to 0) // mb_type (positive integer value) is equal to "Name of mb_type" (i.e. I_NxN). These are often interchanged in the norm // Everything as described in norm page 119. table 7-11. //Specific inter prediction? // Norm: if (mb_type != I_NxN && MbPartPredMode(mb_type,0) != Intra_16x16 && NumMbPart(mb_type) == 4) if(MbPartPredMode(mb_type,0) != Intra_4x4 && MbPartPredMode( mb_type, 0 )!=Intra_16x16 && NumMbPart( mb_type )==4 ) { // Norm: start sub_mb_pred(mb_type) int mbPartIdx; for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) { sub_mb_type[mbPartIdx]=expGolomb_UD(); } for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) { if ((shd.num_ref_idx_active_override_flag > 0) && (mb_type != P_8x8ref0) && (SubMbPredMode(sub_mb_type[mbPartIdx]) != Pred_L1)) { ref_idx_l0_array[CurrMbAddr][mbPartIdx] = expGolomb_TD(); } } // Norm: there are no B-frames in baseline, so the stream // does not contain ref_idx_l1 or mvd_l1 for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) { for (int subMbPartIdx = 0; subMbPartIdx < NumSubMbPart(sub_mb_type[mbPartIdx]); subMbPartIdx++) { mvd_l0[mbPartIdx][subMbPartIdx][0] = expGolomb_SD(); mvd_l0[mbPartIdx][subMbPartIdx][1] = expGolomb_SD(); } } // Norm: end sub_mb_pred(mb_type) } else { //Norm: This is section "mb_pred( mb_type )" if(MbPartPredMode(mb_type, 0) == Intra_4x4 /*|| MbPartPredMode(mb_type, 0) == Intra_8x8*/ || MbPartPredMode(mb_type, 0) == Intra_16x16 ) { if(MbPartPredMode(mb_type, 0) == Intra_4x4) { for(int luma4x4BlkIdx=0; luma4x4BlkIdx<16; luma4x4BlkIdx++) { prev_intra4x4_pred_mode_flag[luma4x4BlkIdx] = (bool)getRawBit(); if(prev_intra4x4_pred_mode_flag[luma4x4BlkIdx]==false) { rem_intra4x4_pred_mode[luma4x4BlkIdx]=getRawBits(3); } } } //Norm: //if( MbPartPredMode( mb_type, 0 ) = = Intra_8x8 ) //This if clause has been skipped, because "intra_8x8" is not supported in baseline. //Norm: //if( ChromaArrayType == 1 || ChromaArrayType == 2 ) //baseline defines "ChromaArrayType==1", so the if clause is skipped intra_chroma_pred_mode=expGolomb_UD(); if (intra_chroma_pred_mode > 3) { printf("Fatal error: Unexpected intra_chroma_pred_mode value (%d)\n", intra_chroma_pred_mode); printf("Frame #%d, CurrMbAddr = %d\n", frameCount, CurrMbAddr); system("pause"); writeToPPM("errorFrame"); // dump the current frame exit(1); } } else { int mbPartIdx; for (mbPartIdx = 0; mbPartIdx < NumMbPart(mb_type); mbPartIdx++) { if ((shd.num_ref_idx_l0_active_minus1 > 0) && (MbPartPredMode(mb_type, mbPartIdx) != Pred_L1)) { ref_idx_l0_array[CurrMbAddr][mbPartIdx] = expGolomb_TD(); } } // Norm: there are no B-frames in baseline, so the stream // does not contain ref_idx_l1 or mvd_l1 for (mbPartIdx = 0; mbPartIdx < NumMbPart(mb_type); ++mbPartIdx) { if (MbPartPredMode(mb_type, mbPartIdx) != Pred_L1) { mvd_l0[mbPartIdx][0][0] = expGolomb_SD(); mvd_l0[mbPartIdx][0][1] = expGolomb_SD(); } } } // Norm: end mb_pred(mb_type) } //If the next if clause does not execute, this is the final value of coded block patterns for this macroblock CodedBlockPatternLuma=-1; CodedBlockPatternChroma=-1; if(MbPartPredMode(mb_type,0)!=Intra_16x16) { int coded_block_pattern=expGolomb_UD(); if (coded_block_pattern > 47) { printf("Fatal error: Unexpected coded_block_pattern value (%d)\n", coded_block_pattern); printf("Frame #%d, CurrMbAddr = %d\n", frameCount, CurrMbAddr); system("pause"); writeToPPM("errorFrame"); // dump the current frame exit(1); } //This is not real coded_block_pattern, it's the coded "codeNum" value which is now being decoded: if(MbPartPredMode(mb_type,0)==Intra_4x4 /*|| MbPartPredMode(mb_type,0)==Intra_8x8*/ ) { coded_block_pattern=codeNum_to_coded_block_pattern_intra[coded_block_pattern]; } //Inter prediction else { coded_block_pattern=codeNum_to_coded_block_pattern_inter[coded_block_pattern]; } CodedBlockPatternLuma=coded_block_pattern & 15; CodedBlockPatternChroma=coded_block_pattern >> 4; //Norm: /* if( CodedBlockPatternLuma > 0 && transform_8x8_mode_flag && mb_type != I_NxN && noSubMbPartSizeLessThan8x8Flag && ( mb_type != B_Direct_16x16 || direct_8x8_inference_flag)) */ //This if clause is not implemented since transform_8x8_mode_flag is not supported } //DOES NOT EXIST IN THE NORM! else { if (shd.slice_type % 5 == I_SLICE) { CodedBlockPatternChroma=I_Macroblock_Modes[mb_type][5]; CodedBlockPatternLuma=I_Macroblock_Modes[mb_type][6]; } else { CodedBlockPatternChroma=P_and_SP_macroblock_modes[mb_type][5]; CodedBlockPatternLuma=P_and_SP_macroblock_modes[mb_type][6]; } } CodedBlockPatternLumaArray[CurrMbAddr] = CodedBlockPatternLuma; CodedBlockPatternChromaArray[CurrMbAddr] = CodedBlockPatternChroma; if(CodedBlockPatternLuma>0 || CodedBlockPatternChroma>0 || MbPartPredMode(mb_type,0)==Intra_16x16) { mb_qp_delta=expGolomb_SD(); if ((mb_qp_delta < -26) || (mb_qp_delta > 25)) { printf("Fatal error: Unexpected mb_qp_delta value (%d)\n", mb_qp_delta); printf("Frame #%d, CurrMbAddr = %d\n", frameCount, CurrMbAddr); system("pause"); writeToPPM("errorFrame"); // dump the current frame exit(1); } //Norm: decode residual data. //residual_block_cavlc( coeffLevel, startIdx, endIdx, maxNumCoeff ) residual(0, 15); } else { clear_residual_structures(); } // Norm: end macroblock_layer() //Data ready for rendering // Norm: QpBdOffsetY == 0 in baseline QPy = (QPy + mb_qp_delta + 52) % 52; if ((MbPartPredMode(mb_type , 0) == Intra_4x4) || (MbPartPredMode(mb_type , 0) == Intra_16x16)) { intraPrediction(predL, predCr, predCb); } else { DeriveMVs(); Decode(predL, predCr, predCb); } if (MbPartPredMode(mb_type, 0) == Intra_16x16) { transformDecodingIntra_16x16Luma(Intra16x16DCLevel, Intra16x16ACLevel, predL, QPy); } else if (MbPartPredMode(mb_type, 0) != Intra_4x4) // Intra { for(int luma4x4BlkIdx = 0; luma4x4BlkIdx < 16; luma4x4BlkIdx++) { transformDecoding4x4LumaResidual(LumaLevel, predL, luma4x4BlkIdx, QPy); } } transformDecodingChroma(ChromaDCLevel[0], ChromaACLevel[0], predCb, QPy, true); transformDecodingChroma(ChromaDCLevel[1], ChromaACLevel[1], predCr, QPy, false); moreDataFlag=more_rbsp_data(); ++CurrMbAddr; }