Beispiel #1
0
def main(inwavfile, outmp3file, bitrate):
    """ENCODER MAIN FUNCTION"""

    # Read WAVE file and set MPEG encoder parameters
    input_buffer = WavRead(inwavfile)
    params = EncoderParameters(input_buffer.fs, input_buffer.nch, bitrate)

    # Read baseband filter samples
    baseband_filter = prototype_filter().astype = ('float32')

    subband_samples = np.zeros((params.nch, N_SUBBANDS, FRAMES_PER_BLOCK),
                               dtype='float32')

    # Main loop executing until all samples have been processed
    while input_buffer.nprocessed_samples < input_buffer.nsamples:

        # In each block 12 frames are processed, which equals 12x32=384 samples per block
        for frm in range(FRAMES_PER_BLOCK):
            samples_read = input_buffer.read_sample(SHIFT_SIZE)

            # Perform zero padding if all samples have been read
            if samples_read < SHIFT_SIZE:
                input_buffer.audio[ch].insert(
                    np.zeros(SHIFT_SIZE - samples_read))

        # Filtering = dot product with reverse buffer
        for ch in range(params.nch):
            subband_samples[ch, :, frm] = subband_filtering(
                input_buffer.audio[ch].reversed(), baseband_filter)

        # Declaring arrays for keeping table indices of calculated scalefactors and bits allocated in subbands.
        # Number of bits allocated in subband is either 0 or in range [2,15]
        sfcindices = np.zeros((params.nch, N_SUBBANDS), dtype='uint8')
        subband_bit_allocation = np.zeros((params.nch, N_SUBBANDS),
                                          dtype='uint8')
        smr = np.zeros((params.nch, N_SUBBANDS), dtype='float32')

        # Finding scale factors, psychoacoustic model and bit allocation calculation for subbands. Although scaling is done later,
        # its result is necessary for the psychoacoustic model and calculation of  sound pressure levels.
        for ch in range(params.nch):
            sfcindices[ch, :] = get_scalefactors(subband_samples[ch, :, :],
                                                 params.table.scalefactor)
            subband_bit_allocation[ch, :] = psycho.model1(
                input_buffer.audio[ch].ordered(), params, sfindices)

        subband_samples_quantized = np.zeros(subband_samples.shape,
                                             dtype='uint32')
        for ch in range(params.nch):
            for sb in range(N_SUBBANDS):
                QCa = params.table.qca[subband_bit_allocation[ch, sb] - 2]
                QCb = params.table.qcb[subband_bit_allocation[ch, sb] - 2]
                scf = params.table.scalefactor[sfcindices[ch, sb]]
                ba = subband_bit_allocation[ch, sb]
                for ind in (FRAMES_PER_BLOCK):
                    subband_samples_quantized[ch, sb, ind] = quantization(
                        subband_samples[ch, sb, ind], scf, ba, QCa, QCb)

        # Fromatting output bitstream and appending it to the output file
        bitstream_formatting(outmp3file, params, subband_bit_allocation,
                             sfcindices, subband_samples_quantized)
