Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 11746099 authored by Andy Hung's avatar Andy Hung Committed by Android (Google) Code Review
Browse files

Merge changes from topic "flac float codec"

* changes:
  FlacEncoder: Enable float support
  FlacDecoder: Enable float support
parents 435ba2e2 1188a051
Loading
Loading
Loading
Loading
+4 −1
Original line number Diff line number Diff line
@@ -23,5 +23,8 @@ cc_library_shared {

    srcs: ["C2SoftFlacEnc.cpp"],

    static_libs: ["libFLAC"],
    static_libs: [
        "libaudioutils",
        "libFLAC",
    ],
}
+20 −7
Original line number Diff line number Diff line
@@ -83,8 +83,21 @@ public:
                DefineParam(mInputMaxBufSize, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE)
                .withConstValue(new C2StreamMaxBufferSizeInfo::input(0u, 32768))
                .build());

        addParameter(
                DefineParam(mPcmEncodingInfo, C2_PARAMKEY_PCM_ENCODING)
                .withDefault(new C2StreamPcmEncodingInfo::output(0u, C2Config::PCM_16))
                .withFields({C2F(mPcmEncodingInfo, value).oneOf({
                     C2Config::PCM_16,
                     // C2Config::PCM_8,
                     C2Config::PCM_FLOAT})
                })
                .withSetter((Setter<decltype(*mPcmEncodingInfo)>::StrictValueWithNoDeps))
                .build());
    }

    int32_t getPcmEncodingInfo() const { return mPcmEncodingInfo->value; }

private:
    std::shared_ptr<C2StreamFormatConfig::input> mInputFormat;
    std::shared_ptr<C2StreamFormatConfig::output> mOutputFormat;
@@ -94,6 +107,7 @@ private:
    std::shared_ptr<C2StreamChannelCountInfo::output> mChannelCount;
    std::shared_ptr<C2BitrateTuning::input> mBitrate;
    std::shared_ptr<C2StreamMaxBufferSizeInfo::input> mInputMaxBufSize;
    std::shared_ptr<C2StreamPcmEncodingInfo::output> mPcmEncodingInfo;
};

C2SoftFlacDec::C2SoftFlacDec(
@@ -263,11 +277,11 @@ void C2SoftFlacDec::process(
        return;
    }

    size_t outSize;
    if (mHasStreamInfo)
        outSize = mStreamInfo.max_blocksize * mStreamInfo.channels * sizeof(short);
    else
        outSize = kMaxBlockSize * FLACDecoder::kMaxChannels * sizeof(short);
    const bool outputFloat = mIntf->getPcmEncodingInfo() == C2Config::PCM_FLOAT;
    const size_t sampleSize = outputFloat ? sizeof(float) : sizeof(short);
    size_t outSize = mHasStreamInfo ?
            mStreamInfo.max_blocksize * mStreamInfo.channels * sampleSize
          : kMaxBlockSize * FLACDecoder::kMaxChannels * sampleSize;

    std::shared_ptr<C2LinearBlock> block;
    C2MemoryUsage usage = { C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE };
@@ -284,9 +298,8 @@ void C2SoftFlacDec::process(
        return;
    }

    short *output = reinterpret_cast<short *>(wView.data());
    status_t decoderErr = mFLACDecoder->decodeOneFrame(
                            input, inSize, output, &outSize);
                            input, inSize, wView.data(), &outSize, outputFloat);
    if (decoderErr != OK) {
        ALOGE("process: FLACDecoder decodeOneFrame returns error %d", decoderErr);
        mSignalledError = true;
+36 −12
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@
#define LOG_TAG "C2SoftFlacEnc"
#include <log/log.h>

#include <audio_utils/primitives.h>
#include <media/stagefright/foundation/MediaDefs.h>

#include <C2PlatformSupport.h>
@@ -72,11 +73,23 @@ public:
                DefineParam(mInputMaxBufSize, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE)
                .withConstValue(new C2StreamMaxBufferSizeInfo::input(0u, 4608))
                .build());

        addParameter(
                DefineParam(mPcmEncodingInfo, C2_PARAMKEY_PCM_ENCODING)
                .withDefault(new C2StreamPcmEncodingInfo::input(0u, C2Config::PCM_16))
                .withFields({C2F(mPcmEncodingInfo, value).oneOf({
                     C2Config::PCM_16,
                     // C2Config::PCM_8,
                     C2Config::PCM_FLOAT})
                })
                .withSetter((Setter<decltype(*mPcmEncodingInfo)>::StrictValueWithNoDeps))
                .build());
    }

    uint32_t getSampleRate() const { return mSampleRate->value; }
    uint32_t getChannelCount() const { return mChannelCount->value; }
    uint32_t getBitrate() const { return mBitrate->value; }
    int32_t getPcmEncodingInfo() const { return mPcmEncodingInfo->value; }

