nok_bwp_enc.c

语音压缩算法

	for (j = 0; j < BWP_BLEN; j++)
	  x_buffer[i][j] = 0;

      for (i = 0; i < BWP_LPC; i++)
	for (j = 0; j < CLEN; j++)
	  pred[i][j] = 63;

      for (j = 0; j < CLEN; j++)
	{
	  last_spec[j] = 0.0;
	  sb_samples_pred[j] = 0.0;
	}

      pred_global_flag[0] = 0;

      pred_global_prev = 0;

      indicate = 0;

      do_reset = 0;

      short_set = 0;

      if (debuglevel >= DEBUG_THRESHOLD)
	fprintf (stderr, "nok_PredCalcPrediction: number of bit save -1\n");

    }
  else
    {

      short_set++;

      for (i = 0; i < CLEN; i++)
	{
	  ftemp = (float)last_spec[i];
	  flt_round_8 (&ftemp);
	  last_spec[i] = ftemp;
	  last_spec[i] += sb_samples_pred[i];
	}

      if (short_set > 81 && pred_global_prev == 1 && do_reset == 1)
	{
	  rg = (resetting_group > 0) ? resetting_group - 1 : RESET_GROUPS - 1;
	  for (j = rg; j < CLEN; j += RESET_GROUPS)
	    last_spec[j] = 0.0;
	  if (debuglevel >= DEBUG_THRESHOLD)
	    fprintf (stderr, "nok_PredCalcPrediction: reset_group2 %d %d %d %d\n", short_set, pred_global_prev, do_reset, rg);
	}

      autocorr (x_buffer, last_spec, pred, sb_samples_pred, BWP_LPC, indicate);

      indicate += 1;
      indicate = indicate % NRCSTA;

/*******************************************************************/

      for (k = 0; k < CLEN; k++)
	{
	  energy[k] = act_spec[k] * act_spec[k];
	  snr_p[k] = (act_spec[k] - sb_samples_pred[k]) * (act_spec[k] - sb_samples_pred[k]);
	}

      cb_long = 0;
      for (i = 0; i < last_band; i++)
	{
	  pred_sfb_flag[i] = 1;
	  temp1 = 0.0;
	  temp2 = 0.0;
	  for (j = cb_long; j < cb_long + isfb_width[i]; j++)
	    {
	      temp1 += energy[j];
	      temp2 += snr_p[j];
	    }
	  if (temp2 < 1.e-20)
	    {
	      temp2 = 1.e-20;
	    }
	  if (temp1 != 0.0)
	    snr[i] = -10. * log10 (temp2 / temp1);
	  else
	    snr[i] = 0.0;
	  if (snr[i] <= 0.0)
	    {
	      pred_sfb_flag[i] = 0;
	      for (j = cb_long; j < cb_long + isfb_width[i]; j++)
		sb_samples_pred[j] = 0.0;
	    }
	  cb_long += isfb_width[i];
	}
      for ( ; i < NOK_BWP_PRED_SFB_MAX; i++)
	{
	  pred_sfb_flag[i] = 0;
	  for (j = cb_long; j < cb_long + isfb_width[i]; j++)
	    sb_samples_pred[j] = 0.0;
	  cb_long += isfb_width[i];
	}

      num_bit = 0.0;
      for (i = 0; i < last_band; i++)
	if (snr[i] > 0.0)
	  num_bit += snr[i] / 6. * isfb_width[i];

      pred_global_flag[0] = 1;
      if (num_bit < 50.0)
	{
	  if (debuglevel >= DEBUG_THRESHOLD)
	    fprintf (stderr, "nok_PredCalcPrediction: num_bit=%5.3f<50\n", num_bit);
	  pred_global_flag[0] = 0;
	  num_bit = 0.0;
	  for (j = 0; j < CLEN; j++)
	    sb_samples_pred[j] = 0.0;
	  for (j = 0; j < NOK_BWP_PRED_SFB_MAX; j++)
	    pred_sfb_flag[j] = 0;
	}

      if (debuglevel >= DEBUG_THRESHOLD)
	fprintf (stderr, "nok_PredCalcPrediction: bitsave %f\n", num_bit);
      if (debuglevel >= DEBUG_THRESHOLD)
	{
	  fprintf (stderr, "nok_PredCalcPrediction: pred_global_flag %d\n",
		   *pred_global_flag);
	  fprintf (stderr, "nok_PredCalcPrediction: pred_sfb_flag ");
	  for (j = 0; j < NOK_BWP_PRED_SFB_MAX; j++)
	    fprintf (stderr, "%d ", pred_sfb_flag[j]);
	  fprintf (stderr, "\n");
	}

      for (j = 0; j < CLEN; j++)
	act_spec[j] -= sb_samples_pred[j];
    }

  *side_info = LEN_PREDICTOR_DATA_PRESENT;
  if (*pred_global_flag)
    *side_info += last_band * LEN_PREDICTION_USED;

  if (*pred_global_flag)
    {	
      if (short_set > 80 && do_reset == 0)
	{
	  pred_global_prev = 1;
	  *reset_flag = 1;

	  if (debuglevel >= DEBUG_THRESHOLD)
	    fprintf (stderr, "nok_PredCalcPrediction: reset_group1 %d\n", resetting_group);

	  for (j = resetting_group; j < CLEN; j += RESET_GROUPS)
	    {
	      pred[0][j] = 63;
	      pred[1][j] = 63;
	      rg = j / 4;
	      if (indicate == 0)
		{
		  x_buffer[0][rg] = 0;
		  x_buffer[1][rg] = 0;
		  x_buffer[2][rg] = 0;
		  x_buffer[3][rg] = 0;
		}
	      if (indicate == 1)
		{
		  x_buffer[4][rg] = 0;
		  x_buffer[5][rg] = 0;
		  x_buffer[6][rg] = 0;
		}
	      if (indicate == 2)
		{
		  x_buffer[7][rg] = 0;
		  x_buffer[8][rg] = 0;
		}
	      if (indicate == 3)
		{
		  x_buffer[9][rg] = 0;
		}
	    }


	  *reset_group = resetting_group + 1;

	  resetting_group++;
	  resetting_group %= RESET_GROUPS;

	  *side_info += LEN_PREDICTOR_RESET + LEN_PREDICTOR_RESET_INDEX;
	}

      do_reset++;
      do_reset %= RESET_PERIOD;
    }
}


/**************************************************************************
  Title:	nok_bwp_encode

  Purpose:      Writes BWP parameters to the bit stream.

  Usage:	nok_bwp_encode (bs, num_of_sfb, status)

  Input:        bs         - bit stream
                num_of_sfb - number of scalefactor bands
                status	   - side_info:
			     1, if prediction not used in this frame
			     >1 otherwise
			   - pred_sfb_flag:
                             1 bit for each scalefactor band (sfb) where BWP 
                             can be used indicating whether BWP is switched 
                             on (1) /off (0) in that sfb.
			   - global_pred_flag:
			     1, if prediction used on some sfb's
			     0 otherwise
			   - reset_flag:
			     1, if reset has been performed
			     0 otherwise
			   - reset_group:
			     number of the group where reset was done

  Output:	-

  References:	1.) BsPutBit

  Explanation:  -

  Author(s):	Mikko Suonio, Juha Ojanper