Merge "Fix Fugu bytes per sample computation" into mnc-dev

4 files changed, 17 insertions, 35 deletions

diff --git a/libaudio/AudioOutput.cpp b/libaudio/AudioOutput.cpp
index 5e4f18f..bc4a99c 100644
--- a/libaudio/AudioOutput.cpp
+++ b/libaudio/AudioOutput.cpp
@@ -48,6 +48,7 @@ AudioOutput::AudioOutput(const char* alsa_name,
         , mChannelCnt(0)
         , mALSAName(alsa_name)
         , mALSAFormat(alsa_pcm_format)
+        , mBytesPerSample(0)
         , mBytesPerFrame(0)
         , mBytesPerChunk(0)
         , mStagingSize(0)
@@ -95,25 +96,22 @@ void AudioOutput::setupInternal() {
 
     mMaxDelayCompFrames = kMaxDelayCompensationMSec * mFramesPerSec / 1000;
 
-#if 0
-    mBytesPerSample = ((mALSAFormat == PCM_FORMAT_S32_LE) ? 4 : 2);
-#else
     switch (mALSAFormat) {
     case PCM_FORMAT_S16_LE:
         mBytesPerSample = 2;
         break;
-    case PCM_FORMAT_S24_LE:
-        mBytesPerSample = 3; // FIXME: This is 4 bytes.
+    case PCM_FORMAT_S24_3LE:
+        mBytesPerSample = 3;
         break;
+    case PCM_FORMAT_S24_LE: // fall through
     case PCM_FORMAT_S32_LE:
         mBytesPerSample = 4;
         break;
     default:
-        ALOGE("Unexpected alsa format 0x%x, setting mBytesPerSample to 3", mALSAFormat);
-        mBytesPerSample = 3; // FIXME: Should be fatal.
+        LOG_ALWAYS_FATAL("Unexpected alsa format %d", mALSAFormat);
         break;
     }
-#endif
+
     mBytesPerFrame = mBytesPerSample * mChannelCnt;
     mBytesPerChunk = mBytesPerFrame * mFramesPerChunk;
 
@@ -184,14 +182,6 @@ void AudioOutput::pushSilence(uint32_t nFrames)
     mFramesQueuedToDriver += nFrames; // FIXME: should take into account error?
 }
 
-void AudioOutput::stageChunk(const uint8_t* chunkData,
-                             uint8_t* sbuf,
-                             uint32_t inBytesPerSample,
-                             uint32_t nSamples)
-{
-    memcpy(sbuf, chunkData, inBytesPerSample * nSamples);
-}
-
 void AudioOutput::cleanupResources() {
 
     Mutex::Autolock _l(mDeviceLock);
@@ -411,10 +401,12 @@ void AudioOutput::processOneChunk(const uint8_t* data, size_t len,
         // Don't push data when primed and waiting for buffer alignment.
         // We need to align the ALSA buffers first.
         break;
-    case ACTIVE:
+    case ACTIVE: {
         doPCMWrite(data, len, format);
-        mFramesQueuedToDriver += len / mBytesPerFrame;
-        break;
+        // we use input frame size here (mBytesPerFrame is alsa device frame size)
+        const size_t frameSize = mChannelCnt * audio_bytes_per_sample(format);
+        mFramesQueuedToDriver += len / frameSize;
+        } break;
     default:
         // Do nothing.
         break;
diff --git a/libaudio/AudioOutput.h b/libaudio/AudioOutput.h
index 2655834..76fe643 100644
--- a/libaudio/AudioOutput.h
+++ b/libaudio/AudioOutput.h
@@ -109,13 +109,7 @@ class AudioOutput : public RefBase {
   protected:
 
     void                pushSilence(uint32_t nFrames);
-    // Take nBytes of chunkData, convert to output format and write at
-    // sbuf. sbuf WILL point to enough space to convert from 16 to 32 bit
-    // if needed.
-    virtual void        stageChunk(const uint8_t* chunkData,
-                                   uint8_t* sbuf,
-                                   uint32_t inBytesPerSample,
-                                   uint32_t nSamples);
+
     virtual void        openPCMDevice();
     virtual void        reset();
     virtual status_t    getDMAStartData(int64_t* dma_start_time,
diff --git a/libaudio/AudioStreamOut.cpp b/libaudio/AudioStreamOut.cpp
index ad452c2..82678c9 100644
--- a/libaudio/AudioStreamOut.cpp
+++ b/libaudio/AudioStreamOut.cpp
@@ -231,9 +231,11 @@ void AudioStreamOut::updateInputNums()
     ALOGD("AudioStreamOut::updateInputNums: chunk size %u from output rate %u\n",
         mInputChunkFrames, outputSampleRate());
 
+    mInputFrameSize = mInputChanCount * audio_bytes_per_sample(mInputFormat);
+
     // Buffer size is just the frame size multiplied by the number of
     // frames per chunk.
-    mInputBufSize = mInputChunkFrames * mInputChanCount * audio_bytes_per_sample(mInputFormat);
+    mInputBufSize = mInputChunkFrames * mInputFrameSize;
 
     // The nominal latency is just the duration of a chunk * the number of
     // chunks we nominally keep in flight at any given point in time.
@@ -362,12 +364,6 @@ uint32_t AudioStreamOut::outputSampleRate() const
     return mInputSampleRate;
 }
 
-int AudioStreamOut::getBytesPerOutputFrame()
-{
-    // FIXME: Use output format (PCM_FORMAT_S24_LE), should be 4 bytes per sample.
-    return mInputChanCount * sizeof(int16_t);
-}
-
 uint32_t AudioStreamOut::latency() const {
     uint32_t uSecLatency = mInputNominalLatencyUSec;
     uint32_t vcompDelay = mOwnerHAL.getVideoDelayCompUsec();
@@ -642,7 +638,7 @@ ssize_t AudioStreamOut::write(const void* buffer, size_t bytes)
     // If we don't actually have any physical outputs to write to, just sleep
     // for the proper amt of time in order to simulate the throttle that writing
     // to the hardware would impose.
-    finishedWriteOp(bytes / getBytesPerOutputFrame(), (0 == mPhysOutputs.size()));
+    finishedWriteOp(bytes / mInputFrameSize, (0 == mPhysOutputs.size()));
 
     return static_cast<ssize_t>(bytes);
 }
diff --git a/libaudio/AudioStreamOut.h b/libaudio/AudioStreamOut.h
index a6db8d2..f73241d 100644
--- a/libaudio/AudioStreamOut.h
+++ b/libaudio/AudioStreamOut.h
@@ -88,6 +88,7 @@ protected:
     // Handy values pre-computed from the audio configuration.
     uint32_t        mInputBufSize;
     uint32_t        mInputChanCount;
+    uint32_t        mInputFrameSize;
     uint32_t        mInputChunkFrames;
     uint32_t        mInputNominalLatencyUSec;
     LinearTransform mLocalTimeToFrames;
@@ -124,7 +125,6 @@ protected:
     status_t        getNextWriteTimestamp_internal(int64_t *timestamp);
     void            adjustOutputs(int64_t maxTime);
     ssize_t         writeInternal(const void* buffer, size_t bytes);
-    int             getBytesPerOutputFrame();
 };
 
 }  // android