header.c

JM 11.0 KTA 2.1 Source Code

  assert (PartNo > 0 && PartNo < img->currentSlice->max_part_nr);

  sym->type = SE_HEADER;         // This will be true for all symbols generated here
  sym->mapping = ue_linfo;       // Mapping rule: Simple code number to len/info
  sym->value2  = 0;

  //ZL 
  //changed according to the g050r1
  SYMTRACESTRING("RTP-PH: Slice ID");
  sym->value1 = img->current_slice_nr;
  len += writeSyntaxElement_UVLC (sym, partition);

  return len;
}

#ifdef E_DAIF
void generatePrefixCode_EDAIF(int *prefixCode, int *prefixCodeLen, int size)
{
  int i; 

  prefixCode[0] = 0;
  prefixCodeLen[0] = 1;

  for(i = 1; i < size-1; i++)
  {
    prefixCode[i] = (1<<(i+1))-2; 
    prefixCodeLen[i] = i+1;
  }

  prefixCode[size-1] = prefixCode[size-2]+1;
  prefixCodeLen[size-1] = prefixCodeLen[size-2];
}

void generateThres_EDAIF(int *thres, int max, int size)
{
  int i; 

  thres[0] = 0; 
  for(i = 0; i < size; i++)
    thres[i+1] = max >> (size-1-i);
}

int writeCoeff_EDAIF(int coeffQ, Bitstream *bitstream, int numQBits, int depth, char *tracestring)
{
  int prefixCode[100];
  int prefixCodeLen[100]; 
  int thres[100];

  int sign = (coeffQ >= 0) ? 0:1; 
  int mag = (sign==0) ? coeffQ:(-coeffQ); 

  int rangeQ = 1<<(numQBits-1); 

  int len = 0;
  int i; 
  int suffixLen; 
  int bin;

  generatePrefixCode_EDAIF(prefixCode, prefixCodeLen, depth);
  generateThres_EDAIF(thres, rangeQ, depth); 

  // find to which bin this value "mag" belongs
  for(i = 0; i < depth; i++)
  {
    if(mag >= thres[i] && mag < thres[i+1])
      break; 
  }
  bin = i;
  assert(bin < depth);

  suffixLen = numQBits-2;
  for(i = depth-1; i > bin; i--)
    suffixLen--;
  if(bin == 0)
    suffixLen++;

  len += u_v(prefixCodeLen[bin], tracestring, prefixCode[bin], bitstream); 
  len += u_v(suffixLen, tracestring, mag-thres[bin], bitstream); 

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

  return len; 
}

int sendAIFInteger_EDAIF(Bitstream *bitstream)
{
  int newStreamFlag; 
  int i; 
  int len = 0; 

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

  if(!FilterFlagInt)
    return len; 

  newStreamFlag = 0;
  if (bitstream==NULL)
  {
    bitstream =  (Bitstream *) calloc(1, sizeof(Bitstream));
    bitstream->streamBuffer = (byte *) calloc(1000, sizeof(byte));
    newStreamFlag = 1;
  }

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

  if (newStreamFlag)
  {
    free(bitstream->streamBuffer);
    free(bitstream);
  }

  return len;
}

