Merge "Add resampler comments and fix a typo"

        AudioStreamIn *input = new AudioStreamIn(inHwDev, inStream);

        // Start record thread

        // RecorThread require both input and output device indication to forward to audio

        // RecordThread requires both input and output device indication to forward to audio

        // pre processing modules

        thread = new RecordThread(this,

                                  input,

    // set the PTS of the next buffer output by the resampler

    virtual void setPTS(int64_t pts);

    // Resample int16_t samples from provider and accumulate into 'out'.

    // A mono provider delivers a sequence of samples.

    // A stereo provider delivers a sequence of interleaved pairs of samples.

    // Multi-channel providers are not supported.

    // In either case, 'out' holds interleaved pairs of fixed-point signed Q19.12.

    // That is, for a mono provider, there is an implicit up-channeling.

    // Since this method accumulates, the caller is responsible for clearing 'out' initially.

    // FIXME assumes provider is always successful; it should return the actual frame count.

    virtual void resample(int32_t* out, size_t outFrameCount,

            AudioBufferProvider* provider) = 0;

                } else {

                    // resampling

                    memset(mRsmpOutBuffer, 0, framesOut * 2 * sizeof(int32_t));

                    // resampler accumulates, but we only have one source track

                    memset(mRsmpOutBuffer, 0, framesOut * FCC_2 * sizeof(int32_t));

                    // alter output frame count as if we were expecting stereo samples

                    if (mChannelCount == 1 && mReqChannelCount == 1) {

                        framesOut >>= 1;

                    // ditherAndClamp() works as long as all buffers returned by

                    // mActiveTrack->getNextBuffer() are 32 bit aligned which should be always true.

                    if (mChannelCount == 2 && mReqChannelCount == 1) {

                        // temporarily type pun mRsmpOutBuffer from Q19.12 to int16_t

                        ditherAndClamp(mRsmpOutBuffer, mRsmpOutBuffer, framesOut);

                        // the resampler always outputs stereo samples:

                        // do post stereo to mono conversion

                    } else {

                        ditherAndClamp((int32_t *)buffer.raw, mRsmpOutBuffer, framesOut);

                    }

                    // now done with mRsmpOutBuffer

                }

                if (mFramestoDrop == 0) {

        mResampler = AudioResampler::create(16, channelCount, mReqSampleRate);

        mResampler->setSampleRate(mSampleRate);

        mResampler->setVolume(AudioMixer::UNITY_GAIN, AudioMixer::UNITY_GAIN);

        mRsmpOutBuffer = new int32_t[mFrameCount * 2];

        mRsmpOutBuffer = new int32_t[mFrameCount * FCC_2];

        // optmization: if mono to mono, alter input frame count as if we were inputing

        // stereo samples

            // updated by RecordThread::readInputParameters()

            AudioResampler                      *mResampler;

            // interleaved stereo pairs of fixed-point signed Q19.12

            int32_t                             *mRsmpOutBuffer;

            int16_t                             *mRsmpInBuffer;

            int16_t                             *mRsmpInBuffer; // [mFrameCount * mChannelCount]

            size_t                              mRsmpInIndex;

            size_t                              mBufferSize;    // stream buffer size for read()

            const uint32_t                      mReqChannelCount;