header.c

JM 11.0 KTA 2.1 Source Code

      }
    }
    // Calculate the MSBs of current picture
    if( img->pic_order_cnt_lsb  <  img->PrevPicOrderCntLsb  &&  
      ( img->PrevPicOrderCntLsb - img->pic_order_cnt_lsb )  >=  ( MaxPicOrderCntLsb / 2 ) )
      img->PicOrderCntMsb = img->PrevPicOrderCntMsb + MaxPicOrderCntLsb;
    else if ( img->pic_order_cnt_lsb  >  img->PrevPicOrderCntLsb  &&
      ( img->pic_order_cnt_lsb - img->PrevPicOrderCntLsb )  >  ( MaxPicOrderCntLsb / 2 ) )
      img->PicOrderCntMsb = img->PrevPicOrderCntMsb - MaxPicOrderCntLsb;
    else
      img->PicOrderCntMsb = img->PrevPicOrderCntMsb;

    // 2nd

    if(img->field_pic_flag==0)
    {           //frame pix
      img->toppoc = img->PicOrderCntMsb + img->pic_order_cnt_lsb;
      img->bottompoc = img->toppoc + img->delta_pic_order_cnt_bottom;
      img->ThisPOC = img->framepoc = (img->toppoc < img->bottompoc)? img->toppoc : img->bottompoc; // POC200301
    }
    else if (img->bottom_field_flag==0)
    {  //top field 
      img->ThisPOC= img->toppoc = img->PicOrderCntMsb + img->pic_order_cnt_lsb;
    }
    else
    {  //bottom field
      img->ThisPOC= img->bottompoc = img->PicOrderCntMsb + img->pic_order_cnt_lsb;
    }
    img->framepoc=img->ThisPOC;

    if ( img->frame_num!=img->PreviousFrameNum)
      img->PreviousFrameNum=img->frame_num;

    if(img->nal_reference_idc)
    {
      img->PrevPicOrderCntLsb = img->pic_order_cnt_lsb;
      img->PrevPicOrderCntMsb = img->PicOrderCntMsb;
    }

    break;

  case 1: // POC MODE 1
    // 1st
    if(img->idr_flag)
    {
      img->FrameNumOffset=0;     //  first pix of IDRGOP, 
      img->delta_pic_order_cnt[0]=0;                        //ignore first delta
      if(img->frame_num)
        error("frame_num not equal to zero in IDR picture", -1020);
    }
    else 
    {
      if (img->last_has_mmco_5)
      {
        img->PreviousFrameNumOffset = 0;
        img->PreviousFrameNum = 0;
      }
      if (img->frame_num<img->PreviousFrameNum)
      {             //not first pix of IDRGOP
        img->FrameNumOffset = img->PreviousFrameNumOffset + img->MaxFrameNum;
      }
      else 
      {
        img->FrameNumOffset = img->PreviousFrameNumOffset;
      }
    }

    // 2nd
    if(active_sps->num_ref_frames_in_pic_order_cnt_cycle) 
      img->AbsFrameNum = img->FrameNumOffset+img->frame_num;
    else 
      img->AbsFrameNum=0;
    if( (!img->nal_reference_idc) && img->AbsFrameNum>0)
      img->AbsFrameNum--;

    // 3rd
    img->ExpectedDeltaPerPicOrderCntCycle=0;

    if(active_sps->num_ref_frames_in_pic_order_cnt_cycle)
      for(i=0;i<(int) active_sps->num_ref_frames_in_pic_order_cnt_cycle;i++)
        img->ExpectedDeltaPerPicOrderCntCycle += active_sps->offset_for_ref_frame[i];

    if(img->AbsFrameNum)
    {
      img->PicOrderCntCycleCnt = (img->AbsFrameNum-1)/active_sps->num_ref_frames_in_pic_order_cnt_cycle;
      img->FrameNumInPicOrderCntCycle = (img->AbsFrameNum-1)%active_sps->num_ref_frames_in_pic_order_cnt_cycle;
      img->ExpectedPicOrderCnt = img->PicOrderCntCycleCnt*img->ExpectedDeltaPerPicOrderCntCycle;
      for(i=0;i<=(int)img->FrameNumInPicOrderCntCycle;i++)
        img->ExpectedPicOrderCnt += active_sps->offset_for_ref_frame[i];
    }
    else 
      img->ExpectedPicOrderCnt=0;

    if(!img->nal_reference_idc)
      img->ExpectedPicOrderCnt += active_sps->offset_for_non_ref_pic;

    if(img->field_pic_flag==0)
    {           //frame pix
      img->toppoc = img->ExpectedPicOrderCnt + img->delta_pic_order_cnt[0];
      img->bottompoc = img->toppoc + active_sps->offset_for_top_to_bottom_field + img->delta_pic_order_cnt[1];
      img->ThisPOC = img->framepoc = (img->toppoc < img->bottompoc)? img->toppoc : img->bottompoc; // POC200301
    }
    else if (img->bottom_field_flag==0)
    {  //top field 
      img->ThisPOC = img->toppoc = img->ExpectedPicOrderCnt + img->delta_pic_order_cnt[0];
    } 
    else
    {  //bottom field
      img->ThisPOC = img->bottompoc = img->ExpectedPicOrderCnt + active_sps->offset_for_top_to_bottom_field + img->delta_pic_order_cnt[0];
    }
    img->framepoc=img->ThisPOC;

    img->PreviousFrameNum=img->frame_num;
    img->PreviousFrameNumOffset=img->FrameNumOffset;

    break;


  case 2: // POC MODE 2
    if(img->idr_flag) // IDR picture
    {
      img->FrameNumOffset=0;     //  first pix of IDRGOP, 
      img->ThisPOC = img->framepoc = img->toppoc = img->bottompoc = 0;
      if(img->frame_num) 
        error("frame_num not equal to zero in IDR picture", -1020);
    }
    else
    {
      if (img->last_has_mmco_5)
      {
        img->PreviousFrameNum = 0;
        img->PreviousFrameNumOffset = 0;
      }
      if (img->frame_num<img->PreviousFrameNum)
        img->FrameNumOffset = img->PreviousFrameNumOffset + img->MaxFrameNum;
      else 
        img->FrameNumOffset = img->PreviousFrameNumOffset;


      img->AbsFrameNum = img->FrameNumOffset+img->frame_num;
      if(!img->nal_reference_idc)
        img->ThisPOC = (2*img->AbsFrameNum - 1);
      else
        img->ThisPOC = (2*img->AbsFrameNum);

      if (img->field_pic_flag==0)
        img->toppoc = img->bottompoc = img->framepoc = img->ThisPOC;
      else if (img->bottom_field_flag==0)
        img->toppoc = img->framepoc = img->ThisPOC;
      else img->bottompoc = img->framepoc = img->ThisPOC;
    }

    img->PreviousFrameNum=img->frame_num;
    img->PreviousFrameNumOffset=img->FrameNumOffset;
    break;


  default:
    //error must occurs
    assert( 1==0 );
    break;
  }
}