def encode(input_buffer,params,outmp3file,**kwargs):
  """Encode the rest of the file. If uniform=true, another file with uniform quantization is created."""
  
  uniform = kwargs.get('uniform', False)
  if uniform:
    params_uniform = EncoderParameters(input_buffer.fs, input_buffer.nch, params.bitrate)
    uniform_bit_allocation = np.zeros((params.nch, N_SUBBANDS), dtype='uint8')
    for ch in range(params.nch):
      uniform_bit_allocation[ch,:] = psychoacoustic.smr_bit_allocation(params, np.zeros(N_SUBBANDS))


  # Read baseband filter samples
  baseband_filter = filter_coeffs()
  # Allocate space for 32 subband filters of length 512.
  filterbank = np.zeros((N_SUBBANDS, FRAME_SIZE), dtype='float32')
  # Perform modulation.
  for sb in range(N_SUBBANDS):
    for n in range(FRAME_SIZE):
      filterbank[sb,n] = baseband_filter[n] * np.cos((2 * sb + 1) * (n - 16 ) * np.pi / 64)

      

  subband_samples = np.zeros((params.nch, N_SUBBANDS, FRAMES_PER_BLOCK), dtype='float32') 

  # Main loop, executing until all samples have been processed.
  while input_buffer.nprocessed_samples < input_buffer.nsamples:

    # In each block 12 frames are processed, which equals 12x32=384 new samples per block.
    for frm in range(FRAMES_PER_BLOCK):
      samples_read = input_buffer.read_samples(SHIFT_SIZE)

      # If all samples have been read, perform zero padding.
      if samples_read < SHIFT_SIZE:
        for ch in range(params.nch):
          input_buffer.audio[ch].insert(np.zeros(SHIFT_SIZE - samples_read))

      # Filtering = dot product with reversed buffer.
      for ch in range(params.nch):
        subband_samples[ch,:,frm] = np.dot(filterbank, input_buffer.audio[ch].reversed())
                   

    # Declaring arrays for keeping table indices of calculated scalefactors and bits allocated in subbands.
    scfindices = np.zeros((params.nch, N_SUBBANDS), dtype='uint8')
    subband_bit_allocation = np.zeros((params.nch, N_SUBBANDS), dtype='uint8') 

    
    # Finding scale factors, psychoacoustic model and bit allocation calculation for subbands. Although 
    # scaling is done later, its result is necessary for the psychoacoustic model and calculation of 
    # sound pressure levels.
    for ch in range(params.nch):
      scfindices[ch,:] = get_scalefactors(subband_samples[ch,:,:], params.table.scalefactor)
      subband_bit_allocation[ch,:] = psychoacoustic.model1(input_buffer.audio[ch].ordered(), params, scfindices)


    # Scaling subband samples with determined scalefactors.
    for ind in range(FRAMES_PER_BLOCK):
      subband_samples[:,:,ind] /= params.table.scalefactor[scfindices]
  
    if uniform:
      subband_samples_uniform = np.copy(subband_samples)


    # Subband samples quantization. Multiplication with coefficients 'a' and adding coefficients 'b' is
    # defined in the ISO standard.
    subband_samples_quantized = subband_samples
    for ch in range(params.nch):
      for sb in range(N_SUBBANDS):
        if subband_bit_allocation[ch,sb] != 0:
          subband_samples[ch,sb,:] *= params.table.qca[subband_bit_allocation[ch,sb] - 2]
          subband_samples[ch,sb,:] += params.table.qcb[subband_bit_allocation[ch,sb] - 2]
          subband_samples[ch,sb,:] *= 1<<subband_bit_allocation[ch,sb] - 1
  

    # Since subband_samples is a float array, it needs to be cast to unsigned integers.
    subband_samples_quantized = subband_samples.astype('uint32')


    # Forming output bitsream and appending it to the output file.
    bitstream_formatting(outmp3file,
                         params,
                         subband_bit_allocation,
                         scfindices,
                         subband_samples_quantized)



    if uniform:
    
      for ch in range(params.nch):
        for sb in range(N_SUBBANDS):
          if uniform_bit_allocation[ch,sb] != 0:
            subband_samples_uniform[ch,sb,:] *= params_uniform.table.qca[uniform_bit_allocation[ch,sb] - 2]
            subband_samples_uniform[ch,sb,:] += params_uniform.table.qcb[uniform_bit_allocation[ch,sb] - 2]
            subband_samples_uniform[ch,sb,:] *= 1<<uniform_bit_allocation[ch,sb] - 1
      
      subband_samples_uniform = subband_samples_uniform.astype('uint32')


      bitstream_formatting(outmp3file[:-4] + '_uniform' + outmp3file[-4:],
                         params_uniform,
                         uniform_bit_allocation,
                         scfindices,
                         subband_samples_uniform)