private:
    std::shared_ptr<C2StreamFormatConfig::input> mInputFormat;
@@ -87,6 +100,7 @@ private:
    std::shared_ptr<C2StreamChannelCountInfo::input> mChannelCount;
    std::shared_ptr<C2BitrateTuning::output> mBitrate;
    std::shared_ptr<C2StreamMaxBufferSizeInfo::input> mInputMaxBufSize;
    std::shared_ptr<C2StreamPcmEncodingInfo::input> mPcmEncodingInfo;
};
constexpr char COMPONENT_NAME[] = "c2.android.flac.encoder";

@@ -224,12 +238,15 @@ void C2SoftFlacEnc::process(
        mWroteHeader = true;
    }

    uint32_t sampleRate = mIntf->getSampleRate();
    uint32_t channelCount = mIntf->getChannelCount();
    uint64_t outTimeStamp = mProcessedSamples * 1000000ll / sampleRate;
    const uint32_t sampleRate = mIntf->getSampleRate();
    const uint32_t channelCount = mIntf->getChannelCount();
    const bool inputFloat = mIntf->getPcmEncodingInfo() == C2Config::PCM_FLOAT;
    const unsigned sampleSize = inputFloat ? sizeof(float) : sizeof(int16_t);
    const unsigned frameSize = channelCount * sampleSize;
    const uint64_t outTimeStamp = mProcessedSamples * 1000000ll / sampleRate;

    size_t outCapacity = inSize;
    outCapacity += mBlockSize * channelCount * sizeof(int16_t);
    outCapacity += mBlockSize * frameSize;

    C2MemoryUsage usage = { C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE };
    c2_status_t err = pool->fetchLinearBlock(outCapacity, usage, &mOutputBlock);
