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

Commit 56d517cb authored by Glenn Kasten's avatar Glenn Kasten Committed by Android (Google) Code Review
Browse files

Merge "Add "m" prefix to fields"

parents c3375234 e4a7ce25

services/audioflinger/FastCapture.cpp

+68 −68
Original line number Diff line number Diff line
@@ -29,18 +29,18 @@ 


namespace android {



/*static*/ const FastCaptureState FastCapture::initial;

/*static*/ const FastCaptureState FastCapture::sInitial;



FastCapture::FastCapture() : FastThread(),

    inputSource(NULL), inputSourceGen(0), pipeSink(NULL), pipeSinkGen(0),

    readBuffer(NULL), readBufferState(-1), format(Format_Invalid), sampleRate(0),

    // dummyDumpState

    totalNativeFramesRead(0)

    mInputSource(NULL), mInputSourceGen(0), mPipeSink(NULL), mPipeSinkGen(0),

    mReadBuffer(NULL), mReadBufferState(-1), mFormat(Format_Invalid), mSampleRate(0),

    // mDummyDumpState

    mTotalNativeFramesRead(0)

{

    previous = &initial;

    current = &initial;

    mPrevious = &sInitial;

    mCurrent = &sInitial;



    mDummyDumpState = &dummyDumpState;

    mDummyDumpState = &mDummyFastCaptureDumpState;

}



FastCapture::~FastCapture()
@@ -63,13 +63,13 @@ void FastCapture::setLog(NBLog::Writer *logWriter __unused) 


void FastCapture::onIdle()

{

    preIdle = *(const FastCaptureState *)current;

    current = &preIdle;

    mPreIdle = *(const FastCaptureState *)mCurrent;

    mCurrent = &mPreIdle;

}



void FastCapture::onExit()

{

    delete[] readBuffer;

    delete[] mReadBuffer;

}



bool FastCapture::isSubClassCommand(FastThreadState::Command command)
@@ -86,69 +86,69 @@ bool FastCapture::isSubClassCommand(FastThreadState::Command command) 


void FastCapture::onStateChange()

{

    const FastCaptureState * const current = (const FastCaptureState *) this->current;

    const FastCaptureState * const previous = (const FastCaptureState *) this->previous;

    FastCaptureDumpState * const dumpState = (FastCaptureDumpState *) this->dumpState;

    const FastCaptureState * const current = (const FastCaptureState *) this->mCurrent;

    const FastCaptureState * const previous = (const FastCaptureState *) this->mPrevious;

    FastCaptureDumpState * const dumpState = (FastCaptureDumpState *) this->mDumpState;

    const size_t frameCount = current->mFrameCount;



    bool eitherChanged = false;



    // check for change in input HAL configuration

    NBAIO_Format previousFormat = format;

    if (current->mInputSourceGen != inputSourceGen) {

        inputSource = current->mInputSource;

        inputSourceGen = current->mInputSourceGen;

        if (inputSource == NULL) {

            format = Format_Invalid;

            sampleRate = 0;

    NBAIO_Format previousFormat = mFormat;

    if (current->mInputSourceGen != mInputSourceGen) {

        mInputSource = current->mInputSource;

        mInputSourceGen = current->mInputSourceGen;

        if (mInputSource == NULL) {

            mFormat = Format_Invalid;

            mSampleRate = 0;

        } else {

            format = inputSource->format();

            sampleRate = Format_sampleRate(format);

            unsigned channelCount = Format_channelCount(format);

            mFormat = mInputSource->format();

            mSampleRate = Format_sampleRate(mFormat);

            unsigned channelCount = Format_channelCount(mFormat);

            ALOG_ASSERT(channelCount == 1 || channelCount == 2);

        }

        dumpState->mSampleRate = sampleRate;

        dumpState->mSampleRate = mSampleRate;

        eitherChanged = true;

    }



    // check for change in pipe

    if (current->mPipeSinkGen != pipeSinkGen) {

        pipeSink = current->mPipeSink;

        pipeSinkGen = current->mPipeSinkGen;

    if (current->mPipeSinkGen != mPipeSinkGen) {

        mPipeSink = current->mPipeSink;

        mPipeSinkGen = current->mPipeSinkGen;

        eitherChanged = true;

    }



    // input source and pipe sink must be compatible

    if (eitherChanged && inputSource != NULL && pipeSink != NULL) {

        ALOG_ASSERT(Format_isEqual(format, pipeSink->format()));

    if (eitherChanged && mInputSource != NULL && mPipeSink != NULL) {

        ALOG_ASSERT(Format_isEqual(mFormat, mPipeSink->format()));

    }



    if ((!Format_isEqual(format, previousFormat)) || (frameCount != previous->mFrameCount)) {

    if ((!Format_isEqual(mFormat, previousFormat)) || (frameCount != previous->mFrameCount)) {

        // FIXME to avoid priority inversion, don't delete here

        delete[] readBuffer;

        readBuffer = NULL;

        if (frameCount > 0 && sampleRate > 0) {

        delete[] mReadBuffer;

        mReadBuffer = NULL;

        if (frameCount > 0 && mSampleRate > 0) {

            // FIXME new may block for unbounded time at internal mutex of the heap

            //       implementation; it would be better to have normal capture thread allocate for

            //       us to avoid blocking here and to prevent possible priority inversion

            unsigned channelCount = Format_channelCount(format);

            unsigned channelCount = Format_channelCount(mFormat);

            // FIXME frameSize

            readBuffer = new short[frameCount * channelCount];

            periodNs = (frameCount * 1000000000LL) / sampleRate;    // 1.00

            underrunNs = (frameCount * 1750000000LL) / sampleRate;  // 1.75

            overrunNs = (frameCount * 500000000LL) / sampleRate;    // 0.50

            forceNs = (frameCount * 950000000LL) / sampleRate;      // 0.95

            warmupNsMin = (frameCount * 750000000LL) / sampleRate;  // 0.75

            warmupNsMax = (frameCount * 1250000000LL) / sampleRate; // 1.25

            mReadBuffer = new short[frameCount * channelCount];

            mPeriodNs = (frameCount * 1000000000LL) / mSampleRate;      // 1.00

            mUnderrunNs = (frameCount * 1750000000LL) / mSampleRate;    // 1.75

            mOverrunNs = (frameCount * 500000000LL) / mSampleRate;      // 0.50

            mForceNs = (frameCount * 950000000LL) / mSampleRate;        // 0.95

            mWarmupNsMin = (frameCount * 750000000LL) / mSampleRate;    // 0.75

            mWarmupNsMax = (frameCount * 1250000000LL) / mSampleRate;   // 1.25

        } else {

            periodNs = 0;

            underrunNs = 0;

            overrunNs = 0;

            forceNs = 0;

            warmupNsMin = 0;

            warmupNsMax = LONG_MAX;

        }

        readBufferState = -1;

            mPeriodNs = 0;

            mUnderrunNs = 0;

            mOverrunNs = 0;

            mForceNs = 0;

            mWarmupNsMin = 0;

            mWarmupNsMax = LONG_MAX;

        }

        mReadBufferState = -1;

        dumpState->mFrameCount = frameCount;

    }
@@ -156,44 +156,44 @@ void FastCapture::onStateChange() 


void FastCapture::onWork()

{

    const FastCaptureState * const current = (const FastCaptureState *) this->current;

    FastCaptureDumpState * const dumpState = (FastCaptureDumpState *) this->dumpState;

    const FastCaptureState::Command command = this->command;

    const FastCaptureState * const current = (const FastCaptureState *) this->mCurrent;

    FastCaptureDumpState * const dumpState = (FastCaptureDumpState *) this->mDumpState;

    const FastCaptureState::Command command = this->mCommand;

    const size_t frameCount = current->mFrameCount;



    if ((command & FastCaptureState::READ) /*&& isWarm*/) {

        ALOG_ASSERT(inputSource != NULL);

        ALOG_ASSERT(readBuffer != NULL);

        ALOG_ASSERT(mInputSource != NULL);

        ALOG_ASSERT(mReadBuffer != NULL);

        dumpState->mReadSequence++;

        ATRACE_BEGIN("read");

        ssize_t framesRead = inputSource->read(readBuffer, frameCount,

        ssize_t framesRead = mInputSource->read(mReadBuffer, frameCount,

                AudioBufferProvider::kInvalidPTS);

        ATRACE_END();

        dumpState->mReadSequence++;

        if (framesRead >= 0) {

            LOG_ALWAYS_FATAL_IF((size_t) framesRead > frameCount);

            totalNativeFramesRead += framesRead;

            dumpState->mFramesRead = totalNativeFramesRead;

            readBufferState = framesRead;

            mTotalNativeFramesRead += framesRead;

            dumpState->mFramesRead = mTotalNativeFramesRead;

            mReadBufferState = framesRead;

        } else {

            dumpState->mReadErrors++;

            readBufferState = 0;

            mReadBufferState = 0;

        }

        // FIXME rename to attemptedIO

        attemptedWrite = true;

        mAttemptedWrite = true;

    }



    if (command & FastCaptureState::WRITE) {

        ALOG_ASSERT(pipeSink != NULL);

        ALOG_ASSERT(readBuffer != NULL);

        if (readBufferState < 0) {

            unsigned channelCount = Format_channelCount(format);

        ALOG_ASSERT(mPipeSink != NULL);

        ALOG_ASSERT(mReadBuffer != NULL);

        if (mReadBufferState < 0) {

            unsigned channelCount = Format_channelCount(mFormat);

            // FIXME frameSize

            memset(readBuffer, 0, frameCount * channelCount * sizeof(short));

            readBufferState = frameCount;

            memset(mReadBuffer, 0, frameCount * channelCount * sizeof(short));

            mReadBufferState = frameCount;

        }

        if (readBufferState > 0) {

            ssize_t framesWritten = pipeSink->write(readBuffer, readBufferState);

        if (mReadBufferState > 0) {

            ssize_t framesWritten = mPipeSink->write(mReadBuffer, mReadBufferState);

            // FIXME This supports at most one fast capture client.

            //       To handle multiple clients this could be converted to an array,

            //       or with a lot more work the control block could be shared by all clients.

services/audioflinger/FastCapture.h

+14 −12
Original line number Diff line number Diff line
@@ -46,19 +46,21 @@ private: 
    virtual void onStateChange();

    virtual void onWork();



    static const FastCaptureState initial;

    FastCaptureState preIdle; // copy of state before we went into idle

    static const FastCaptureState sInitial;



    FastCaptureState    mPreIdle;   // copy of state before we went into idle

    // FIXME by renaming, could pull up many of these to FastThread

    NBAIO_Source *inputSource;

    int inputSourceGen;

    NBAIO_Sink *pipeSink;

    int pipeSinkGen;

    short *readBuffer;

    ssize_t readBufferState;    // number of initialized frames in readBuffer, or -1 to clear

    NBAIO_Format format;

    unsigned sampleRate;

    FastCaptureDumpState dummyDumpState;

    uint32_t totalNativeFramesRead; // copied to dumpState->mFramesRead

    NBAIO_Source*       mInputSource;

    int                 mInputSourceGen;

    NBAIO_Sink*         mPipeSink;

    int                 mPipeSinkGen;

    short*              mReadBuffer;

    ssize_t             mReadBufferState;   // number of initialized frames in readBuffer,

                                            // or -1 to clear

    NBAIO_Format        mFormat;

    unsigned            mSampleRate;

    FastCaptureDumpState mDummyFastCaptureDumpState;

    uint32_t            mTotalNativeFramesRead; // copied to dumpState->mFramesRead



};  // class FastCapture

services/audioflinger/FastMixer.cpp

+121 −121

File changed.

Preview size limit exceeded, changes collapsed.

services/audioflinger/FastMixer.h

+25 −22
Original line number Diff line number Diff line
@@ -48,15 +48,18 @@ private: 
    virtual void onStateChange();

    virtual void onWork();



    // FIXME these former local variables need comments and to be renamed to have "m" prefix

    static const FastMixerState initial;

    FastMixerState preIdle; // copy of state before we went into idle

    long slopNs;        // accumulated time we've woken up too early (> 0) or too late (< 0)

    int fastTrackNames[FastMixerState::kMaxFastTracks]; // handles used by mixer to identify tracks

    int generations[FastMixerState::kMaxFastTracks];    // last observed mFastTracks[i].mGeneration

    NBAIO_Sink *outputSink;

    int outputSinkGen;

    AudioMixer* mixer;

    // FIXME these former local variables need comments

    static const FastMixerState sInitial;



    FastMixerState  mPreIdle;   // copy of state before we went into idle

    long            mSlopNs;    // accumulated time we've woken up too early (> 0) or too late (< 0)

    int             mFastTrackNames[FastMixerState::kMaxFastTracks];

                                // handles used by mixer to identify tracks

    int             mGenerations[FastMixerState::kMaxFastTracks];

                                // last observed mFastTracks[i].mGeneration

    NBAIO_Sink*     mOutputSink;

    int             mOutputSinkGen;

    AudioMixer*     mMixer;



    // mSinkBuffer audio format is stored in format.mFormat.

    void*           mSinkBuffer;        // used for mixer output format translation
@@ -69,15 +72,15 @@ private: 
    audio_format_t  mMixerBufferFormat; // mixer output format: AUDIO_FORMAT_PCM_(16_BIT|FLOAT).



    enum {UNDEFINED, MIXED, ZEROED} mMixerBufferState;

    NBAIO_Format format;

    unsigned sampleRate;

    int fastTracksGen;

    FastMixerDumpState dummyDumpState;

    uint32_t totalNativeFramesWritten;  // copied to dumpState->mFramesWritten

    NBAIO_Format    mFormat;

    unsigned        mSampleRate;

    int             mFastTracksGen;

    FastMixerDumpState mDummyFastMixerDumpState;

    uint32_t        mTotalNativeFramesWritten;  // copied to dumpState->mFramesWritten



    // next 2 fields are valid only when timestampStatus == NO_ERROR

    AudioTimestamp timestamp;

    uint32_t nativeFramesWrittenButNotPresented;

    AudioTimestamp  mTimestamp;

    uint32_t        mNativeFramesWrittenButNotPresented;



};  // class FastMixer

services/audioflinger/FastThread.cpp

+133 −132

File changed.

Preview size limit exceeded, changes collapsed.