Beispiel #3
0
def main(inwavfile, outmp3file, bitrate):
    """Encoder main function."""

    #inwavfile  = "../samples/sinestereo.wav"
    #outmp3file = "../samples/sinestereo.mp3"
    #bitrate = 320

    # Read WAVE file and set MPEG encoder parameters.
    input_buffer = WavRead(inwavfile)
    params = EncoderParameters(input_buffer.fs, input_buffer.nch, bitrate)

    # Subband filter calculation from baseband prototype.
    # Very detailed analysis of MP3 subband filtering available at
    # http://cnx.org/content/m32148/latest/?collection=col11121/latest

    # Read baseband filter samples
    """
  Prototype-filter
  """
    baseband_filter = prototype_filter.prototype_filter().astype('float32')

    subband_samples = np.zeros((params.nch, N_SUBBANDS, FRAMES_PER_BLOCK),
                               dtype='float32')

    # Main loop, executing until all samples have been processed.
    while input_buffer.nprocessed_samples < input_buffer.nsamples:

        # In each block 12 frames are processed, which equals 12x32=384 new samples per block.
        for frm in range(FRAMES_PER_BLOCK):
            samples_read = input_buffer.read_samples(SHIFT_SIZE)

            # If all samples have been read, perform zero padding.
            if samples_read < SHIFT_SIZE:
                for ch in range(params.nch):
                    input_buffer.audio[ch].insert(
                        np.zeros(SHIFT_SIZE - samples_read))

            # Filtering = dot product with reversed buffer.
            """
       Subband filtering
      """
            for ch in range(params.nch):
                subband_samples[ch, :,
                                frm] = subband_filtering.subband_filtering(
                                    input_buffer.audio[ch].reversed(),
                                    baseband_filter)

        # Declaring arrays for keeping table indices of calculated scalefactors and bits allocated in subbands.
        # Number of bits allocated in subband is either 0 or in range [2,15].
        scfindices = np.zeros((params.nch, N_SUBBANDS), dtype='uint8')
        subband_bit_allocation = np.zeros((params.nch, N_SUBBANDS),
                                          dtype='uint8')
        smr = np.zeros((params.nch, N_SUBBANDS), dtype='float32')

        # Finding scale factors, psychoacoustic model and bit allocation calculation for subbands. Although
        # scaling is done later, its result is necessary for the psychoacoustic model and calculation of
        # sound pressure levels.
        for ch in range(params.nch):
            scfindices[ch, :] = get_scalefactors(subband_samples[ch, :, :],
                                                 params.table.scalefactor)
            subband_bit_allocation[ch, :] = psycho.model1(
                input_buffer.audio[ch].ordered(), params, scfindices)
        """
    Quantization
    """
        subband_samples_quantized = np.zeros(subband_samples.shape,
                                             dtype='uint32')
        for ch in range(params.nch):
            for sb in range(N_SUBBANDS):
                QCa = params.table.qca[subband_bit_allocation[ch, sb] - 2]
                QCb = params.table.qcb[subband_bit_allocation[ch, sb] - 2]
                scf = params.table.scalefactor[scfindices[ch, sb]]
                ba = subband_bit_allocation[ch, sb]
                for ind in range(FRAMES_PER_BLOCK):
                    subband_samples_quantized[ch, sb,
                                              ind] = quantization.quantization(
                                                  subband_samples[ch, sb, ind],
                                                  scf, ba, QCa, QCb)

        # Forming output bitsream and appending it to the output file.
        bitstream_formatting(outmp3file, params, subband_bit_allocation,
                             scfindices, subband_samples_quantized)
