sequence.c

Nokia H.264/AVC Encoder/Decoder Usage Manual

          frmStat->bitsCoefLuma +
          frmStat->bitsCoefChromaDC +
          frmStat->bitsCoefChroma +
          frmStat->bitsArithmeticStream;  
        
        headerBits=
          frmStat->bitsNAL +
          frmStat->bitsHdr +
          frmStat->bitsSkipLen +
          frmStat->bitsMBtype +
          frmStat->bitsPred +
          frmStat->bitsVec +
          frmStat->bitsCBP;
        
      }
      }
      else if(textureBits + headerBits < seq->bRC.bitsPerFrame*seq->bRC.I_P_RATIO)
      {
        maxreencode=5;
        while( textureBits + headerBits < seq->bRC.bitsPerFrame*seq->bRC.I_P_RATIO && maxreencode>0)
        {
        maxreencode--;
        bibInit(&seq->bitbuf);
        
        if(seq->bRC.useSEI)
          sendPictureTimingSEIMessage(&seq->bitbuf,&seq->bRC.picture_timing_SEI,&seq->sps.vui_parameters.vcl_hrd_parameters, &seq->nonSliceStat.bitsNAL);

        staClear(frmStat);
        seq->bRC.numIntraMBs = 0;
        
        seq->bRC.stat_NumberofReencodes++;
        printf("REENCODE\n");
        seq->bRC.frameComputedQP -=2;
      seq->bRC.frameReturnedQP = seq->bRC.frameComputedQP;
      slice->qp = seq->bRC.frameComputedQP;
        
        numIntraMbs = frmEncode(slice, & seq->dpbBuf, 
          &seq->encPar, &seq->mbData, &seq->sps, &seq->pps, seq->forcedIRNo, seq->forcedIR, &seq->bRC);
        
        textureBits=
          frmStat->bitsCoefLumaDC +
          frmStat->bitsCoefLuma +
          frmStat->bitsCoefChromaDC +
          frmStat->bitsCoefChroma +
          frmStat->bitsArithmeticStream;  
        
        headerBits=
          frmStat->bitsNAL +
          frmStat->bitsHdr +
          frmStat->bitsSkipLen +
          frmStat->bitsMBtype +
          frmStat->bitsPred +
          frmStat->bitsVec +
          frmStat->bitsCBP;
        
      }
      }
    }
    else if(slice->sliceType == SLICE_I)
    {
      maxreencode=5;
      if(seq->bRC.CurrentBufferFullness + textureBits + headerBits - seq->bRC.bitsPerFrame)
      {
      while((seq->bRC.CurrentBufferFullness + textureBits + headerBits - seq->bRC.bitsPerFrame > seq->bRC.BufferSize && maxreencode>0))
      {
        maxreencode--;
        //Buffer Overflow and I picture
        bibInit(&seq->bitbuf);
        
        if(seq->bRC.useSEI)
          sendPictureTimingSEIMessage(&seq->bitbuf,&seq->bRC.picture_timing_SEI,&seq->sps.vui_parameters.vcl_hrd_parameters, &seq->nonSliceStat.bitsNAL);
        
        staClear(frmStat);
        seq->bRC.numIntraMBs = 0;
        
        seq->bRC.stat_NumberofReencodes++;
        printf("REENCODE\n");
        slice->qp = (int16)MIN(seq->bRC.frameComputedQP+2,51);
        seq->bRC.frameComputedQP = slice->qp;
        seq->bRC.frameReturnedQP = slice->qp;
        numIntraMbs = frmEncode(slice, & seq->dpbBuf, 
          &seq->encPar, &seq->mbData, &seq->sps, &seq->pps, seq->forcedIRNo, seq->forcedIR, &seq->bRC);
        
        textureBits=
          frmStat->bitsCoefLumaDC +
          frmStat->bitsCoefLuma +
          frmStat->bitsCoefChromaDC +
          frmStat->bitsCoefChroma +
          frmStat->bitsArithmeticStream;  
        
        headerBits=
          frmStat->bitsNAL +
          frmStat->bitsHdr +
          frmStat->bitsSkipLen +
          frmStat->bitsMBtype +
          frmStat->bitsPred +
          frmStat->bitsVec +
          frmStat->bitsCBP;        
      }
      }
    }
    else
    {
      maxreencode=5;
      while((seq->bRC.CurrentBufferFullness + textureBits + headerBits - seq->bRC.bitsPerFrame > seq->bRC.BufferSize && slice->sliceType == SLICE_P && maxreencode>0))
      {
        maxreencode--;      
        bibInit(&seq->bitbuf);
        
        if(seq->bRC.useSEI)
          sendPictureTimingSEIMessage(&seq->bitbuf,&seq->bRC.picture_timing_SEI,&seq->sps.vui_parameters.vcl_hrd_parameters, &seq->nonSliceStat.bitsNAL);

        staClear(frmStat);
        seq->bRC.numIntraMBs = 0;
        
        seq->bRC.stat_NumberofReencodes++;
        printf("REENCODE\n");
        slice->qp = (int16)(MIN(seq->bRC.frameComputedQP+2,51));
        seq->bRC.frameComputedQP = slice->qp;
        seq->bRC.frameReturnedQP = slice->qp;
        numIntraMbs = frmEncode(slice, & seq->dpbBuf, 
          &seq->encPar, &seq->mbData, &seq->sps, &seq->pps, seq->forcedIRNo, seq->forcedIR, &seq->bRC);
        
        textureBits=
          frmStat->bitsCoefLumaDC +
          frmStat->bitsCoefLuma +
          frmStat->bitsCoefChromaDC +
          frmStat->bitsCoefChroma +
          frmStat->bitsArithmeticStream;  
        
        headerBits=
          frmStat->bitsNAL +
          frmStat->bitsHdr +
          frmStat->bitsSkipLen +
          frmStat->bitsMBtype +
          frmStat->bitsPred +
          frmStat->bitsVec +
          frmStat->bitsCBP;
        
      }
    }
 
    {
      
      if((seq->bRC.SPPPictureCounter!=0) && ( seq->bRC.TotalFrameBits>seq->bRC.upperFrameLimit*1.2 || seq->bRC.TotalFrameBits<seq->bRC.lowerFrameLimit*0.8 ) && (fabs(seq->bRC.averageQPforFrame - seq->bRC.frameComputedQP*1.0) > 4))
      {
        if(!(seq->bRC.TotalFrameBits<seq->bRC.lowerFrameLimit*0.8 && !(seq->bRC.bufferStall == 0 || seq->bRC.CurrentBufferFullness*1.0/seq->bRC.BufferSize > 0.1)))
        {
          //do not reencode low-complexity frames unless critical buffer situation  
          bibInit(&seq->bitbuf);
          
          if(seq->bRC.useSEI)
            sendPictureTimingSEIMessage(&seq->bitbuf,&seq->bRC.picture_timing_SEI,&seq->sps.vui_parameters.vcl_hrd_parameters, &seq->nonSliceStat.bitsNAL);
          
          staClear(frmStat);
          seq->bRC.numIntraMBs = 0;
          
          seq->bRC.stat_NumberofReencodes++;
          printf("REENCODE\n");
          slice->qp = (int16)(seq->bRC.averageQPforFrame+0.5);
          seq->bRC.frameComputedQP = (int)(seq->bRC.averageQPforFrame+0.5);
          numIntraMbs = frmEncode(slice, & seq->dpbBuf, 
            &seq->encPar, &seq->mbData, &seq->sps, &seq->pps, seq->forcedIRNo, seq->forcedIR, &seq->bRC);
        }
      }
    }
