slice.c

JM 11.0 KTA 2.1 Source Code

        img->top_field = 0;

      //Rate control
      img->bot_MB = 0;// for Rate control

      // go back to the Top MB in the MB pair
      start_macroblock (CurrentMbAddr, img->field_mode);

      rdopt =  img->field_mode ? &rddata_top_field_mb : &rddata_top_frame_mb;
      copy_rdopt_data (0);  // copy the MB data for Top MB from the temp buffers

#ifdef ADAPTIVE_FD_SD_CODING
      write_one_macroblock (1);     // write the Top MB data to the bitstream
      currMB    = &img->mb_data[CurrentMbAddr];
      if (currMB->written_SD_Coding_on_off==0)
      {
        currMB->SD_Coding_on_off=0;
      }
#else
      write_one_macroblock (1);     // write the Top MB data to the bitstream
#endif

      terminate_macroblock (&end_of_slice, &recode_macroblock);     // done coding the Top MB 

      if (recode_macroblock == FALSE)       // The final processing of the macroblock has been done
      {
        CurrentMbAddr = FmoGetNextMBNr (CurrentMbAddr);
        if (CurrentMbAddr == -1)   // end of slice
        {
          end_of_slice = TRUE;
        }
        NumberOfCodedMBs++;       // only here we are sure that the coded MB is actually included in the slice
        proceed2nextMacroblock ();


        //Rate control
        img->bot_MB = 1;//for Rate control
        // go to the Bottom MB in the MB pair
        img->top_field = 0;
        start_macroblock (CurrentMbAddr, img->field_mode);

        rdopt = img->field_mode ? &rddata_bot_field_mb : &rddata_bot_frame_mb;
        copy_rdopt_data (1);  // copy the MB data for Bottom MB from the temp buffers

#ifdef ADAPTIVE_FD_SD_CODING
        write_one_macroblock (0);     // write the Bottom MB data to the bitstream
        currMB    = &img->mb_data[CurrentMbAddr];
        if (currMB->written_SD_Coding_on_off==0)
        {
          currMB->SD_Coding_on_off=0;
        }
#else
        write_one_macroblock (0);     // write the Bottom MB data to the bitstream
#endif

        terminate_macroblock (&end_of_slice, &recode_macroblock);     // done coding the Top MB 
        if (recode_macroblock == FALSE)       // The final processing of the macroblock has been done
        {
          CurrentMbAddr = FmoGetNextMBNr (CurrentMbAddr);
          if (CurrentMbAddr == -1)   // end of slice
          {
            end_of_slice = TRUE;
          }
          NumberOfCodedMBs++;       // only here we are sure that the coded MB is actually included in the slice
          proceed2nextMacroblock ();
        }
        else
        {
          //Go back to the beginning of the macroblock pair to recode it
          img->current_mb_nr = FmoGetPreviousMBNr(img->current_mb_nr);
          img->current_mb_nr = FmoGetPreviousMBNr(img->current_mb_nr);
          if(img->current_mb_nr == -1 )   // The first MB of the slice group  is too big,
            // which means it's impossible to encode picture using current slice bits restriction
          {
            snprintf (errortext, ET_SIZE, "Error encoding first MB with specified parameter, bits of current MB may be too big");
            error (errortext, 300);
          }
        }

      }

      else
      {
        //!Go back to the previous MB to recode it
        img->current_mb_nr = FmoGetPreviousMBNr(img->current_mb_nr);
        if(img->current_mb_nr == -1 )   // The first MB of the slice group  is too big,
          // which means it's impossible to encode picture using current slice bits restriction
        {
          snprintf (errortext, ET_SIZE, "Error encoding first MB with specified parameter, bits of current MB may be too big");
          error (errortext, 300);
        }
      }



      if (MBPairIsField)    // if MB Pair was coded as field the buffer size variables back to frame mode
      {
        img->buf_cycle >>= 1;
        input->num_ref_frames >>= 1;
        img->num_ref_idx_l0_active -= 1;
        img->num_ref_idx_l0_active >>= 1;
      }

      img->field_mode = img->top_field = 0; // reset to frame mode

      if (CurrentMbAddr == FmoGetLastCodedMBOfSliceGroup (FmoMB2SliceGroup (CurrentMbAddr)))
        end_of_slice = TRUE;        // just in case it doesn't get set in terminate_macroblock
    }
  }  
  /*
  // Tian Dong: June 7, 2002 JVT-B042
  // Restore the short_used
  if (input->NumFramesInELSubSeq)
  {
  fb->short_used = short_used;
  }
  */
  // separable aif (BEGIN)