int sendAIFOffset(int sub_pos, Bitstream *bitstream)
{
  int newStreamFlag; 
  int len = 0; 
  int offsetI, offsetF; 
  int sign; 
  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 SymmetryPosition[15];
  extern int FilterFlagInt; 
  extern int FilterFlag[15]; 
  extern double FilterCoef[15][SQR_FILTER];
  extern double FilterCoefInt [SQR_FILTER_INT];
  extern int DiffQFilterOffsetI[15], DiffQFilterOffsetF[15];
  extern int DiffQFilterOffsetIntI, DiffQFilterOffsetIntF; 
  extern int FILTER_SIZE; 

  newStreamFlag = 0;
  if (bitstream==NULL)
  {
    bitstream =  (Bitstream *) calloc(1, sizeof(Bitstream));
    bitstream->streamBuffer = (byte *) calloc(1000, sizeof(byte));
    newStreamFlag = 1;
  }

  if(sub_pos == -1) // full-pel offset
  {
    if(FilterFlagInt)
    {
      offsetI = DiffQFilterOffsetIntI; 
      offsetF = DiffQFilterOffsetIntF; 
      sign = FilterCoefInt[SQR(FILTER_SIZE_INT)] >= 0. ? 0:1;
      // send integer, using EXP-GOLOMB
      len += se_v("SH: offset int", offsetI, bitstream);

      // send fraction, using fixed-length code 
      if(offsetF != -1)
      {
        len += u_v(offsetFracCodeLen[offsetI], "SH: offset frac", offsetF, bitstream); 
      }
      if(offsetI || (offsetF > 0)) 
        len += u_1("SH: offset sign", sign, bitstream);
    }
  }
  else if(FilterFlag[sub_pos] && SymmetryPosition[sub_pos]) // subpel offset 
  {
    offsetI = DiffQFilterOffsetI[sub_pos]; 
    offsetF = DiffQFilterOffsetF[sub_pos]; 
    sign = FilterCoef[sub_pos][SQR(FILTER_SIZE)] >= 0. ? 0:1;
    // send integer, using EXP-GOLOMB
    len += se_v("SH: offset int", offsetI, bitstream);

    // send fraction, using fixed-length code 
    if(offsetF != -1)
    {
      len += u_v(offsetFracCodeLen[offsetI], "SH: offset frac", offsetF, bitstream); 
    }
    if(offsetI || (offsetF > 0)) 
      len += u_1("SH: offset sign", sign, bitstream);
  }

  if (newStreamFlag)
  {
    free(bitstream->streamBuffer);
    free(bitstream);
  }

  return len; 
}
#endif

#ifdef DIRECTIONAL_FILTER
/*! 
*************************************************************************************
* \brief
*   Send 1D-AIF coefficient to the bitstream
*  
* \para <title>
*    <paragraph>
*
* \para
*    <another paragraph>
*
* \author
*    - Dmytro Rusanovskyy                   <[e-mail]>
*************************************************************************************
*/
int sendCoefsAIF(Bitstream *bitstream)
{
  int i, j;
  int newStreamFlag;
  extern int DiffQFilterCoef[15][SQR_FILTER];        // differences to be transmitted
  extern int POS_EQUATION_NUMBER[15];                // number of different coefficietns for each sub-pel position
  extern int FilterFlag[15];                         // Flags defining if Filter at the particular position calculated
  extern int UseAllSubpelPositions;                  // 1 if FilterFlag for all independent positions is 1
  extern int SubpelPositionsPattern;
  extern int FILTER_SIZE;
  extern int FILTER_OFFSET;

  //Bitstream *bitstream;
  int len = 0;

  newStreamFlag = 0;
  if (bitstream==NULL)
  {
    bitstream =  (Bitstream *) calloc(1, sizeof(Bitstream));
    bitstream->streamBuffer = (byte *) calloc(1000, sizeof(byte));
    newStreamFlag = 1;
  }

  len += u_1("SH: use_all_subpel_positions", UseAllSubpelPositions, bitstream);

  //  If simmetry is assumed FILTER_TYPE_Z17 transmits pattern otherwise  we transmit filterFlag[]
  if(!UseAllSubpelPositions)
    len += ue_v("SH: positions_pattern", SubpelPositionsPattern, bitstream);

  if(FilterFlag[a_pos])
    for(i= 0; i < POS_EQUATION_NUMBER[a_pos]; i++)
      len += se_v("SH: a_pos", DiffQFilterCoef[a_pos][FILTER_SIZE*FILTER_OFFSET+i], bitstream);
  if(FilterFlag[b_pos])
    for(i= 0; i < POS_EQUATION_NUMBER[b_pos]; i++)
      len += se_v("SH: b_pos", DiffQFilterCoef[b_pos][FILTER_SIZE*FILTER_OFFSET+i], bitstream);
  if(FilterFlag[e_pos])
    for(i = 0; i < FILTER_SIZE; i++)
    {
      j = i;//NW-SE
      len += se_v("SH: e_pos", DiffQFilterCoef[e_pos][FILTER_SIZE*i+j], bitstream);
    }
    if(FilterFlag[f_pos])
      for(i = 0; i < FILTER_SIZE; i++)
      {
        j = i;//NW-SE
        len += se_v("SH: f_pos", DiffQFilterCoef[f_pos][FILTER_SIZE*i+j], bitstream);
      }
      if(FilterFlag[j_pos])
        for(i = 0; i < FILTER_SIZE/2; i++)
        {
          j = i;//NW-SE
          len += se_v("SH: j_pos", DiffQFilterCoef[j_pos][FILTER_SIZE*i+j], bitstream);
        }

        if (newStreamFlag)
        {
          free(bitstream->streamBuffer);
          free(bitstream);
        }
        // printf("nAIF: %d\n",len);
        return len;
}