/*!
************************************************************************
* \brief
*    A little helper for the debugging of POC code
* \return
*    none
************************************************************************
*/
int dumppoc(struct img_par *img) 
{
  printf ("\nPOC locals...\n");
  printf ("toppoc                                %d\n", img->toppoc);
  printf ("bottompoc                             %d\n", img->bottompoc);
  printf ("frame_num                             %d\n", img->frame_num);
  printf ("field_pic_flag                        %d\n", img->field_pic_flag);
  printf ("bottom_field_flag                     %d\n", img->bottom_field_flag);
  printf ("POC SPS\n");
  printf ("log2_max_frame_num_minus4             %d\n", active_sps->log2_max_frame_num_minus4);         // POC200301
  printf ("log2_max_pic_order_cnt_lsb_minus4     %d\n", active_sps->log2_max_pic_order_cnt_lsb_minus4);
  printf ("pic_order_cnt_type                    %d\n", active_sps->pic_order_cnt_type);
  printf ("num_ref_frames_in_pic_order_cnt_cycle %d\n", active_sps->num_ref_frames_in_pic_order_cnt_cycle);
  printf ("delta_pic_order_always_zero_flag      %d\n", active_sps->delta_pic_order_always_zero_flag);
  printf ("offset_for_non_ref_pic                %d\n", active_sps->offset_for_non_ref_pic);
  printf ("offset_for_top_to_bottom_field        %d\n", active_sps->offset_for_top_to_bottom_field);
  printf ("offset_for_ref_frame[0]               %d\n", active_sps->offset_for_ref_frame[0]);
  printf ("offset_for_ref_frame[1]               %d\n", active_sps->offset_for_ref_frame[1]);
  printf ("POC in SLice Header\n");
  printf ("pic_order_present_flag                %d\n", active_pps->pic_order_present_flag);
  printf ("delta_pic_order_cnt[0]                %d\n", img->delta_pic_order_cnt[0]);
  printf ("delta_pic_order_cnt[1]                %d\n", img->delta_pic_order_cnt[1]);
  printf ("delta_pic_order_cnt[2]                %d\n", img->delta_pic_order_cnt[2]);
  printf ("idr_flag                              %d\n", img->idr_flag);
  printf ("MaxFrameNum                           %d\n", img->MaxFrameNum);

  return 0;
}