#else

if(seq->encPar.frameSkipEnabled >= 1)
  {
   
  if( seq->bRC.PictureIndex == 0 && seq->bRC.bit_rate > 0 && seq->bRC.ignoreIDR == 0) {
      slice->qp = (short) seq->bRC.InitialQP;   
    while((rc_update_pict(&seq->bRC,slice->sliceType, textureBits, headerBits,(float)frmStat->psnrY) == AVCE_FRAME_SKIPPED))
      {
        //Buffer Overflow and I picture
                
        bibInit(&seq->bitbuf);
        
        if(seq->bRC.useSEI)
          sendPictureTimingSEIMessage(&seq->bitbuf,&seq->bRC.picture_timing_SEI,&seq->sps.vui_parameters.vcl_hrd_parameters, &seq->nonSliceStat.bitsNAL);

        staClear(frmStat);
        seq->bRC.numIntraMBs = 0;
        seq->bRC.PictureIndex--;    
        seq->bRC.stat_NumberofReencodes++;
        printf("REENCODE1: %d\n",seq->bRC.numConsecutiveSkips);
        slice->qp= (short) (seq->bRC.InitialQP+seq->bRC.stat_NumberofReencodes);
        seq->bRC.frameComputedQP = slice->qp;
        seq->bRC.frameReturnedQP = slice->qp;
        numIntraMbs = frmEncode(slice, & seq->dpbBuf, 
          &seq->encPar, &seq->mbData, &seq->sps, &seq->pps, seq->forcedIRNo, seq->forcedIR, &seq->bRC);
        
        textureBits=
          frmStat->bitsCoefLumaDC +
          frmStat->bitsCoefLuma +
          frmStat->bitsCoefChromaDC +
          frmStat->bitsCoefChroma +
          frmStat->bitsArithmeticStream;  
        
        headerBits=
          frmStat->bitsNAL +
          frmStat->bitsHdr +
          frmStat->bitsSkipLen +
          frmStat->bitsMBtype +
          frmStat->bitsPred +
          frmStat->bitsVec +
          frmStat->bitsCBP;
      }
      seq->bRC.PictureIndex--;
    }

}

    
#endif
  }
  else
    numIntraMbs = frmEncode(slice, & seq->dpbBuf, 
    &seq->encPar, &seq->mbData, &seq->sps, &seq->pps, seq->forcedIRNo, seq->forcedIR, &seq->bRC);
  


    
  if (slice->sliceType == SLICE_P)
  {
    numMbsPerFrm = (seq->encPar.picWidth/16) * (seq->encPar.picHeight/16);
    
    if (((seq->encPar.scIntra == 1) && (numIntraMbs == numMbsPerFrm)) ||
      ((seq->encPar.scIntra == 2) && (numIntraMbs >= (numMbsPerFrm * 95)/100)))
    {
      bibInit(&seq->bitbuf);
      
      if(seq->bRC.useSEI)
          sendPictureTimingSEIMessage(&seq->bitbuf,&seq->bRC.picture_timing_SEI,&seq->sps.vui_parameters.vcl_hrd_parameters, &seq->nonSliceStat.bitsNAL);
      
      slice->sliceType = SLICE_I;
      
      // we re-encode this frame as intra frame
      // Clear frame statistics
      staClear(frmStat);
      
      if(seq->bRC.bit_rate > 0)
        
      {
        slice->qp = (int16)rc_getFrameQP(& seq->bRC,slice->sliceType);
        
        frmEncode(slice, & seq->dpbBuf, &seq->encPar, &seq->mbData, &seq->sps, 
          &seq->pps, seq->forcedIRNo, seq->forcedIR, &seq->bRC);
      }
      else
        frmEncode(slice, & seq->dpbBuf, &seq->encPar, &seq->mbData, &seq->sps, 
        &seq->pps, seq->forcedIRNo, seq->forcedIR, &seq->bRC);
      
    }
  }
  
  calcRecoError(& seq->recoFrm, & origBuf, frmStat);
  
  /* Return reconstructed frame buffer to the caller */
  recoPic->y = seq->recoFrm.y;
  recoPic->u = seq->recoFrm.u;
  recoPic->v = seq->recoFrm.v;
  
  
  /* Update statistics */
  frmStat->nFrames = 1;
  
  
  textureBits=
    frmStat->bitsCoefLumaDC +
    frmStat->bitsCoefLuma +
    frmStat->bitsCoefChromaDC +
    frmStat->bitsCoefChroma +
    frmStat->bitsArithmeticStream;  
  
  headerBits=
    frmStat->bitsNAL +
    frmStat->bitsHdr +
    frmStat->bitsSkipLen +
    frmStat->bitsMBtype +
    frmStat->bitsPred +
    frmStat->bitsVec +
    frmStat->bitsCBP;
  
     
  i=rc_update_pict(&seq->bRC,slice->sliceType, textureBits, headerBits,(float)frmStat->psnrY);
  
  if(i!=AVCE_FRAME_SKIPPED)
  {
      
    staAccumulate(seqStat, frmStat);
    
    /* update dpb */
    dpbUpdate(& seq->dpbBuf, & seq->recoFrm, nalRefIdc, idrFlag, seq->encPar.low_complex_prof3);
    
#if 1
    /*
    /* Printf frame by frame statistics */
    
    deb5f(stderr, "%3i  snr: Y %2.2f  U: %2.2f  V: %2.2f  bits: %7i\n",
      srcPicNum, frmStat.psnrY, frmStat.psnrU, frmStat.psnrV,
      staGetTotalBits(&frmStat));
    
#endif
    
#ifdef RC_DEBUG
    if(seq->encPar.brcBitRate!= 0)
      rc_printDebug(&seq->bRC,frmStat);
#endif  
    
    /* Get NAL bit buffer pointer and bit buffer length in bytes */
    *nalBufSize = bibGetBuffer(&seq->bitbuf, nalBuffer);
    
    /* Reset bit buffer to empty state. This does not delete contents of bit buffer */
    bibInit(&seq->bitbuf);
    
  }
  else
  {
    
    //Frame skipped
    bibInit(&seq->bitbuf);
    staClear(frmStat);
    seq->dpbBuf.prevRefFrameNum--;
    seq->dpbBuf.frameNum--;
  }
  
  if(i==AVCE_FRAME_SKIPPED)
    return AVCE_FRAME_SKIPPED;
  else        
    return AVCE_OK;
}


