예제 #1
0
void Trimmer::CopyConstantSubframe(BitIStream& bis, BitOStream& bos, FLACFrameHeader * fh, FLACMetaStreamInfo * msi)
{
	size_t bitsCount = GetBitsPerSample(fh, msi);
	uint64_t constant = 0;
	bis.ReadInteger(&constant, bitsCount);
	bos.WriteInteger(constant, bitsCount);
}
예제 #2
0
/*--------------------------------------------------------------------------------*/
bool ADMRIFFFile::CreateExtraChunks()
{
  bool success = true;

  if (adm)
  {
    RIFFChunk *chunk;
    uint64_t  chnalen;
    uint8_t   *chna;
    uint_t i, nchannels = GetChannels();

    success = true;

    for (i = 0; i < nchannels; i++)
    {
      ADMAudioTrack *track;

      // create chna track data
      if ((track = adm->CreateTrack(i)) != NULL)
      {
        track->SetSampleRate(GetSampleRate());
        track->SetBitDepth(GetBitsPerSample());
      }
    }

    if (!admfile.empty())
    {
      // create ADM structure (content and objects from file)
      if (adm->CreateFromFile(admfile.c_str()))
      {
        // can prepare cursors now since all objects have been created
        PrepareCursors();
      }
      else
      {
        BBCERROR("Unable to create ADM structure from '%s'", admfile.c_str());
        success = false;
      }
    }

    // get ADM object to create chna chunk
    if ((chna = adm->GetChna(chnalen)) != NULL)
    {
      // and add it to the RIFF file
      if ((chunk = AddChunk(chna_ID)) != NULL)
      {
        success &= chunk->CreateChunkData(chna, chnalen);
      }
      else BBCERROR("Failed to add chna chunk");

      // don't need the raw data any more
      delete[] chna;
    }
    else BBCERROR("No chna data available");

    success &= (AddChunk(axml_ID) != NULL);
  }

  return success;
}
예제 #3
0
int AudioFormat_YM::GetPosition()
	{
	if (!ymFile_)
		{
		return 0;
		}
	return (int)((ymFile_->getPos()/1000.0f)*GetChannels()*(GetBitsPerSample()/8)*GetFrequency());
	}
예제 #4
0
void AudioFormat_YM::SetPosition(int position)
	{
	if (!ymFile_)
		{
		return;
		}
	float sampleSize=(float)(GetChannels()*GetFrequency()*(GetBitsPerSample()/8));
	float time=position/sampleSize;
	ymFile_->setMusicTime((int)(time*1000.0f));
	}