Beispiel #4
0
def main(inwavfile, outmp3file, bitrate):
    """Encoder main function."""

    #inwavfile  = "../samples/sinestereo.wav"
    #outmp3file = "../samples/sinestereo.mp3"
    #bitrate = 320

    # Read WAVE file and set MPEG encoder parameters.
    input_buffer = WavRead(inwavfile)
    params = EncoderParameters(input_buffer.fs, input_buffer.nch, bitrate)

    # Subband filter calculation from baseband prototype.
    # Very detailed analysis of MP3 subband filtering available at
    # http://cnx.org/content/m32148/latest/?collection=col11121/latest

    # Read baseband filter samples
    baseband_filter = filter_coeffs()
    # Allocate space for 32 subband filters of length 512.
    filterbank = np.zeros((N_SUBBANDS, FRAME_SIZE), dtype='float32')
    # Perform modulation.
    for sb in range(N_SUBBANDS):
        for n in range(FRAME_SIZE):
            filterbank[sb, n] = baseband_filter[n] * np.cos(
                (2 * sb + 1) * (n - 16) * np.pi / 64)

    subband_samples = np.zeros((params.nch, N_SUBBANDS, FRAMES_PER_BLOCK),
                               dtype='float32')

    # Main loop, executing until all samples have been processed.
    while input_buffer.nprocessed_samples < input_buffer.nsamples:

        # In each block 12 frames are processed, which equals 12x32=384 new samples per block.
        for frm in range(FRAMES_PER_BLOCK):
            samples_read = input_buffer.read_samples(SHIFT_SIZE)

            # If all samples have been read, perform zero padding.
            if samples_read < SHIFT_SIZE:
                for ch in range(params.nch):
                    input_buffer.audio[ch].insert(
                        np.zeros(SHIFT_SIZE - samples_read))

            # Filtering = dot product with reversed buffer.
            for ch in range(params.nch):
                subband_samples[ch, :, frm] = np.dot(
                    filterbank, input_buffer.audio[ch].reversed())

        # Declaring arrays for keeping table indices of calculated scalefactors and bits allocated in subbands.
        # Number of bits allocated in subband is either 0 or in range [2,15].
        scfindices = np.zeros((params.nch, N_SUBBANDS), dtype='uint8')
        subband_bit_allocation = np.zeros((params.nch, N_SUBBANDS),
                                          dtype='uint8')
        smr = np.zeros((params.nch, N_SUBBANDS), dtype='float32')

        # Finding scale factors, psychoacoustic model and bit allocation calculation for subbands. Although
        # scaling is done later, its result is necessary for the psychoacoustic model and calculation of
        # sound pressure levels.
        for ch in range(params.nch):
            scfindices[ch, :] = get_scalefactors(subband_samples[ch, :, :],
                                                 params.table.scalefactor)
            subband_bit_allocation[ch, :] = psycho.model1(
                input_buffer.audio[ch].ordered(), params, scfindices)

        # Scaling subband samples with determined scalefactors.
        for ind in range(FRAMES_PER_BLOCK):
            subband_samples[:, :, ind] /= params.table.scalefactor[scfindices]

        # Subband samples quantization. Multiplication with coefficients 'a' and adding coefficients 'b' is
        # defined in the ISO standard.
        for ch in range(params.nch):
            for sb in range(N_SUBBANDS):
                if subband_bit_allocation[ch, sb] != 0:
                    subband_samples[ch, sb, :] *= params.table.qca[
                        subband_bit_allocation[ch, sb] - 2]
                    subband_samples[ch, sb, :] += params.table.qcb[
                        subband_bit_allocation[ch, sb] - 2]
                    subband_samples[
                        ch, sb, :] *= 1 << subband_bit_allocation[ch, sb] - 1

        # Since subband_samples is a float array, it needs to be cast to unsigned integers.
        subband_samples_quantized = subband_samples.astype('uint32')

        # Forming output bitsream and appending it to the output file.
        bitstream_formatting(outmp3file, params, subband_bit_allocation,
                             scfindices, subband_samples_quantized)