@@ -250,15 +267,20 @@ void C2SoftFlacEnc::process(
    size_t inPos = 0;
    while (inPos < inSize) {
        const uint8_t *inPtr = rView.data() + inOffset;
        size_t processSize = MIN(kInBlockSize * channelCount * sizeof(int16_t), (inSize - inPos));
        const unsigned nbInputFrames = processSize / (channelCount * sizeof(int16_t));
        const unsigned nbInputSamples = processSize / sizeof(int16_t);
        const int16_t *pcm16 = reinterpret_cast<const int16_t *>(inPtr + inPos);
        ALOGV("about to encode %zu bytes", processSize);
        const size_t processSize = MIN(kInBlockSize * frameSize, (inSize - inPos));
        const unsigned nbInputFrames = processSize / frameSize;
        const unsigned nbInputSamples = processSize / sampleSize;

        ALOGV("about to encode %zu bytes", processSize);
        if (inputFloat) {
            const float * const pcmFloat = reinterpret_cast<const float *>(inPtr + inPos);
            memcpy_to_q8_23_from_float_with_clamp(mInputBufferPcm32, pcmFloat, nbInputSamples);
        } else {
            const int16_t * const pcm16 = reinterpret_cast<const int16_t *>(inPtr + inPos);
            for (unsigned i = 0; i < nbInputSamples; i++) {
                mInputBufferPcm32[i] = (FLAC__int32) pcm16[i];
            }
        }

        FLAC__bool ok = FLAC__stream_encoder_process_interleaved(
                mFlacStreamEncoder, mInputBufferPcm32, nbInputFrames);
@@ -342,10 +364,12 @@ status_t C2SoftFlacEnc::configureEncoder() {
        return UNKNOWN_ERROR;
    }

    const bool inputFloat = mIntf->getPcmEncodingInfo() == C2Config::PCM_FLOAT;
    const int bitsPerSample = inputFloat ? 24 : 16;
    FLAC__bool ok = true;
    ok = ok && FLAC__stream_encoder_set_channels(mFlacStreamEncoder, mIntf->getChannelCount());
    ok = ok && FLAC__stream_encoder_set_sample_rate(mFlacStreamEncoder, mIntf->getSampleRate());
    ok = ok && FLAC__stream_encoder_set_bits_per_sample(mFlacStreamEncoder, 16);
    ok = ok && FLAC__stream_encoder_set_bits_per_sample(mFlacStreamEncoder, bitsPerSample);
    ok = ok && FLAC__stream_encoder_set_compression_level(mFlacStreamEncoder, mCompressionLevel);
    ok = ok && FLAC__stream_encoder_set_verify(mFlacStreamEncoder, false);
    if (!ok) {
+8 −5
Original line number Diff line number Diff line
@@ -2183,7 +2183,8 @@ status_t ACodec::configureCodec(
            err = setupG711Codec(encoder, sampleRate, numChannels);
        }
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FLAC)) {
        int32_t numChannels = 0, sampleRate = 0, compressionLevel = -1;
        // numChannels needs to be set to properly communicate PCM values.
        int32_t numChannels = 2, sampleRate = 44100, compressionLevel = -1;
        if (encoder &&
                (!msg->findInt32("channel-count", &numChannels)
                        || !msg->findInt32("sample-rate", &sampleRate))) {
@@ -2209,7 +2210,7 @@ status_t ACodec::configureCodec(
                }
            }
            err = setupFlacCodec(
                    encoder, numChannels, sampleRate, compressionLevel);
                    encoder, numChannels, sampleRate, compressionLevel, pcmEncoding);
        }
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW)) {
        int32_t numChannels, sampleRate;
@@ -3033,8 +3034,8 @@ status_t ACodec::setupG711Codec(bool encoder, int32_t sampleRate, int32_t numCha
}

status_t ACodec::setupFlacCodec(
        bool encoder, int32_t numChannels, int32_t sampleRate, int32_t compressionLevel) {

        bool encoder, int32_t numChannels, int32_t sampleRate, int32_t compressionLevel,
        AudioEncoding encoding) {
    if (encoder) {
        OMX_AUDIO_PARAM_FLACTYPE def;
        InitOMXParams(&def);
@@ -3057,7 +3058,8 @@ status_t ACodec::setupFlacCodec(
    return setupRawAudioFormat(
            encoder ? kPortIndexInput : kPortIndexOutput,
            sampleRate,
            numChannels);
            numChannels,
            encoding);
}

status_t ACodec::setupRawAudioFormat(
@@ -3115,6 +3117,7 @@ status_t ACodec::setupRawAudioFormat(
    pcmParams.ePCMMode = OMX_AUDIO_PCMModeLinear;

    if (getOMXChannelMapping(numChannels, pcmParams.eChannelMapping) != OK) {
        ALOGE("%s: incorrect numChannels: %d", __func__, numChannels);
        return OMX_ErrorNone;
    }

+28 −10
Original line number Diff line number Diff line
@@ -89,12 +89,12 @@ void SoftFlacDecoder::initPorts() {
    def.eDir = OMX_DirOutput;
    def.nBufferCountMin = kNumOutputBuffers;
    def.nBufferCountActual = def.nBufferCountMin;
    def.nBufferSize = 4096 * FLACDecoder::kMaxChannels;
    def.nBufferSize = kNumSamplesPerFrame * FLACDecoder::kMaxChannels * sizeof(float);
    def.bEnabled = OMX_TRUE;
    def.bPopulated = OMX_FALSE;
    def.eDomain = OMX_PortDomainAudio;
    def.bBuffersContiguous = OMX_FALSE;
    def.nBufferAlignment = 2;
    def.nBufferAlignment = sizeof(float);

    def.format.audio.cMIMEType = const_cast<char *>("audio/raw");
    def.format.audio.pNativeRender = NULL;
@@ -173,7 +173,7 @@ OMX_ERRORTYPE SoftFlacDecoder::internalGetParameter(
                flacParams->nChannels = mStreamInfo.channels;
                flacParams->nSampleRate = mStreamInfo.sample_rate;
            } else {
                flacParams->nChannels = 1;
                flacParams->nChannels = 2;
                flacParams->nSampleRate = 44100;
            }

@@ -195,10 +195,10 @@ OMX_ERRORTYPE SoftFlacDecoder::internalGetParameter(
                return OMX_ErrorBadPortIndex;
            }

            pcmParams->eNumData = OMX_NumericalDataSigned;
            pcmParams->eNumData = mNumericalData;
            pcmParams->eEndian = OMX_EndianBig;
            pcmParams->bInterleaved = OMX_TRUE;
            pcmParams->nBitPerSample = 16;
            pcmParams->nBitPerSample = mBitsPerSample;
            pcmParams->ePCMMode = OMX_AUDIO_PCMModeLinear;
            pcmParams->eChannelMapping[0] = OMX_AUDIO_ChannelLF;
            pcmParams->eChannelMapping[1] = OMX_AUDIO_ChannelRF;
@@ -211,7 +211,7 @@ OMX_ERRORTYPE SoftFlacDecoder::internalGetParameter(
                pcmParams->nChannels = mStreamInfo.channels;
                pcmParams->nSamplingRate = mStreamInfo.sample_rate;
            } else {
                pcmParams->nChannels = 1;
                pcmParams->nChannels = 2;
                pcmParams->nSamplingRate = 44100;
            }

@@ -281,6 +281,19 @@ OMX_ERRORTYPE SoftFlacDecoder::internalSetParameter(
                return OMX_ErrorBadPortIndex;
            }

            if (pcmParams->eNumData == OMX_NumericalDataFloat && pcmParams->nBitPerSample == 32) {
                mNumericalData = OMX_NumericalDataFloat;
                mBitsPerSample = 32;
            } else if (pcmParams->eNumData == OMX_NumericalDataSigned
                     && pcmParams->nBitPerSample == 16) {
                mNumericalData = OMX_NumericalDataSigned;
                mBitsPerSample = 16;
            } else {
                ALOGE("Invalid eNumData %d, nBitsPerSample %d",
                        pcmParams->eNumData, pcmParams->nBitPerSample);
                return OMX_ErrorUndefined;
            }

            return OMX_ErrorNone;
        }

@@ -301,11 +314,13 @@ void SoftFlacDecoder::onQueueFilled(OMX_U32 /* portIndex */) {
    List<BufferInfo *> &inQueue = getPortQueue(0);
    List<BufferInfo *> &outQueue = getPortQueue(1);

    const bool outputFloat = mNumericalData == OMX_NumericalDataFloat;

    ALOGV("onQueueFilled %d/%d:", inQueue.empty(), outQueue.empty());
    while ((!inQueue.empty() || mSawInputEOS) && !outQueue.empty() && !mFinishedDecoder) {
        BufferInfo *outInfo = *outQueue.begin();
        OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader;
        int16_t *outBuffer = reinterpret_cast<int16_t *>(outHeader->pBuffer + outHeader->nOffset);
        void *outBuffer = reinterpret_cast<void *>(outHeader->pBuffer + outHeader->nOffset);
        size_t outBufferSize = outHeader->nAllocLen - outHeader->nOffset;
        int64_t timeStamp = 0;

@@ -374,7 +389,7 @@ void SoftFlacDecoder::onQueueFilled(OMX_U32 /* portIndex */) {
            }

            status_t decoderErr = mFLACDecoder->decodeOneFrame(
                    inBuffer, inBufferLength, outBuffer, &outBufferSize);
                    inBuffer, inBufferLength, outBuffer, &outBufferSize, outputFloat);
            if (decoderErr != OK) {
                ALOGE("onQueueFilled: FLACDecoder decodeOneFrame returns error %d", decoderErr);
                mSignalledError = true;
@@ -393,7 +408,9 @@ void SoftFlacDecoder::onQueueFilled(OMX_U32 /* portIndex */) {
                continue;
            }
        } else if (mSawInputEOS) {
            status_t decoderErr = mFLACDecoder->decodeOneFrame(NULL, 0, outBuffer, &outBufferSize);
            status_t decoderErr = mFLACDecoder->decodeOneFrame(
                    nullptr /* inBuffer */, 0 /* inBufferLen */,
                    outBuffer, &outBufferSize, outputFloat);
            mFinishedDecoder = true;
            if (decoderErr != OK) {
                ALOGE("onQueueFilled: FLACDecoder finish returns error %d", decoderErr);
@@ -456,7 +473,8 @@ void SoftFlacDecoder::onPortEnableCompleted(OMX_U32 portIndex, bool enabled) {
            mOutputPortSettingsChange = AWAITING_ENABLED;
            PortInfo *info = editPortInfo(1 /* portIndex */);
            if (!info->mDef.bEnabled) {
                info->mDef.nBufferSize = mStreamInfo.max_blocksize * mStreamInfo.channels * 2;
                info->mDef.nBufferSize =
                        mStreamInfo.max_blocksize * mStreamInfo.channels * sizeof(float);
            }
            break;
        }
Loading