/*
* avceEncodeSceneInfo:
*
* Parameters:
*      seq                   Encoder instance
*      sceneId               The Scene ID
*      nalBuffer             Return pointer for nal bits buffer
*      nalBufSize            Return pointer for nal buffer size
*
* Function:
*      Encode the scene information SEI message.
*      
* Returns:
*      AVCE_ERROR          for error
*      AVCE_OK             for ok
*/
int avceEncodeSceneInfo(avceEncoder_t *pSeq, int sceneId, void **nalBuffer, int *nalBufSize)
{
  int         byte;
  sequence_s  *seq;
  bitbuffer_s tmpBitbuf;
  bitbuffer_s *bitbuf;
  int         initialSize;
  int         payloadSize;
  
  seq = (sequence_s *) pSeq;
  
  bitbuf = &tmpBitbuf;
  initialSize = 500;    // hard coded
  
  bibOpen(bitbuf, initialSize);
  
  /* start code prefix */
  vlcuSendNalUnitStartCodePrefix(&seq->bitbuf, 1);
  
  /* NAL head */
  vlcuSendNalHead(&seq->bitbuf, 0, SEI_NAL_TYPE);
  
  /* 
  * BEGIN -- scene info payload 
  */
  
  payloadSize = 0;
  
  /* scene_info_present_flag (1) */
  byte = 1;
  payloadSize += u_n(bitbuf, byte, 1);
  
  /* scene id */
  payloadSize += ue_v(bitbuf, sceneId);
  
  /* scene transition type (0) */
  byte = 0;
  payloadSize += ue_v(bitbuf, byte);
  
  /* byte align */ 
  if (!bibIsByteAlign(bitbuf))
    payloadSize += bibTrailingBits(bitbuf);
  
  payloadSize = (payloadSize >> 3);
  
  /* 
  * write the scene info payload to SEI message
  */
  
  /* payload type (9) */
  bibPutByte(&seq->bitbuf, SEI_TYPE_SCENE_INFO);
  
  /* payload size */
  while (payloadSize > 255) {
    byte = 0xFF;
    bibPutByte(&seq->bitbuf, byte);
    payloadSize -= byte;
  }
  bibPutByte(&seq->bitbuf, payloadSize);
  
  /* copy the payload */
  memcpy(seq->bitbuf.bufAddr + seq->bitbuf.bytePos, bitbuf->bufAddr, bitbuf->bytePos);
  seq->bitbuf.bytePos += bitbuf->bytePos;
  
  /* 
  * END -- scene info payload 
  */
  
  bibTrailingBits(bitbuf);
  
  /* Get NAL bit buffer pointer and bit buffer length in bytes */
  *nalBufSize = bibGetBuffer(&seq->bitbuf, nalBuffer);
  
  /* Reset bit buffer to empty state. This does not delete contents of bit buffer */
  bibInit(&seq->bitbuf);
  
#if 1
  printf("Scene %d ....\n", sceneId);
#endif
  
  bibClose(bitbuf);
  
  return AVCE_OK;
}


void avceUpdateEncodingParameters(avceEncoder_t *encoder, avceOpenParams_s *param)
{
  sequence_s *seq;
  seq = (sequence_s *) encoder;
  
  //Update only the bitrate for now
  seq->encPar.brcBitRate = param->brcBitRate;
  rc_update_bitrate(& seq->bRC,seq->encPar.brcBitRate);  
}