Beispiel #5
0
def main(inwavfile, outmp3file, bitrate):
  """Encoder main function."""

  #inwavfile  = "../samples/sinestereo.wav"
  #outmp3file = "../samples/sinestereo.mp3"
  #bitrate = 320
  
  
  # Read WAVE file and set MPEG encoder parameters.
  input_buffer = WavRead(inwavfile)
  params = EncoderParameters(input_buffer.fs, input_buffer.nch, bitrate)
  

  
  # Subband filter calculation from baseband prototype.
  # Very detailed analysis of MP3 subband filtering available at
  # http://cnx.org/content/m32148/latest/?collection=col11121/latest

  # Read baseband filter samples
  """
  ASSIGNMENT 2
  """
  baseband_filter = assignment2.prototype_filter().astype('float32')

  subband_samples = np.zeros((params.nch, N_SUBBANDS, FRAMES_PER_BLOCK), dtype='float32') 

  # Main loop, executing until all samples have been processed.
  while input_buffer.nprocessed_samples < input_buffer.nsamples:

    # In each block 12 frames are processed, which equals 12x32=384 new samples per block.
    for frm in range(FRAMES_PER_BLOCK):
      samples_read = input_buffer.read_samples(SHIFT_SIZE)

      # If all samples have been read, perform zero padding.
      if samples_read < SHIFT_SIZE:
        for ch in range(params.nch):
          input_buffer.audio[ch].insert(np.zeros(SHIFT_SIZE - samples_read))

      # Filtering = dot product with reversed buffer.
      """
      ASSIGNMENT 3 : Subband filtering
      """
      for ch in range(params.nch):
        subband_samples[ch,:,frm] = assignment3.subband_filtering(input_buffer.audio[ch].reversed(), baseband_filter)
      
    # Declaring arrays for keeping table indices of calculated scalefactors and bits allocated in subbands.
    # Number of bits allocated in subband is either 0 or in range [2,15].
    scfindices = np.zeros((params.nch, N_SUBBANDS), dtype='uint8')
    subband_bit_allocation = np.zeros((params.nch, N_SUBBANDS), dtype='uint8') 
    smr = np.zeros((params.nch, N_SUBBANDS), dtype='float32')

    
    # Finding scale factors, psychoacoustic model and bit allocation calculation for subbands. Although 
    # scaling is done later, its result is necessary for the psychoacoustic model and calculation of 
    # sound pressure levels.
    for ch in range(params.nch):
      scfindices[ch,:] = get_scalefactors(subband_samples[ch,:,:], params.table.scalefactor)
      subband_bit_allocation[ch,:] = psycho.model1(input_buffer.audio[ch].ordered(), params,scfindices)

    """
    ASSIGNMENT 4 : Quantization
    """
    subband_samples_quantized = np.zeros(subband_samples.shape, dtype='uint32')
    for ch in range(params.nch):
      for sb in range(N_SUBBANDS):
        QCa = params.table.qca[subband_bit_allocation[ch,sb]-2]
        QCb = params.table.qcb[subband_bit_allocation[ch,sb]-2]
        scf = params.table.scalefactor[scfindices[ch,sb]]
        ba = subband_bit_allocation[ch,sb]
        for ind in range(FRAMES_PER_BLOCK):
          subband_samples_quantized[ch,sb,ind] = assignment4.quantization(subband_samples[ch,sb,ind], scf, ba, QCa, QCb)


    # Forming output bitsream and appending it to the output file.
    bitstream_formatting(outmp3file,
                         params,
                         subband_bit_allocation,
                         scfindices,
                         subband_samples_quantized)