#ifdef E_DAIF
int sendCoefs_EDAIF(Bitstream *bitstream)
{
  int len;
  int sub_pos;
  int newStreamFlag;
  extern int FilterFlagInt; 

  len = 0;
  newStreamFlag = 0;
  if (bitstream==NULL)
  {
    bitstream =  (Bitstream *) calloc(1, sizeof(Bitstream));
    bitstream->streamBuffer = (byte *) calloc(1000, sizeof(byte));
    newStreamFlag = 1;
  }

  // This function is improvement on the top of DAIF => we send first DAIF coefs and after offsets and Integer pos. filter
  len += sendCoefsAIF(bitstream);

  // full-pel filter
  len += u_1("SH: FilterFlagInt", FilterFlagInt, bitstream); 
  len += sendAIFInteger_EDAIF(bitstream); 

  // sub-pel filter offsets
  for(sub_pos = a_pos; sub_pos <= o_pos; sub_pos++)
  {
    len += sendAIFOffset(sub_pos, bitstream); 
  }

  // full-pel filter offset
  len += sendAIFOffset(-1, bitstream); 

  if (newStreamFlag)
  {
    free(bitstream->streamBuffer);
    free(bitstream);
  }
  // printf("nAIF: %d\n",len);
  return len;
}

//
//  Estimates the cost in bit of sending the filter corresponding to a sub-pixel position
//
int estimateCostOfCoefs_EDAIF(int sub_pos)
{
  extern int DiffQFilterCoef[15][SQR_FILTER];       // differences to be transmitted
  extern int POS_EQUATION_NUMBER[15];               // number of different coefficietns for each sub-pel position
  extern int FILTER_SIZE;
  extern int FILTER_OFFSET;

  int len = 0;
  int i;
  Bitstream *bitstream = (Bitstream *) calloc(1, sizeof(Bitstream));

  bitstream->streamBuffer = (byte *) calloc(1000, sizeof(byte));

  if(sub_pos == a_pos)
    for(i = 0; i < POS_EQUATION_NUMBER[a_pos]; i++)
      len += se_v("SH: a_pos", DiffQFilterCoef[a_pos][FILTER_SIZE*FILTER_OFFSET+i], bitstream);
  else if(sub_pos == b_pos)
    for(i = 0; i < POS_EQUATION_NUMBER[b_pos]; i++)
      len += se_v("SH: b_pos", DiffQFilterCoef[b_pos][FILTER_SIZE*FILTER_OFFSET+i], bitstream);
  else if(sub_pos == e_pos)
    for(i = 0; i < FILTER_SIZE; i++)
      len += se_v("SH: e_pos", DiffQFilterCoef[e_pos][FILTER_SIZE*i+i], bitstream);
  else if(sub_pos == f_pos)
    for(i = 0; i < FILTER_SIZE; i++)
      len += se_v("SH: f_pos", DiffQFilterCoef[f_pos][FILTER_SIZE*i+i], bitstream);
  else if(sub_pos == j_pos)
    for(i = 0; i < FILTER_SIZE / 2; i++)
      len += se_v("SH: j_pos", DiffQFilterCoef[j_pos][FILTER_SIZE*i+i], bitstream);

  free(bitstream->streamBuffer);
  free(bitstream);

  // printf("nAIF: %d\n",len);
  return len;
}

#endif  //  E_DAIF

#endif