int COMXAudioCodecOMX::GetData(BYTE** dst, double &dts, double &pts)
{
    if (!m_bGotFrame)
        return 0;
    int inLineSize, outLineSize;
    /* input audio is aligned */
    int inputSize = m_dllAvUtil.av_samples_get_buffer_size(&inLineSize, m_pCodecContext->channels, m_pFrame1->nb_samples, m_pCodecContext->sample_fmt, 0);
    /* output audio will be packed */
    int outputSize = m_dllAvUtil.av_samples_get_buffer_size(&outLineSize, m_pCodecContext->channels, m_pFrame1->nb_samples, m_desiredSampleFormat, 1);

    if (!m_bNoConcatenate && m_iBufferOutputUsed && (int)m_frameSize != outputSize)
    {
        CLog::Log(LOGERROR, "COMXAudioCodecOMX::GetData Unexpected change of size (%d->%d)", m_frameSize, outputSize);
        m_bNoConcatenate = true;
    }

    // if this buffer won't fit then flush out what we have
    int desired_size = AUDIO_DECODE_OUTPUT_BUFFER * (m_pCodecContext->channels * GetBitsPerSample()) >> (rounded_up_channels_shift[m_pCodecContext->channels] + 4);
    if (m_iBufferOutputUsed && (m_iBufferOutputUsed + outputSize > desired_size || m_bNoConcatenate))
    {
        int ret = m_iBufferOutputUsed;
        m_iBufferOutputUsed = 0;
        m_bNoConcatenate = false;
        dts = m_dts;
        pts = m_pts;
        *dst = m_pBufferOutput;
        return ret;
    }
    m_frameSize = outputSize;

    if (m_iBufferOutputAlloced < m_iBufferOutputUsed + outputSize)
    {
        m_pBufferOutput = (BYTE*)m_dllAvUtil.av_realloc(m_pBufferOutput, m_iBufferOutputUsed + outputSize + FF_INPUT_BUFFER_PADDING_SIZE);
        m_iBufferOutputAlloced = m_iBufferOutputUsed + outputSize;
    }

    /* need to convert format */
    if(m_pCodecContext->sample_fmt != m_desiredSampleFormat)
    {
        if(m_pConvert && (m_pCodecContext->sample_fmt != m_iSampleFormat || m_channels != m_pCodecContext->channels))
        {
            m_dllSwResample.swr_free(&m_pConvert);
            m_channels = m_pCodecContext->channels;
        }

        if(!m_pConvert)
        {
            m_iSampleFormat = m_pCodecContext->sample_fmt;
            m_pConvert = m_dllSwResample.swr_alloc_set_opts(NULL,
                         m_dllAvUtil.av_get_default_channel_layout(m_pCodecContext->channels),
                         m_desiredSampleFormat, m_pCodecContext->sample_rate,
                         m_dllAvUtil.av_get_default_channel_layout(m_pCodecContext->channels),
                         m_pCodecContext->sample_fmt, m_pCodecContext->sample_rate,
                         0, NULL);

            if(!m_pConvert || m_dllSwResample.swr_init(m_pConvert) < 0)
            {
                CLog::Log(LOGERROR, "COMXAudioCodecOMX::Decode - Unable to initialise convert format %d to %d", m_pCodecContext->sample_fmt, m_desiredSampleFormat);
                return 0;
            }
        }

        /* use unaligned flag to keep output packed */
        uint8_t *out_planes[m_pCodecContext->channels];
        if(m_dllAvUtil.av_samples_fill_arrays(out_planes, NULL, m_pBufferOutput + m_iBufferOutputUsed, m_pCodecContext->channels, m_pFrame1->nb_samples, m_desiredSampleFormat, 1) < 0 ||
                m_dllSwResample.swr_convert(m_pConvert, out_planes, m_pFrame1->nb_samples, (const uint8_t **)m_pFrame1->data, m_pFrame1->nb_samples) < 0)
        {
            CLog::Log(LOGERROR, "COMXAudioCodecOMX::Decode - Unable to convert format %d to %d", (int)m_pCodecContext->sample_fmt, m_desiredSampleFormat);
            outputSize = 0;
        }
    }
    else
    {
        /* copy to a contiguous buffer */
        uint8_t *out_planes[m_pCodecContext->channels];
        if (m_dllAvUtil.av_samples_fill_arrays(out_planes, NULL, m_pBufferOutput + m_iBufferOutputUsed, m_pCodecContext->channels, m_pFrame1->nb_samples, m_desiredSampleFormat, 1) < 0 ||
                m_dllAvUtil.av_samples_copy(out_planes, m_pFrame1->data, 0, 0, m_pFrame1->nb_samples, m_pCodecContext->channels, m_desiredSampleFormat) < 0 )
        {
            outputSize = 0;
        }
    }
    m_bGotFrame = false;

    if (m_bFirstFrame)
    {
        CLog::Log(LOGDEBUG, "COMXAudioCodecOMX::GetData size=%d/%d line=%d/%d buf=%p, desired=%d", inputSize, outputSize, inLineSize, outLineSize, m_pBufferOutput, desired_size);
        m_bFirstFrame = false;
    }
    m_iBufferOutputUsed += outputSize;
    return 0;
}
예제 #6
0
uint16_t Trimmer::GetWarmUpSamplesBitSize(FLACFrameHeader * fh, FLACMetaStreamInfo * msi, FLACSubframeHeader * sfh)
{
	return GetBitsPerSample(fh, msi) * GetPredictorOrder(sfh);
}
예제 #7
0
uint16_t Trimmer::GetUnencSubblockBitSize(FLACFrameHeader * fh, FLACMetaStreamInfo * msi)
{
	return GetBlockSize(fh, msi) * GetBitsPerSample(fh, msi);
}
예제 #8
0
void Trimmer::CopyRiceResidual(BitIStream& bis, BitOStream& bos, FLACFrameHeader * fh, FLACMetaStreamInfo * msi, FLACSubframeHeader * sfh)
{
	uint8_t partitionOrder = 0;
	bis.ReadInteger(&partitionOrder, 4);
	bos.WriteInteger(partitionOrder, 4);

	size_t partitionsCount = pow(2, partitionOrder);
	
	
	for (size_t partitionN = 0; partitionN < partitionsCount; partitionN++)
	{
		uint8_t riceParameter = 0;
		bis.ReadInteger(&riceParameter, 4);
		bos.WriteInteger(riceParameter, 4);

		
		bool isUnencoded = false;
		uint8_t unencBitsPerSample = 0;
		if (riceParameter == 0b1111) 
		{
			isUnencoded = true;
			bis.ReadInteger(&unencBitsPerSample, 5);
			bos.WriteInteger(unencBitsPerSample, 5);
		}
		
		size_t samplesCount = 0;
		if (partitionOrder == 0)
		{
			samplesCount = GetBlockSize(fh, msi) - GetPredictorOrder(sfh);
		}
		else if (partitionN != 0) // this is not first partition of subframe ?
		{
			samplesCount = GetBlockSize(fh, msi) / pow(2, partitionOrder);
		}
		else
		{
			samplesCount = GetBlockSize(fh, msi) / pow(2, partitionOrder) - GetPredictorOrder(sfh);
		}
		
		size_t residualBitSize = 0;

		if (isUnencoded)
		{
			residualBitSize = samplesCount * unencBitsPerSample;
		}
		else 
		{
			residualBitSize = samplesCount * GetBitsPerSample(fh, msi);
		}
	/*	uint32_t unary = 0;
		bis.ReadUnary(&unary);
		bos.WriteUnary(unary);
		cout << unary << endl;*/

		for (size_t i = 0; i < samplesCount; i++)
		{
			uint8_t sign = 0;
			bis.ReadInteger(&sign, 1);
			bos.WriteInteger(sign, 1);
			uint32_t unary = 0;
			bis.ReadUnary(&unary);
			bos.WriteUnary(unary);

			uint32_t resudial = 0;
			if (riceParameter != 0)
			{
				bis.ReadInteger(&resudial, riceParameter);
				bos.WriteInteger(resudial, riceParameter);
			}

		}
	//	CopyBits(bis, bos, residualBitSize);	
	}

}