Beispiel #6
0
def main(inwavfile, outmp3file, bitrate):
  """Encoder main function."""

  #inwavfile  = "../samples/sinestereo.wav"
  #outmp3file = "../samples/sinestereo.mp3"
  #bitrate = 320
  
  
  # Read WAVE file and set MPEG encoder parameters.
  input_buffer = WavRead(inwavfile)
  params = EncoderParameters(input_buffer.fs, input_buffer.nch, bitrate)
  

  
  # Subband filter calculation from baseband prototype.
  # Very detailed analysis of MP3 subband filtering available at
  # http://cnx.org/content/m32148/latest/?collection=col11121/latest

  # Read baseband filter samples
  baseband_filter = filter_coeffs()
  # Allocate space for 32 subband filters of length 512.
  filterbank = np.zeros((N_SUBBANDS, FRAME_SIZE), dtype='float32')
  # Perform modulation.
  for sb in range(N_SUBBANDS):
    for n in range(FRAME_SIZE):
      filterbank[sb,n] = baseband_filter[n] * np.cos((2 * sb + 1) * (n - 16) * np.pi / 64)

      

  subband_samples = np.zeros((params.nch, N_SUBBANDS, FRAMES_PER_BLOCK), dtype='float32') 

  # Main loop, executing until all samples have been processed.
  while input_buffer.nprocessed_samples < input_buffer.nsamples:

    # In each block 12 frames are processed, which equals 12x32=384 new samples per block.
    for frm in range(FRAMES_PER_BLOCK):
      samples_read = input_buffer.read_samples(SHIFT_SIZE)

      # If all samples have been read, perform zero padding.
      if samples_read < SHIFT_SIZE:
        for ch in range(params.nch):
          input_buffer.audio[ch].insert(np.zeros(SHIFT_SIZE - samples_read))

      # Filtering = dot product with reversed buffer.
      for ch in range(params.nch):
        subband_samples[ch,:,frm] = np.dot(filterbank, input_buffer.audio[ch].reversed())
                   

    # Declaring arrays for keeping table indices of calculated scalefactors and bits allocated in subbands.
    # Number of bits allocated in subband is either 0 or in range [2,15].
    scfindices = np.zeros((params.nch, N_SUBBANDS), dtype='uint8')
    subband_bit_allocation = np.zeros((params.nch, N_SUBBANDS), dtype='uint8') 
    smr = np.zeros((params.nch, N_SUBBANDS), dtype='float32')

    
    # Finding scale factors, psychoacoustic model and bit allocation calculation for subbands. Although 
    # scaling is done later, its result is necessary for the psychoacoustic model and calculation of 
    # sound pressure levels.
    for ch in range(params.nch):
      scfindices[ch,:] = get_scalefactors(subband_samples[ch,:,:], params.table.scalefactor)
      subband_bit_allocation[ch,:] = psycho.model1(input_buffer.audio[ch].ordered(), params,scfindices)


    # Scaling subband samples with determined scalefactors.
    for ind in range(FRAMES_PER_BLOCK):
      subband_samples[:,:,ind] /= params.table.scalefactor[scfindices]
  

    # Subband samples quantization. Multiplication with coefficients 'a' and adding coefficients 'b' is
    # defined in the ISO standard.
    for ch in range(params.nch):
      for sb in range(N_SUBBANDS):
        if subband_bit_allocation[ch,sb] != 0:
          subband_samples[ch,sb,:] *= params.table.qca[subband_bit_allocation[ch,sb] - 2]
          subband_samples[ch,sb,:] += params.table.qcb[subband_bit_allocation[ch,sb] - 2]
          subband_samples[ch,sb,:] *= 1<<subband_bit_allocation[ch,sb] - 1
  

    # Since subband_samples is a float array, it needs to be cast to unsigned integers.
    subband_samples_quantized = subband_samples.astype('uint32')


    # Forming output bitsream and appending it to the output file.
    bitstream_formatting(outmp3file,
                         params,
                         subband_bit_allocation,
                         scfindices,
                         subband_samples_quantized)