/*!
************************************************************************
* \brief
*    return the poc of img as per (8-1) JVT-F100d2
*  POC200301
************************************************************************
*/
int picture_order(struct img_par *img)
{
  if (img->field_pic_flag==0) // is a frame
    return img->framepoc;
  else if (img->bottom_field_flag==0) // top field
    return img->toppoc;
  else // bottom field
    return img->bottompoc;
}

#ifdef E_DAIF
int readCoeff1(char *tracestring, int numQBits, Bitstream *bitstream)
{
  int prefix, suffix, suffixLen; 
  int coeffQ; 
  int sign = 0;
  int mag; 
  int rangeQ = 1<<(numQBits-1); 

  int i, bit; 

  // read prefix code
  for(i = 0; i < 5; i++)
  {
    bit = u_1(tracestring, bitstream);
    if(!bit)
      break; 
  }
  prefix = i; 

  // read suffix code
  suffixLen = numQBits-2-(5-prefix);
  if(prefix == 0)
    suffixLen++;
  suffix = u_v(suffixLen, tracestring, bitstream); 

  // get the magnitude 
  if(prefix == 0)
    mag = 0;
  else
    mag = rangeQ>>(6-prefix); 
  mag += suffix; 

  // read sign bit 
  if(mag) 
    sign = u_1(tracestring, bitstream); 

  coeffQ = sign ? -mag:mag; 

  return coeffQ; 
}

void readAIFInteger(Bitstream *currStream)
{
  int i;

  extern int DiffQFilterCoeffInt[SQR_FILTER_INT]; 
  extern int numQBitsInt[SQR_FILTER_INT-1];

  for(i = 0; i < FILTER_SIZE_INT*FILTER_SIZE_INT; i++)
  {
    DiffQFilterCoeffInt[i] = readCoeff1("SH: full-pel filter", numQBitsInt[i], currStream);
  }
}

void readAIFOffset(int sub_pos, Bitstream *bitstream)
{
  int offsetI, offsetF; 
  int sign = 0; 
  int offsetFracCodeLen[] = 
  {
    5, 4, 4, 2, 2, 2, 2, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
  };

  extern int DiffQFilterOffsetI[15], DiffQFilterOffsetF[15], DiffQFilterOffsetSign[15];
  extern int DiffQFilterOffsetIntI, DiffQFilterOffsetIntF, DiffQFilterOffsetIntSign; 

  if(sub_pos == -1) // full-pel offset
  {
    // integer part
    offsetI = se_v("full-pel offset int", bitstream);

    if(offsetFracCodeLen[offsetI])
      offsetF = u_v(offsetFracCodeLen[offsetI], "full-pel offset frac", bitstream); 
    else
      offsetF = 0; 
    if(offsetI || (offsetF > 0)) 
      sign = u_1("full-pel offset sign", bitstream);
    DiffQFilterOffsetIntI = offsetI; 
    DiffQFilterOffsetIntF = offsetF; 
    DiffQFilterOffsetIntSign = sign ? -1:1; 
  }
  else // subpel offset 
  {
    // send integer, using EXP-GOLOMB
    offsetI = se_v("sub-pel offset int", bitstream);

    // send fraction, using fixed-length code 
    if(offsetFracCodeLen[offsetI])
    {
      offsetF = u_v(offsetFracCodeLen[offsetI], "sub-pel offset frac", bitstream); 
    }
    else 
      offsetF = 0;
    if(offsetI || (offsetF > 0)) 
      sign = u_1("sub-pel offset sign", bitstream);
    DiffQFilterOffsetI[sub_pos] = offsetI; 
    DiffQFilterOffsetF[sub_pos] = offsetF; 
    DiffQFilterOffsetSign[sub_pos] = sign ? -1:1; 
  }
}
#endif  // E_DAIF


