// Main code function void PredModeCodec::DoWorkCode( MvData& in_data ) { int step,max; int split_depth; for (m_sb_yp = 0, m_sb_tlb_y = 0; m_sb_yp < in_data.SBSplit().LengthY(); ++m_sb_yp, m_sb_tlb_y += 4) { for (m_sb_xp = 0,m_sb_tlb_x = 0; m_sb_xp < in_data.SBSplit().LengthX(); ++m_sb_xp,m_sb_tlb_x += 4) { split_depth = in_data.SBSplit()[m_sb_yp][m_sb_xp]; step = 4 >> (split_depth); max = (1 << split_depth); //now do all the block modes and mvs in the mb for (m_b_yp = m_sb_tlb_y; m_b_yp < m_sb_tlb_y+4; m_b_yp += step) { for (m_b_xp = m_sb_tlb_x; m_b_xp < m_sb_tlb_x+4; m_b_xp += step) { CodeVal(in_data); }//m_b_xp }//m_b_yp }//m_sb_xp }//m_sb_yp }
void SplitModeCodec::CodeVal(const MvData& in_data) { int val = in_data.SBSplit()[m_sb_yp][m_sb_xp] - Prediction( in_data.SBSplit() ); if (val < 0) val+=3; //produce prediction mod 3 EncodeUInt(val, SB_SPLIT_BIN1_CTX, SB_SPLIT_BIN2_CTX); }
// Main code function void SplitModeCodec::DoWorkCode( MvData& in_data ) { for (m_sb_yp = 0; m_sb_yp < in_data.SBSplit().LengthY(); ++m_sb_yp) { for (m_sb_xp = 0; m_sb_xp < in_data.SBSplit().LengthX(); ++m_sb_xp) { CodeVal(in_data); }//m_sb_xp }//m_sb_yp }
// Main decode function void SplitModeCodec::DoWorkDecode( MvData& out_data) { for (m_sb_yp = 0; m_sb_yp < out_data.SBSplit().LengthY(); ++m_sb_yp) { for (m_sb_xp = 0; m_sb_xp < out_data.SBSplit().LengthX(); ++m_sb_xp) { DecodeVal( out_data ); }//m_sb_xp }//m_sb_yp }
// Main decode function void PredModeCodec::DoWorkDecode( MvData& out_data) { int step,max; int split_depth; int xstart,ystart; // Then the prediction mode for (m_sb_yp = 0,m_sb_tlb_y = 0; m_sb_yp < out_data.SBSplit().LengthY(); ++m_sb_yp,m_sb_tlb_y += 4) { for (m_sb_xp = 0,m_sb_tlb_x = 0; m_sb_xp < out_data.SBSplit().LengthX(); ++m_sb_xp,m_sb_tlb_x += 4) { split_depth = out_data.SBSplit()[m_sb_yp][m_sb_xp]; step = 4 >> (split_depth); max = (1 << split_depth); //now do all the block mvs in the mb for (int j = 0; j < max; ++j) { for (int i = 0; i < max; ++i) { xstart = m_b_xp = m_sb_tlb_x + i * step; ystart = m_b_yp = m_sb_tlb_y + j * step; DecodeVal(out_data); // propagate throughout SB for (m_b_yp = ystart; m_b_yp < ystart+step; m_b_yp++) { for (m_b_xp = xstart; m_b_xp < xstart+step; m_b_xp++) { out_data.Mode()[m_b_yp][m_b_xp] = out_data.Mode()[ystart][xstart]; }//m_b_xp }//m_b_yp }//i }//j }//m_sb_xp }//m_sb_yp }
void MotionCompensator::CompensateComponent( Picture* pic , Picture* refsptr[2] , const MvData& mv_data , const CompSort cs ) { // Set up references to pictures and references PicArray& pic_data_out = pic->Data( cs ); // Size of picture component being motion compensated const PicArray& ref1up = refsptr[0]->UpData( cs ); const PicArray& ref2up = refsptr[1]->UpData( cs ); // Set up a row of blocks which will contain the MC data, which // we'll add or subtract to pic_data_out TwoDArray<ValueType> pic_data(m_bparams.Yblen(), pic_data_out.LengthX(), 0 ); // Factors to compensate for subsampling of chroma int xscale_shift = 0; int yscale_shift = 0; if ( cs != Y_COMP ) { if (m_cformat == format420) { xscale_shift = 1; yscale_shift = 1; } else if (m_cformat == format422) { xscale_shift = 1; yscale_shift = 0; } } ImageCoords pic_size(pic->GetPparams().Xl(), pic->GetPparams().Yl()); if ( cs != Y_COMP ) { pic_size.x = pic->GetPparams().ChromaXl(); pic_size.y = pic->GetPparams().ChromaYl(); } // Reference to the relevant DC array const TwoDArray<ValueType>& dcarray = mv_data.DC( cs ); // Set up references to the vectors const int num_refs = pic->GetPparams().Refs().size(); const MvArray* mv_array1; const MvArray* mv_array2; mv_array1 = &mv_data.Vectors(1); if (num_refs ==2 ) mv_array2 = &mv_data.Vectors(2); else mv_array2 = &mv_data.Vectors(1); ReConfig();//set all the weighting blocks up //Blocks are listed left to right, line by line. MVector mv1,mv2; PredMode block_mode; //Coords of the top-left corner of a block ImageCoords pos; //Loop for each block in the output image. //The CompensateBlock function will use the image pointed to by ref1up //and add the compensated pixels to the image pointed to by pic_data. size_t wgt_idx; int save_from_row = m_bparams.Ybsep()-m_bparams.Yoffset(); // unpadded picture dimensions const int x_end_data = pic_data_out.FirstX() + std::min(pic_data_out.LengthX(), pic_size.x ); const int y_end_data = pic_data_out.FirstY() + std::min(pic_data_out.LengthY(), pic_size.y ); const int blocks_per_mb_row = m_predparams.XNumBlocks()/m_predparams.XNumSB(); const int blocks_per_sb_row = blocks_per_mb_row>>1; // The picture does not contain integral number of blocks. So not all // blocks need to be processed. Compute the relevant blocks to be // processed int y_num_blocks = std::min((NUM_USED_BLKS(pic_size.y,m_bparams.Ybsep(),m_bparams.Yblen())), m_predparams.YNumBlocks()); int x_num_blocks = std::min((NUM_USED_BLKS(pic_size.x,m_bparams.Xbsep(),m_bparams.Xblen())), m_predparams.XNumBlocks()); //Loop over all the block rows pos.y = -m_bparams.Yoffset(); for(int yblock = 0; yblock < y_num_blocks; ++yblock) { pos.x = -m_bparams.Xoffset(); int xincr, xb_incr = 0; //loop over all the blocks in a row for(int xblock = 0 ; xblock < x_num_blocks; xblock+=xb_incr) { int split_mode = mv_data.SBSplit()[yblock/blocks_per_mb_row][xblock/blocks_per_mb_row]; int blk_x, blk_y = 1; switch (split_mode) { case 0: // processing superblock blk_x = blocks_per_mb_row; break; case 1: // processing sub-superblock blk_x = blocks_per_sb_row; break; case 2: // processing block default: blk_x = 1; break; } //Decide which weights to use. if (pos.x >=0 && (xblock+blk_x) < x_num_blocks) { // block is entirely within picture in x direction if (pos.y < 0) wgt_idx = 1; else if ((yblock+blk_y) < y_num_blocks) wgt_idx = 4; else wgt_idx = 7; } else if (pos.x < 0) { // left edge of block is outside picture in x direction if (pos.y < 0) wgt_idx = 0; else if ((yblock+blk_y) < y_num_blocks) wgt_idx = 3; else wgt_idx = 6; } else { // right edge of block is outside picture in x direction if (pos.y < 0) wgt_idx = 2; else if ((yblock+blk_y) < y_num_blocks) wgt_idx = 5; else wgt_idx = 8; } block_mode = mv_data.Mode()[yblock][xblock]; TwoDArray<ValueType> *wt; if (split_mode == 0) //Block part of a MacroBlock { wt = &m_macro_block_weights[wgt_idx]; xb_incr = blocks_per_mb_row; } else if (split_mode == 1) //Block part of a SubBlock { wt = &m_sub_block_weights[wgt_idx]; xb_incr = blocks_per_sb_row; } else { wt = &m_block_weights[wgt_idx]; xb_incr = 1; } xincr = m_bparams.Xbsep() * xb_incr; mv1 = (*mv_array1)[yblock][xblock]; mv1.x >>= xscale_shift; mv1.y >>= yscale_shift; mv2 = (*mv_array2)[yblock][xblock]; mv2.x >>= xscale_shift; mv2.y >>= yscale_shift; CompensateBlock(pic_data, pos, pic_size, block_mode, dcarray[yblock][xblock], ref1up, mv1, ref2up, mv2, *wt); //Increment the block horizontal position pos.x += xincr; }//xblock // Update the pic data // Use only the first Ybsep rows since the remaining rows are // needed for the next row of blocks since we are using overlapped // blocks motion compensation if (m_add_or_sub == SUBTRACT) { int start_y = std::max(pic_data_out.FirstY() , pos.y) ; int end_y = std::min (pic_data_out.FirstY() + pos.y + m_bparams.Ybsep() , y_end_data); if (yblock == y_num_blocks - 1) { end_y = pic_data_out.LengthY(); if (end_y > y_end_data) end_y = y_end_data; } for ( int i = start_y, pos_y = 0; i < end_y; i++, pos_y++) { ValueType *pic_row = pic_data[pos_y]; ValueType *out_row = pic_data_out[i]; for ( int j =pic_data_out.FirstX(); j < x_end_data; ++j) { out_row[j] -= static_cast<ValueType>( (pic_row[j] + 32) >> 6 ); } // Okay, we've done all the actual blocks. Now if the picture is further padded // we need to set the padded values to zero beyond the last block in the row, // for all the picture lines in the block row. Need only do this when we're // subtracting. for (int j=pic_size.x; j<pic_data_out.LengthX() ; ++j ) { out_row[pic_data_out.FirstX()+j] = 0; } } } else // (m_add_or_sub == ADD) {
void SplitModeCodec::DecodeVal(MvData& out_data) { out_data.SBSplit()[m_sb_yp][m_sb_xp] = (DecodeUInt(SB_SPLIT_BIN1_CTX, SB_SPLIT_BIN2_CTX) + Prediction(out_data.SBSplit())) % 3; }