#ifdef ADAPTIVE_FILTER      
  if(UseAdaptiveFilterForCurrentFrame() && img->AdaptiveFilterFlag == 0 && input->UseAdaptiveFilter == 2)
  {
    Macroblock*     currMB;
    UnifiedOneForthPixWithNewFilterHor ();
    CurrentMbAddr = FmoGetFirstMacroblockInSlice (SliceGroupId);
    end_of_slice = FALSE;
    while (end_of_slice == FALSE) // loop over macroblocks
    {
      set_MB_parameters (CurrentMbAddr);
      currMB    = &img->mb_data[img->current_mb_nr];
      SetAdaptiveFilterVer();
      terminate_macroblock (&end_of_slice, &recode_macroblock);
      CurrentMbAddr = FmoGetNextMBNr (CurrentMbAddr);
      if (CurrentMbAddr == -1)   // end of slice
      {
        end_of_slice = TRUE;
        FindFilterCoefVer();
      }
      proceed2nextMacroblock ();
    }
  }
  // separable aif (END)
  if (img->AdaptiveFilterFlag == 1)
    SwapUpsampledFrames();

#endif

#ifdef SWITCHED_FILTERS
  if((img->type != I_SLICE) && (input->UseHPFilter == HPF_SIFO))
    SwapFilteredFrames();
#endif  // SWITCHED_FILTERS

  terminate_slice ( (NumberOfCodedMBs+TotalCodedMBs >= (int)img->PicSizeInMbs) );
  return NumberOfCodedMBs;
}