#ifdef DIRECTIONAL_FILTER
void readFilterCoefs(int filterID,Bitstream *currStream)
{
  extern int POS_EQUATION_NUMBER[15];
  extern int DiffQFilterCoef[15][SQR_FILTER];
  extern int FilterFlag[15];            
  extern int FILTER_SIZE;
  extern int FILTER_OFFSET;
  extern int UseAllSubpelPositions;
  extern int SubpelPositionsPattern;

  int i,j,sub_pos;
  if (filterID==FILTER_TYPE_1D)
  {
    UseAllSubpelPositions = u_1("use_all_subpel_positions", currStream);
    if(UseAllSubpelPositions)
    {
      for(sub_pos=a_pos; sub_pos <= o_pos; sub_pos++)
        FilterFlag[sub_pos] = 1;
      SubpelPositionsPattern =   (FilterFlag[j_pos]<<4) + (FilterFlag[f_pos]<<3) + (FilterFlag[e_pos]<<2) + 
        (FilterFlag[b_pos]<<1) +  FilterFlag[a_pos];
    }
    else
    {
      SubpelPositionsPattern = ue_v("positions_pattern", currStream);
      FilterFlag[a_pos] = 
        FilterFlag[c_pos] = 
        FilterFlag[d_pos] =
        FilterFlag[l_pos] =  SubpelPositionsPattern       & 1;
      FilterFlag[b_pos] = 
        FilterFlag[h_pos] = (SubpelPositionsPattern >> 1) & 1;
      FilterFlag[e_pos] = 
        FilterFlag[g_pos] = 
        FilterFlag[m_pos] =
        FilterFlag[o_pos] = (SubpelPositionsPattern >> 2) & 1;
      FilterFlag[f_pos] = 
        FilterFlag[i_pos] = 
        FilterFlag[k_pos] =
        FilterFlag[n_pos] = (SubpelPositionsPattern >> 3) & 1;
      FilterFlag[j_pos] = (SubpelPositionsPattern >> 4) & 1;
    }
    if(FilterFlag[a_pos])
      for(i= 0; i < POS_EQUATION_NUMBER[a_pos]; i++)
        DiffQFilterCoef[a_pos][FILTER_SIZE*FILTER_OFFSET+i] = se_v("a_pos", currStream);
    if(FilterFlag[b_pos])
      for(i= 0; i < POS_EQUATION_NUMBER[b_pos]; i++)
        DiffQFilterCoef[b_pos][FILTER_SIZE*FILTER_OFFSET+i] = se_v("b_pos", currStream);
    if(FilterFlag[e_pos])
      for(i = 0; i < FILTER_SIZE; i++)
      {
        j = i;//NW-SE
        DiffQFilterCoef[e_pos][FILTER_SIZE*i+j] = se_v("e_pos", currStream);
      }
      if(FilterFlag[f_pos])
      {
        for(i = 0; i < FILTER_SIZE/*/2*/; i++)
        {
          j = i;//NW-SE
          DiffQFilterCoef[f_pos][FILTER_SIZE*i+j] = se_v("f_pos", currStream);
          /*            }
          for(i = FILTER_SIZE/2; i< FILTER_SIZE; i++)
          {
          j = FILTER_SIZE-i-1;//NW-SE*
          DiffQFilterCoef[f_pos][FILTER_SIZE*i+j] = se_v("f_pos", currStream);*/
        }
      }

      if(FilterFlag[j_pos])
        for(i = 0; i < FILTER_SIZE/2; i++)
        {
          j = i;//NW-SE
          DiffQFilterCoef[j_pos][FILTER_SIZE*i+j] = se_v("j_pos", currStream);
        }


  }
  //PrintFilterCoefInt(DiffQFilterCoef);
  for(sub_pos = a_pos; sub_pos <= o_pos; sub_pos++)
    ExtendFilterCoefficientsInt(sub_pos, DiffQFilterCoef);
  //PrintFilterCoefInt(DiffQFilterCoef);

}
#endif

#ifdef E_DAIF
void readFilterCoefs_EDAIF(int filterID,Bitstream *currStream)
{
  int sub_pos;
  extern int SymmetryPosition[15];
  extern int FilterFlag[15];            

  extern int FilterFlagInt;

  if (!(filterID == FILTER_TYPE_EDAIF))
  {
    printf("ERROR: Wrong filter type @readFilterCoefs_EDAIF!\n");
    return;
  }

  readFilterCoefs(FILTER_TYPE_1D, currStream);

  // full-pel filter flag
  FilterFlagInt = u_1("FilterFlagInt", currStream); 
  if(FilterFlagInt)
    readAIFInteger(currStream);

  // sub-pel filter offsets
  for(sub_pos = a_pos; sub_pos <= o_pos; sub_pos++)
  {
    if(FilterFlag[sub_pos] && SymmetryPosition[sub_pos])
      readAIFOffset(sub_pos, currStream); 
  }
  // full-pel filter flag
  if(FilterFlagInt)
    readAIFOffset(-1, currStream); 
}
#endif  // E_DAIF