def encode(input_buffer, params, outmp3file, **kwargs):
    """Encode the rest of the file. If uniform=true, another file with uniform quantization is created."""

    uniform = kwargs.get('uniform', False)
    if uniform:
        params_uniform = EncoderParameters(input_buffer.fs, input_buffer.nch,
                                           params.bitrate)
        uniform_bit_allocation = np.zeros((params.nch, N_SUBBANDS),
                                          dtype='uint8')
        for ch in range(params.nch):
            uniform_bit_allocation[ch, :] = psychoacoustic.smr_bit_allocation(
                params, np.zeros(N_SUBBANDS))

    # Read baseband filter samples
    baseband_filter = filter_coeffs()
    # Allocate space for 32 subband filters of length 512.
    filterbank = np.zeros((N_SUBBANDS, FRAME_SIZE), dtype='float32')
    # Perform modulation.
    for sb in range(N_SUBBANDS):
        for n in range(FRAME_SIZE):
            filterbank[sb, n] = baseband_filter[n] * np.cos(
                (2 * sb + 1) * (n - 16) * np.pi / 64)

    subband_samples = np.zeros((params.nch, N_SUBBANDS, FRAMES_PER_BLOCK),
                               dtype='float32')

    # Main loop, executing until all samples have been processed.
    while input_buffer.nprocessed_samples < input_buffer.nsamples:

        # In each block 12 frames are processed, which equals 12x32=384 new samples per block.
        for frm in range(FRAMES_PER_BLOCK):
            samples_read = input_buffer.read_samples(SHIFT_SIZE)

            # If all samples have been read, perform zero padding.
            if samples_read < SHIFT_SIZE:
                for ch in range(params.nch):
                    input_buffer.audio[ch].insert(
                        np.zeros(SHIFT_SIZE - samples_read))

            # Filtering = dot product with reversed buffer.
            for ch in range(params.nch):
                subband_samples[ch, :, frm] = np.dot(
                    filterbank, input_buffer.audio[ch].reversed())

        # Declaring arrays for keeping table indices of calculated scalefactors and bits allocated in subbands.
        scfindices = np.zeros((params.nch, N_SUBBANDS), dtype='uint8')
        subband_bit_allocation = np.zeros((params.nch, N_SUBBANDS),
                                          dtype='uint8')

        # Finding scale factors, psychoacoustic model and bit allocation calculation for subbands. Although
        # scaling is done later, its result is necessary for the psychoacoustic model and calculation of
        # sound pressure levels.
        for ch in range(params.nch):
            scfindices[ch, :] = get_scalefactors(subband_samples[ch, :, :],
                                                 params.table.scalefactor)
            subband_bit_allocation[ch, :] = psychoacoustic.model1(
                input_buffer.audio[ch].ordered(), params, scfindices)

        # Scaling subband samples with determined scalefactors.
        for ind in range(FRAMES_PER_BLOCK):
            subband_samples[:, :, ind] /= params.table.scalefactor[scfindices]

        if uniform:
            subband_samples_uniform = np.copy(subband_samples)

        # Subband samples quantization. Multiplication with coefficients 'a' and adding coefficients 'b' is
        # defined in the ISO standard.
        subband_samples_quantized = subband_samples
        for ch in range(params.nch):
            for sb in range(N_SUBBANDS):
                if subband_bit_allocation[ch, sb] != 0:
                    subband_samples[ch, sb, :] *= params.table.qca[
                        subband_bit_allocation[ch, sb] - 2]
                    subband_samples[ch, sb, :] += params.table.qcb[
                        subband_bit_allocation[ch, sb] - 2]
                    subband_samples[
                        ch, sb, :] *= 1 << subband_bit_allocation[ch, sb] - 1

        # Since subband_samples is a float array, it needs to be cast to unsigned integers.
        subband_samples_quantized = subband_samples.astype('uint32')

        # Forming output bitsream and appending it to the output file.
        bitstream_formatting(outmp3file, params, subband_bit_allocation,
                             scfindices, subband_samples_quantized)

        if uniform:

            for ch in range(params.nch):
                for sb in range(N_SUBBANDS):
                    if uniform_bit_allocation[ch, sb] != 0:
                        subband_samples_uniform[
                            ch, sb, :] *= params_uniform.table.qca[
                                uniform_bit_allocation[ch, sb] - 2]
                        subband_samples_uniform[
                            ch, sb, :] += params_uniform.table.qcb[
                                uniform_bit_allocation[ch, sb] - 2]
                        subband_samples_uniform[
                            ch,
                            sb, :] *= 1 << uniform_bit_allocation[ch, sb] - 1

            subband_samples_uniform = subband_samples_uniform.astype('uint32')

            bitstream_formatting(
                outmp3file[:-4] + '_uniform' + outmp3file[-4:], params_uniform,
                uniform_bit_allocation, scfindices, subband_samples_uniform)