/*!
************************************************************************
* \brief
*    Initializes the parameters for a new slice and
*     allocates the memory for the coded slice in the Picture structure
*  \par Side effects:
*      Adds slice/partition header symbols to the symbol buffer
*      increments Picture->no_slices, allocates memory for the
*      slice, sets img->currSlice
************************************************************************
*/
static void init_slice (int start_mb_addr)
{
  int i;
  Picture *currPic = img->currentPicture;
  DataPartition *dataPart;
  Bitstream *currStream;
  Slice *currSlice;

  img->current_mb_nr = start_mb_addr;

  // Allocate new Slice in the current Picture, and set img->currentSlice
  assert (currPic != NULL);
  currPic->no_slices++;

  if (currPic->no_slices >= MAXSLICEPERPICTURE)
    error ("Too many slices per picture, increase MAXSLICEPERPICTURE in global.h.", -1);
#ifdef ADAPTIVE_FD_SD_CODING
  if (currPic->slices[currPic->no_slices-1]==NULL)
#endif
    currPic->slices[currPic->no_slices-1] = malloc_slice();

  currSlice = currPic->slices[currPic->no_slices-1];

  img->currentSlice = currSlice;

  currSlice->picture_id = img->tr % 256;
  currSlice->qp = img->qp;
  currSlice->start_mb_nr = start_mb_addr;
  currSlice->slice_too_big = dummy_slice_too_big;

  for (i = 0; i < currSlice->max_part_nr; i++)
  {
    dataPart = &(currSlice->partArr[i]);
    if (input->symbol_mode == UVLC)
      dataPart->writeSyntaxElement = writeSyntaxElement_UVLC;
    else
      dataPart->writeSyntaxElement = writeSyntaxElement_CABAC;

    currStream = dataPart->bitstream;
    currStream->bits_to_go = 8;
    currStream->byte_pos = 0;
    currStream->byte_buf = 0;
  }

  img->num_ref_idx_l0_active = active_pps->num_ref_idx_l0_active_minus1 + 1; 
  img->num_ref_idx_l1_active = active_pps->num_ref_idx_l1_active_minus1 + 1;

  // primary and redundant slices: number of references overriding.
  if(input->redundant_pic_flag)
  {
    if(!redundant_coding)
    {
      img->num_ref_idx_l0_active = min(img->number,input->NumRefPrimary);
    }
    else
    {
      // 1 reference picture for redundant slices 
      img->num_ref_idx_l0_active = 1;   
    }
  }

  // code now also considers fields. Issue whether we should account this within the appropriate input params directly
  if ((img->type == P_SLICE || img->type == SP_SLICE) && input->P_List0_refs)
  {
    img->num_ref_idx_l0_active = min(img->num_ref_idx_l0_active, input->P_List0_refs * ((img->structure !=0) + 1));
  }
  if (img->type == B_SLICE )
  {
    if (input->B_List0_refs)
    {
      img->num_ref_idx_l0_active = min(img->num_ref_idx_l0_active, input->B_List0_refs * ((img->structure !=0) + 1));
    }
    if (input->B_List1_refs)
    {
      img->num_ref_idx_l1_active = min(img->num_ref_idx_l1_active, input->B_List1_refs * ((img->structure !=0) + 1));
    }
  }
  // generate reference picture lists
  init_lists(img->type, (PictureStructure)img->structure);

  // assign list 0 size from list size
  img->num_ref_idx_l0_active = listXsize[0];
  img->num_ref_idx_l1_active = listXsize[1];

  //Perform memory management based on poc distances for HierarchicalCoding
  if (img->nal_reference_idc  && input->HierarchicalCoding && input->PocMemoryManagement && dpb.ref_frames_in_buffer==active_sps->num_ref_frames)
  {    
    poc_based_ref_management(img->frame_num);
  }

  if (input->EnableOpenGOP)
  {
    for (i = 0; i<listXsize[0]; i++)
    {    
      if (listX[0][i]->poc < img->last_valid_reference && img->ThisPOC > img->last_valid_reference)      
      {
        listXsize[0] = img->num_ref_idx_l0_active = max(1,i);
        break;
      }
    }

    for (i = 0; i<listXsize[1]; i++)
    {
      if (listX[1][i]->poc < img->last_valid_reference && img->ThisPOC > img->last_valid_reference)
      {
        listXsize[1] = img->num_ref_idx_l1_active = max(1,i);
        break;
      }
    }
  }

  init_ref_pic_list_reordering();

  //Perform reordering based on poc distances for HierarchicalCoding
  //if (img->type==P_SLICE && input->HierarchicalCoding && input->ReferenceReorder)
  if (img->type==P_SLICE && input->ReferenceReorder)
  {

    int i, num_ref;

    alloc_ref_pic_list_reordering_buffer(currSlice);

    if ((img->type != I_SLICE) && (img->type !=SI_SLICE))
    {
      for (i=0; i<img->num_ref_idx_l0_active + 1; i++)
      {
        currSlice->reordering_of_pic_nums_idc_l0[i] = 3;
        currSlice->abs_diff_pic_num_minus1_l0[i] = 0;
        currSlice->long_term_pic_idx_l0[i] = 0;
      }

      if (img->type == B_SLICE)
      {
        for (i=0; i<img->num_ref_idx_l1_active + 1; i++)
        {
          currSlice->reordering_of_pic_nums_idc_l1[i] = 3;
          currSlice->abs_diff_pic_num_minus1_l1[i] = 0;
          currSlice->long_term_pic_idx_l1[i] = 0;
        }
      }
    }

    if ((img->type != I_SLICE) && (img->type !=SI_SLICE))
    {
      num_ref = img->num_ref_idx_l0_active;
      poc_ref_pic_reorder(listX[LIST_0], 
        num_ref, 
        currSlice->reordering_of_pic_nums_idc_l0, 
        currSlice->abs_diff_pic_num_minus1_l0, 
        currSlice->long_term_pic_idx_l0, 0, LIST_0);

      //reference picture reordering
      reorder_ref_pic_list(listX[LIST_0], &listXsize[LIST_0], 
        img->num_ref_idx_l0_active - 1, 
        currSlice->reordering_of_pic_nums_idc_l0, 
        currSlice->abs_diff_pic_num_minus1_l0, 
        currSlice->long_term_pic_idx_l0);

      // This is not necessary since order is already poc based...  
      if (img->type == B_SLICE)
      {
        num_ref = img->num_ref_idx_l1_active;
        poc_ref_pic_reorder(listX[LIST_1], 
          num_ref, 
          currSlice->reordering_of_pic_nums_idc_l1, 
          currSlice->abs_diff_pic_num_minus1_l1, 
          currSlice->long_term_pic_idx_l1, 0, LIST_1);

        //reference picture reordering
        reorder_ref_pic_list(listX[LIST_1], &listXsize[LIST_1], 
          img->num_ref_idx_l1_active - 1, 
          currSlice->reordering_of_pic_nums_idc_l1, 
          currSlice->abs_diff_pic_num_minus1_l1, 
          currSlice->long_term_pic_idx_l1);
      }
    }
  }


  //if (img->MbaffFrameFlag)
  if (img->structure==FRAME)
    init_mbaff_lists();

  if (img->type != I_SLICE && (active_pps->weighted_pred_flag == 1 || (active_pps->weighted_bipred_idc > 0 && (img->type == B_SLICE))))
  {
    if (img->type==P_SLICE || img->type==SP_SLICE)
    {
      if (input->GenerateMultiplePPS && input->RDPictureDecision)
      {
        if (enc_picture==enc_frame_picture2)
          estimate_weighting_factor_P_slice (0);
        else
          estimate_weighting_factor_P_slice (1);
      }
      else
        estimate_weighting_factor_P_slice (0);

    }
    else
      estimate_weighting_factor_B_slice ();
  }

  set_ref_pic_num();

  if (img->type == B_SLICE)
    compute_colocated(Co_located, listX);
  if (img->type != I_SLICE && input->FMEnable == 3)
    EPZSSliceInit(EPZSCo_located, listX);
}


/*!
************************************************************************
* \brief
*    Allocates a slice structure along with its dependent data structures
* \return