diff --git a/cmds/screenrecord/Android.mk b/cmds/screenrecord/Android.mk
index 6ee2884..6747e60 100644
--- a/cmds/screenrecord/Android.mk
+++ b/cmds/screenrecord/Android.mk
@@ -41,6 +41,4 @@
 
 LOCAL_MODULE:= screenrecord
 
-LOCAL_32_BIT_ONLY := true
-
 include $(BUILD_EXECUTABLE)
diff --git a/cmds/stagefright/Android.mk b/cmds/stagefright/Android.mk
index e2e389b..561ce02 100644
--- a/cmds/stagefright/Android.mk
+++ b/cmds/stagefright/Android.mk
@@ -23,8 +23,6 @@
 
 LOCAL_MODULE:= stagefright
 
-LOCAL_32_BIT_ONLY := true
-
 include $(BUILD_EXECUTABLE)
 
 ################################################################################
@@ -48,8 +46,6 @@
 
 LOCAL_MODULE:= record
 
-LOCAL_32_BIT_ONLY := true
-
 include $(BUILD_EXECUTABLE)
 
 ################################################################################
@@ -73,8 +69,6 @@
 
 LOCAL_MODULE:= recordvideo
 
-LOCAL_32_BIT_ONLY := true
-
 include $(BUILD_EXECUTABLE)
 
 
@@ -99,8 +93,6 @@
 
 LOCAL_MODULE:= audioloop
 
-LOCAL_32_BIT_ONLY := true
-
 include $(BUILD_EXECUTABLE)
 
 ################################################################################
@@ -124,8 +116,6 @@
 
 LOCAL_MODULE:= stream
 
-LOCAL_32_BIT_ONLY := true
-
 include $(BUILD_EXECUTABLE)
 
 ################################################################################
@@ -149,8 +139,6 @@
 
 LOCAL_MODULE:= sf2
 
-LOCAL_32_BIT_ONLY := true
-
 include $(BUILD_EXECUTABLE)
 
 ################################################################################
@@ -175,8 +163,6 @@
 
 LOCAL_MODULE:= codec
 
-LOCAL_32_BIT_ONLY := true
-
 include $(BUILD_EXECUTABLE)
 
 ################################################################################
@@ -200,6 +186,4 @@
 
 LOCAL_MODULE:= muxer
 
-LOCAL_32_BIT_ONLY := true
-
 include $(BUILD_EXECUTABLE)
diff --git a/include/media/stagefright/ClockEstimator.h b/include/media/stagefright/ClockEstimator.h
new file mode 100644
index 0000000..2fd6e75
--- /dev/null
+++ b/include/media/stagefright/ClockEstimator.h
@@ -0,0 +1,110 @@
+/*
+**
+** Copyright 2014, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef CLOCK_ESTIMATOR_H_
+
+#define CLOCK_ESTIMATOR_H_
+
+
+#include <utils/RefBase.h>
+#include <utils/Vector.h>
+
+namespace android {
+// ---------------------------------------------------------------------------
+
+struct ClockEstimator : RefBase {
+    virtual double estimate(double x, double y) = 0;
+    virtual void reset() = 0;
+};
+
+struct WindowedLinearFitEstimator : ClockEstimator {
+    struct LinearFit {
+        /**
+         * Fit y = a * x + b, where each input has a weight
+         */
+        double mX;  // sum(w_i * x_i)
+        double mXX; // sum(w_i * x_i^2)
+        double mY;  // sum(w_i * y_i)
+        double mYY; // sum(w_i * y_i^2)
+        double mXY; // sum(w_i * x_i * y_i)
+        double mW;  // sum(w_i)
+
+        LinearFit();
+        void reset();
+        void combine(const LinearFit &lf);
+        void add(double x, double y, double w);
+        void scale(double w);
+        double interpolate(double x);
+        double size() const;
+
+        DISALLOW_EVIL_CONSTRUCTORS(LinearFit);
+    };
+
+    /**
+     * Estimator for f(x) = y' where input y' is noisy, but
+     * theoretically linear:
+     *
+     *      y' =~ y = a * x + b
+     *
+     * It uses linear fit regression over a tapering rolling window
+     * to get an estimate for y (from the current and past inputs
+     * (x, y')).
+     *
+     *     ____________
+     *    /|          |\
+     *   / |          | \
+     *  /  |          |  \   <--- new data (x, y')
+     * /   |   main   |   \
+     * <--><----------><-->
+     * tail            head
+     *
+     * weight is 1 under the main window, tapers exponentially by
+     * the factors given in the head and the tail.
+     *
+     * Assuming that x and y' are monotonic, that x is somewhat
+     * evenly sampled, and that a =~ 1, the estimated y is also
+     * going to be monotonic.
+     */
+    WindowedLinearFitEstimator(
+            size_t headLength = 5, double headFactor = 0.5,
+            size_t mainLength = 0, double tailFactor = 0.99);
+
+    virtual void reset();
+
+    // add a new sample (x -> y') and return an estimated value for the true y
+    virtual double estimate(double x, double y);
+
+private:
+    Vector<double> mXHistory; // circular buffer
+    Vector<double> mYHistory; // circular buffer
+    LinearFit mHead;
+    LinearFit mMain;
+    LinearFit mTail;
+    double mHeadFactorInv;
+    double mTailFactor;
+    double mFirstWeight;
+    size_t mHistoryLength;
+    size_t mHeadLength;
+    size_t mNumSamples;
+    size_t mSampleIx;
+
+    DISALLOW_EVIL_CONSTRUCTORS(WindowedLinearFitEstimator);
+};
+
+}; // namespace android
+
+#endif
diff --git a/media/libeffects/downmix/EffectDownmix.c b/media/libeffects/downmix/EffectDownmix.c
index 1663d47..661fde9 100644
--- a/media/libeffects/downmix/EffectDownmix.c
+++ b/media/libeffects/downmix/EffectDownmix.c
@@ -30,25 +30,13 @@
 
 #define MINUS_3_DB_IN_Q19_12 2896 // -3dB = 0.707 * 2^12 = 2896
 
+// subset of possible audio_channel_mask_t values, and AUDIO_CHANNEL_OUT_* renamed to CHANNEL_MASK_*
 typedef enum {
-    CHANNEL_MASK_SURROUND = AUDIO_CHANNEL_OUT_SURROUND,
-    CHANNEL_MASK_QUAD_BACK = AUDIO_CHANNEL_OUT_QUAD,
-    // like AUDIO_CHANNEL_OUT_QUAD with *_SIDE_* instead of *_BACK_*, same channel order
-    CHANNEL_MASK_QUAD_SIDE =
-            AUDIO_CHANNEL_OUT_FRONT_LEFT |
-            AUDIO_CHANNEL_OUT_FRONT_RIGHT |
-            AUDIO_CHANNEL_OUT_SIDE_LEFT |
-            AUDIO_CHANNEL_OUT_SIDE_RIGHT,
-    CHANNEL_MASK_5POINT1_BACK = AUDIO_CHANNEL_OUT_5POINT1,
-    // like AUDIO_CHANNEL_OUT_5POINT1 with *_SIDE_* instead of *_BACK_*, same channel order
-    CHANNEL_MASK_5POINT1_SIDE =
-            AUDIO_CHANNEL_OUT_FRONT_LEFT |
-            AUDIO_CHANNEL_OUT_FRONT_RIGHT |
-            AUDIO_CHANNEL_OUT_FRONT_CENTER |
-            AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
-            AUDIO_CHANNEL_OUT_SIDE_LEFT |
-            AUDIO_CHANNEL_OUT_SIDE_RIGHT,
-    CHANNEL_MASK_7POINT1_SIDE_BACK = AUDIO_CHANNEL_OUT_7POINT1,
+    CHANNEL_MASK_QUAD_BACK = AUDIO_CHANNEL_OUT_QUAD_BACK,
+    CHANNEL_MASK_QUAD_SIDE = AUDIO_CHANNEL_OUT_QUAD_SIDE,
+    CHANNEL_MASK_5POINT1_BACK = AUDIO_CHANNEL_OUT_5POINT1_BACK,
+    CHANNEL_MASK_5POINT1_SIDE = AUDIO_CHANNEL_OUT_5POINT1_SIDE,
+    CHANNEL_MASK_7POINT1 = AUDIO_CHANNEL_OUT_7POINT1,
 } downmix_input_channel_mask_t;
 
 // effect_handle_t interface implementation for downmix effect
@@ -340,14 +328,11 @@
         case CHANNEL_MASK_QUAD_SIDE:
             Downmix_foldFromQuad(pSrc, pDst, numFrames, accumulate);
             break;
-        case CHANNEL_MASK_SURROUND:
-            Downmix_foldFromSurround(pSrc, pDst, numFrames, accumulate);
-            break;
         case CHANNEL_MASK_5POINT1_BACK:
         case CHANNEL_MASK_5POINT1_SIDE:
             Downmix_foldFrom5Point1(pSrc, pDst, numFrames, accumulate);
             break;
-        case CHANNEL_MASK_7POINT1_SIDE_BACK:
+        case CHANNEL_MASK_7POINT1:
             Downmix_foldFrom7Point1(pSrc, pDst, numFrames, accumulate);
             break;
         default:
@@ -828,65 +813,6 @@
 
 
 /*----------------------------------------------------------------------------
- * Downmix_foldFromSurround()
- *----------------------------------------------------------------------------
- * Purpose:
- * downmix a "surround sound" (mono rear) signal to stereo
- *
- * Inputs:
- *  pSrc       surround signal to downmix
- *  numFrames  the number of surround frames to downmix
- *  accumulate whether to mix (when true) the result of the downmix with the contents of pDst,
- *               or overwrite pDst (when false)
- *
- * Outputs:
- *  pDst       downmixed stereo audio samples
- *
- *----------------------------------------------------------------------------
- */
-void Downmix_foldFromSurround(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {
-    int32_t lt, rt, centerPlusRearContrib; // samples in Q19.12 format
-    // sample at index 0 is FL
-    // sample at index 1 is FR
-    // sample at index 2 is FC
-    // sample at index 3 is RC
-    // code is mostly duplicated between the two values of accumulate to avoid repeating the test
-    // for every sample
-    if (accumulate) {
-        while (numFrames) {
-            // centerPlusRearContrib = FC(-3dB) + RC(-3dB)
-            centerPlusRearContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12) + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
-            // FL + centerPlusRearContrib
-            lt = (pSrc[0] << 12) + centerPlusRearContrib;
-            // FR + centerPlusRearContrib
-            rt = (pSrc[1] << 12) + centerPlusRearContrib;
-            // accumulate in destination
-            pDst[0] = clamp16(pDst[0] + (lt >> 13));
-            pDst[1] = clamp16(pDst[1] + (rt >> 13));
-            pSrc += 4;
-            pDst += 2;
-            numFrames--;
-        }
-    } else { // same code as above but without adding and clamping pDst[i] to itself
-        while (numFrames) {
-            // centerPlusRearContrib = FC(-3dB) + RC(-3dB)
-            centerPlusRearContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12) + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
-            // FL + centerPlusRearContrib
-            lt = (pSrc[0] << 12) + centerPlusRearContrib;
-            // FR + centerPlusRearContrib
-            rt = (pSrc[1] << 12) + centerPlusRearContrib;
-            // store in destination
-            pDst[0] = clamp16(lt >> 13); // differs from when accumulate is true above
-            pDst[1] = clamp16(rt >> 13); // differs from when accumulate is true above
-            pSrc += 4;
-            pDst += 2;
-            numFrames--;
-        }
-    }
-}
-
-
-/*----------------------------------------------------------------------------
  * Downmix_foldFrom5Point1()
  *----------------------------------------------------------------------------
  * Purpose:
diff --git a/media/libeffects/downmix/EffectDownmix.h b/media/libeffects/downmix/EffectDownmix.h
index fcb3c9e..2399abd 100644
--- a/media/libeffects/downmix/EffectDownmix.h
+++ b/media/libeffects/downmix/EffectDownmix.h
@@ -97,7 +97,6 @@
 int Downmix_getParameter(downmix_object_t *pDownmixer, int32_t param, uint32_t *pSize, void *pValue);
 
 void Downmix_foldFromQuad(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);
-void Downmix_foldFromSurround(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);
 void Downmix_foldFrom5Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);
 void Downmix_foldFrom7Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);
 bool Downmix_foldGeneric(
diff --git a/media/libmedia/AudioTrack.cpp b/media/libmedia/AudioTrack.cpp
index fbfd3da..8daf08b 100644
--- a/media/libmedia/AudioTrack.cpp
+++ b/media/libmedia/AudioTrack.cpp
@@ -1820,7 +1820,7 @@
 
     result.append(" AudioTrack::dump\n");
     snprintf(buffer, 255, "  stream type(%d), left - right volume(%f, %f)\n", mStreamType,
-            mVolume[0], mVolume[1]);
+            mVolume[AUDIO_INTERLEAVE_LEFT], mVolume[AUDIO_INTERLEAVE_RIGHT]);
     result.append(buffer);
     snprintf(buffer, 255, "  format(%d), channel count(%d), frame count(%zu)\n", mFormat,
             mChannelCount, mFrameCount);
diff --git a/media/libmedia/IAudioFlinger.cpp b/media/libmedia/IAudioFlinger.cpp
index eb813bd..1940fe7 100644
--- a/media/libmedia/IAudioFlinger.cpp
+++ b/media/libmedia/IAudioFlinger.cpp
@@ -106,7 +106,7 @@
         data.writeInt32(format);
         data.writeInt32(channelMask);
         size_t frameCount = pFrameCount != NULL ? *pFrameCount : 0;
-        data.writeInt32(frameCount);
+        data.writeInt64(frameCount);
         track_flags_t lFlags = flags != NULL ? *flags : (track_flags_t) TRACK_DEFAULT;
         data.writeInt32(lFlags);
         // haveSharedBuffer
@@ -128,7 +128,7 @@
         if (lStatus != NO_ERROR) {
             ALOGE("createTrack error: %s", strerror(-lStatus));
         } else {
-            frameCount = reply.readInt32();
+            frameCount = reply.readInt64();
             if (pFrameCount != NULL) {
                 *pFrameCount = frameCount;
             }
@@ -179,7 +179,7 @@
         data.writeInt32(format);
         data.writeInt32(channelMask);
         size_t frameCount = pFrameCount != NULL ? *pFrameCount : 0;
-        data.writeInt32(frameCount);
+        data.writeInt64(frameCount);
         track_flags_t lFlags = flags != NULL ? *flags : (track_flags_t) TRACK_DEFAULT;
         data.writeInt32(lFlags);
         data.writeInt32((int32_t) tid);
@@ -192,7 +192,7 @@
         if (lStatus != NO_ERROR) {
             ALOGE("openRecord error: %s", strerror(-lStatus));
         } else {
-            frameCount = reply.readInt32();
+            frameCount = reply.readInt64();
             if (pFrameCount != NULL) {
                 *pFrameCount = frameCount;
             }
@@ -248,7 +248,7 @@
         data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
         data.writeInt32((int32_t) output);
         remote()->transact(FRAME_COUNT, data, &reply);
-        return reply.readInt32();
+        return reply.readInt64();
     }
 
     virtual uint32_t latency(audio_io_handle_t output) const
@@ -398,7 +398,7 @@
         data.writeInt32(format);
         data.writeInt32(channelMask);
         remote()->transact(GET_INPUTBUFFERSIZE, data, &reply);
-        return reply.readInt32();
+        return reply.readInt64();
     }
 
     virtual audio_io_handle_t openOutput(audio_module_handle_t module,
@@ -769,7 +769,7 @@
         Parcel data, reply;
         data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
         remote()->transact(GET_PRIMARY_OUTPUT_FRAME_COUNT, data, &reply);
-        return reply.readInt32();
+        return reply.readInt64();
     }
 
     virtual status_t setLowRamDevice(bool isLowRamDevice)
@@ -797,7 +797,7 @@
             uint32_t sampleRate = data.readInt32();
             audio_format_t format = (audio_format_t) data.readInt32();
             audio_channel_mask_t channelMask = data.readInt32();
-            size_t frameCount = data.readInt32();
+            size_t frameCount = data.readInt64();
             track_flags_t flags = (track_flags_t) data.readInt32();
             bool haveSharedBuffer = data.readInt32() != 0;
             sp<IMemory> buffer;
@@ -821,7 +821,7 @@
                         &sessionId, clientUid, &status);
                 LOG_ALWAYS_FATAL_IF((track != 0) != (status == NO_ERROR));
             }
-            reply->writeInt32(frameCount);
+            reply->writeInt64(frameCount);
             reply->writeInt32(flags);
             reply->writeInt32(sessionId);
             reply->writeInt32(status);
@@ -834,7 +834,7 @@
             uint32_t sampleRate = data.readInt32();
             audio_format_t format = (audio_format_t) data.readInt32();
             audio_channel_mask_t channelMask = data.readInt32();
-            size_t frameCount = data.readInt32();
+            size_t frameCount = data.readInt64();
             track_flags_t flags = (track_flags_t) data.readInt32();
             pid_t tid = (pid_t) data.readInt32();
             int sessionId = data.readInt32();
@@ -842,7 +842,7 @@
             sp<IAudioRecord> record = openRecord(input,
                     sampleRate, format, channelMask, &frameCount, &flags, tid, &sessionId, &status);
             LOG_ALWAYS_FATAL_IF((record != 0) != (status == NO_ERROR));
-            reply->writeInt32(frameCount);
+            reply->writeInt64(frameCount);
             reply->writeInt32(flags);
             reply->writeInt32(sessionId);
             reply->writeInt32(status);
@@ -861,7 +861,7 @@
         } break;
         case FRAME_COUNT: {
             CHECK_INTERFACE(IAudioFlinger, data, reply);
-            reply->writeInt32( frameCount((audio_io_handle_t) data.readInt32()) );
+            reply->writeInt64( frameCount((audio_io_handle_t) data.readInt32()) );
             return NO_ERROR;
         } break;
         case LATENCY: {
@@ -960,7 +960,7 @@
             uint32_t sampleRate = data.readInt32();
             audio_format_t format = (audio_format_t) data.readInt32();
             audio_channel_mask_t channelMask = data.readInt32();
-            reply->writeInt32( getInputBufferSize(sampleRate, format, channelMask) );
+            reply->writeInt64( getInputBufferSize(sampleRate, format, channelMask) );
             return NO_ERROR;
         } break;
         case OPEN_OUTPUT: {
@@ -1164,7 +1164,7 @@
         } break;
         case GET_PRIMARY_OUTPUT_FRAME_COUNT: {
             CHECK_INTERFACE(IAudioFlinger, data, reply);
-            reply->writeInt32(getPrimaryOutputFrameCount());
+            reply->writeInt64(getPrimaryOutputFrameCount());
             return NO_ERROR;
         } break;
         case SET_LOW_RAM_DEVICE: {
diff --git a/media/libmedia/IAudioFlingerClient.cpp b/media/libmedia/IAudioFlingerClient.cpp
index 3c0d4cf..1c299f7 100644
--- a/media/libmedia/IAudioFlingerClient.cpp
+++ b/media/libmedia/IAudioFlingerClient.cpp
@@ -55,7 +55,7 @@
             data.writeInt32(desc->samplingRate);
             data.writeInt32(desc->format);
             data.writeInt32(desc->channelMask);
-            data.writeInt32(desc->frameCount);
+            data.writeInt64(desc->frameCount);
             data.writeInt32(desc->latency);
         }
         remote()->transact(IO_CONFIG_CHANGED, data, &reply, IBinder::FLAG_ONEWAY);
@@ -85,7 +85,7 @@
                 desc.samplingRate = data.readInt32();
                 desc.format = (audio_format_t) data.readInt32();
                 desc.channelMask = (audio_channel_mask_t) data.readInt32();
-                desc.frameCount = data.readInt32();
+                desc.frameCount = data.readInt64();
                 desc.latency = data.readInt32();
                 param2 = &desc;
             }
diff --git a/media/libmedia/IAudioTrack.cpp b/media/libmedia/IAudioTrack.cpp
index ffc21fc..265bb1b 100644
--- a/media/libmedia/IAudioTrack.cpp
+++ b/media/libmedia/IAudioTrack.cpp
@@ -118,7 +118,7 @@
     virtual status_t allocateTimedBuffer(size_t size, sp<IMemory>* buffer) {
         Parcel data, reply;
         data.writeInterfaceToken(IAudioTrack::getInterfaceDescriptor());
-        data.writeInt32(size);
+        data.writeInt64(size);
         status_t status = remote()->transact(ALLOCATE_TIMED_BUFFER,
                                              data, &reply);
         if (status == NO_ERROR) {
@@ -238,7 +238,7 @@
         case ALLOCATE_TIMED_BUFFER: {
             CHECK_INTERFACE(IAudioTrack, data, reply);
             sp<IMemory> buffer;
-            status_t status = allocateTimedBuffer(data.readInt32(), &buffer);
+            status_t status = allocateTimedBuffer(data.readInt64(), &buffer);
             reply->writeInt32(status);
             if (status == NO_ERROR) {
                 reply->writeStrongBinder(buffer->asBinder());
diff --git a/media/libmedia/IMediaLogService.cpp b/media/libmedia/IMediaLogService.cpp
index 33239a7..8a66c7c 100644
--- a/media/libmedia/IMediaLogService.cpp
+++ b/media/libmedia/IMediaLogService.cpp
@@ -43,7 +43,7 @@
         Parcel data, reply;
         data.writeInterfaceToken(IMediaLogService::getInterfaceDescriptor());
         data.writeStrongBinder(shared->asBinder());
-        data.writeInt32((int32_t) size);
+        data.writeInt64((int64_t) size);
         data.writeCString(name);
         status_t status = remote()->transact(REGISTER_WRITER, data, &reply);
         // FIXME ignores status
@@ -71,7 +71,7 @@
         case REGISTER_WRITER: {
             CHECK_INTERFACE(IMediaLogService, data, reply);
             sp<IMemory> shared = interface_cast<IMemory>(data.readStrongBinder());
-            size_t size = (size_t) data.readInt32();
+            size_t size = (size_t) data.readInt64();
             const char *name = data.readCString();
             registerWriter(shared, size, name);
             return NO_ERROR;
diff --git a/media/libmedia/IMediaMetadataRetriever.cpp b/media/libmedia/IMediaMetadataRetriever.cpp
index c7d9d51..432d890 100644
--- a/media/libmedia/IMediaMetadataRetriever.cpp
+++ b/media/libmedia/IMediaMetadataRetriever.cpp
@@ -101,7 +101,7 @@
             data.writeInt32(0);
         } else {
             // serialize the headers
-            data.writeInt32(headers->size());
+            data.writeInt64(headers->size());
             for (size_t i = 0; i < headers->size(); ++i) {
                 data.writeString8(headers->keyAt(i));
                 data.writeString8(headers->valueAt(i));
@@ -212,8 +212,8 @@
             const char* srcUrl = data.readCString();
 
             KeyedVector<String8, String8> headers;
-            int32_t numHeaders = data.readInt32();
-            for (int i = 0; i < numHeaders; ++i) {
+            size_t numHeaders = (size_t) data.readInt64();
+            for (size_t i = 0; i < numHeaders; ++i) {
                 String8 key = data.readString8();
                 String8 value = data.readString8();
                 headers.add(key, value);
diff --git a/media/libmedia/IOMX.cpp b/media/libmedia/IOMX.cpp
index 71ce320..9c13848 100644
--- a/media/libmedia/IOMX.cpp
+++ b/media/libmedia/IOMX.cpp
@@ -140,7 +140,7 @@
         data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
         data.writeIntPtr((intptr_t)node);
         data.writeInt32(index);
-        data.writeInt32(size);
+        data.writeInt64(size);
         data.write(params, size);
         remote()->transact(GET_PARAMETER, data, &reply);
 
@@ -161,7 +161,7 @@
         data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
         data.writeIntPtr((intptr_t)node);
         data.writeInt32(index);
-        data.writeInt32(size);
+        data.writeInt64(size);
         data.write(params, size);
         remote()->transact(SET_PARAMETER, data, &reply);
 
@@ -175,7 +175,7 @@
         data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
         data.writeIntPtr((intptr_t)node);
         data.writeInt32(index);
-        data.writeInt32(size);
+        data.writeInt64(size);
         data.write(params, size);
         remote()->transact(GET_CONFIG, data, &reply);
 
@@ -196,7 +196,7 @@
         data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
         data.writeIntPtr((intptr_t)node);
         data.writeInt32(index);
-        data.writeInt32(size);
+        data.writeInt64(size);
         data.write(params, size);
         remote()->transact(SET_CONFIG, data, &reply);
 
@@ -375,7 +375,7 @@
         data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
         data.writeIntPtr((intptr_t)node);
         data.writeInt32(port_index);
-        data.writeInt32(size);
+        data.writeInt64(size);
         remote()->transact(ALLOC_BUFFER, data, &reply);
 
         status_t err = reply.readInt32();
@@ -484,7 +484,7 @@
         data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
         data.writeIntPtr((intptr_t)node);
         data.writeInt32(port_index);
-        data.writeInt32(size);
+        data.writeInt64(size);
         data.write(optionData, size);
         data.writeInt32(type);
         remote()->transact(SET_INTERNAL_OPTION, data, &reply);
@@ -596,7 +596,7 @@
             node_id node = (void*)data.readIntPtr();
             OMX_INDEXTYPE index = static_cast<OMX_INDEXTYPE>(data.readInt32());
 
-            size_t size = data.readInt32();
+            size_t size = data.readInt64();
 
             void *params = malloc(size);
             data.read(params, size);
@@ -810,7 +810,7 @@
 
             node_id node = (void*)data.readIntPtr();
             OMX_U32 port_index = data.readInt32();
-            size_t size = data.readInt32();
+            size_t size = data.readInt64();
 
             buffer_id buffer;
             void *buffer_data;
diff --git a/media/libmedia/IStreamSource.cpp b/media/libmedia/IStreamSource.cpp
index 68ffca8..fe2cc61 100644
--- a/media/libmedia/IStreamSource.cpp
+++ b/media/libmedia/IStreamSource.cpp
@@ -62,7 +62,7 @@
     virtual void setBuffers(const Vector<sp<IMemory> > &buffers) {
         Parcel data, reply;
         data.writeInterfaceToken(IStreamSource::getInterfaceDescriptor());
-        data.writeInt32(static_cast<int32_t>(buffers.size()));
+        data.writeInt64(static_cast<int64_t>(buffers.size()));
         for (size_t i = 0; i < buffers.size(); ++i) {
             data.writeStrongBinder(buffers.itemAt(i)->asBinder());
         }
@@ -72,7 +72,7 @@
     virtual void onBufferAvailable(size_t index) {
         Parcel data, reply;
         data.writeInterfaceToken(IStreamSource::getInterfaceDescriptor());
-        data.writeInt32(static_cast<int32_t>(index));
+        data.writeInt64(static_cast<int64_t>(index));
         remote()->transact(
                 ON_BUFFER_AVAILABLE, data, &reply, IBinder::FLAG_ONEWAY);
     }
@@ -102,7 +102,7 @@
         case SET_BUFFERS:
         {
             CHECK_INTERFACE(IStreamSource, data, reply);
-            size_t n = static_cast<size_t>(data.readInt32());
+            size_t n = static_cast<size_t>(data.readInt64());
             Vector<sp<IMemory> > buffers;
             for (size_t i = 0; i < n; ++i) {
                 sp<IMemory> mem =
@@ -117,7 +117,7 @@
         case ON_BUFFER_AVAILABLE:
         {
             CHECK_INTERFACE(IStreamSource, data, reply);
-            onBufferAvailable(static_cast<size_t>(data.readInt32()));
+            onBufferAvailable(static_cast<size_t>(data.readInt64()));
             break;
         }
 
@@ -145,8 +145,8 @@
     virtual void queueBuffer(size_t index, size_t size) {
         Parcel data, reply;
         data.writeInterfaceToken(IStreamListener::getInterfaceDescriptor());
-        data.writeInt32(static_cast<int32_t>(index));
-        data.writeInt32(static_cast<int32_t>(size));
+        data.writeInt64(static_cast<int64_t>(index));
+        data.writeInt64(static_cast<int64_t>(size));
 
         remote()->transact(QUEUE_BUFFER, data, &reply, IBinder::FLAG_ONEWAY);
     }
@@ -177,8 +177,8 @@
         case QUEUE_BUFFER:
         {
             CHECK_INTERFACE(IStreamListener, data, reply);
-            size_t index = static_cast<size_t>(data.readInt32());
-            size_t size = static_cast<size_t>(data.readInt32());
+            size_t index = static_cast<size_t>(data.readInt64());
+            size_t size = static_cast<size_t>(data.readInt64());
 
             queueBuffer(index, size);
             break;
diff --git a/media/libmedia/MemoryLeakTrackUtil.cpp b/media/libmedia/MemoryLeakTrackUtil.cpp
index f004ca4..66f7161 100644
--- a/media/libmedia/MemoryLeakTrackUtil.cpp
+++ b/media/libmedia/MemoryLeakTrackUtil.cpp
@@ -17,6 +17,7 @@
 #include <media/MemoryLeakTrackUtil.h>
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <sys/types.h>
 #include <unistd.h>
 
diff --git a/media/libnbaio/NBLog.cpp b/media/libnbaio/NBLog.cpp
index 96738a7..4d9a1fa 100644
--- a/media/libnbaio/NBLog.cpp
+++ b/media/libnbaio/NBLog.cpp
@@ -343,7 +343,7 @@
     String8 timestamp, body;
     lost += i;
     if (lost > 0) {
-        body.appendFormat("warning: lost %u bytes worth of events", lost);
+        body.appendFormat("warning: lost %zu bytes worth of events", lost);
         // TODO timestamp empty here, only other choice to wait for the first timestamp event in the
         //      log to push it out.  Consider keeping the timestamp/body between calls to readAt().
         dumpLine(timestamp, body);
@@ -354,7 +354,7 @@
         maxSec /= 10;
     }
     if (maxSec >= 0) {
-        timestamp.appendFormat("[%*s]", width + 4, "");
+        timestamp.appendFormat("[%*s]", (int) width + 4, "");
     }
     bool deferredTimestamp = false;
     while (i < avail) {
@@ -364,7 +364,7 @@
         size_t advance = length + 3;
         switch (event) {
         case EVENT_STRING:
-            body.appendFormat("%.*s", length, (const char *) data);
+            body.appendFormat("%.*s", (int) length, (const char *) data);
             break;
         case EVENT_TIMESTAMP: {
             // already checked that length == sizeof(struct timespec);
diff --git a/media/libstagefright/ACodec.cpp b/media/libstagefright/ACodec.cpp
index f11791c..5bca317 100644
--- a/media/libstagefright/ACodec.cpp
+++ b/media/libstagefright/ACodec.cpp
@@ -17,6 +17,8 @@
 //#define LOG_NDEBUG 0
 #define LOG_TAG "ACodec"
 
+#include <utils/Trace.h>
+
 #include <media/stagefright/ACodec.h>
 
 #include <binder/MemoryDealer.h>
@@ -3681,6 +3683,7 @@
     if (mCodec->mNativeWindow != NULL
             && msg->findInt32("render", &render) && render != 0
             && info->mData != NULL && info->mData->size() != 0) {
+        ATRACE_NAME("render");
         // The client wants this buffer to be rendered.
 
         status_t err;
@@ -3693,6 +3696,10 @@
             info->mStatus = BufferInfo::OWNED_BY_US;
         }
     } else {
+        if (mCodec->mNativeWindow != NULL &&
+            (info->mData == NULL || info->mData->size() != 0)) {
+            ATRACE_NAME("frame-drop");
+        }
         info->mStatus = BufferInfo::OWNED_BY_US;
     }
 
diff --git a/media/libstagefright/Android.mk b/media/libstagefright/Android.mk
index 714b5e0..d9e39ff 100644
--- a/media/libstagefright/Android.mk
+++ b/media/libstagefright/Android.mk
@@ -14,6 +14,7 @@
         AwesomePlayer.cpp                 \
         CameraSource.cpp                  \
         CameraSourceTimeLapse.cpp         \
+        ClockEstimator.cpp                \
         DataSource.cpp                    \
         DataURISource.cpp                 \
         DRMExtractor.cpp                  \
diff --git a/media/libstagefright/AwesomePlayer.cpp b/media/libstagefright/AwesomePlayer.cpp
index e924076..8d3032b 100644
--- a/media/libstagefright/AwesomePlayer.cpp
+++ b/media/libstagefright/AwesomePlayer.cpp
@@ -42,6 +42,7 @@
 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/timedtext/TimedTextDriver.h>
 #include <media/stagefright/AudioPlayer.h>
+#include <media/stagefright/ClockEstimator.h>
 #include <media/stagefright/DataSource.h>
 #include <media/stagefright/FileSource.h>
 #include <media/stagefright/MediaBuffer.h>
@@ -231,6 +232,8 @@
                               &AwesomePlayer::onAudioTearDownEvent);
     mAudioTearDownEventPending = false;
 
+    mClockEstimator = new WindowedLinearFitEstimator();
+
     reset();
 }
 
@@ -718,11 +721,9 @@
                 finishAsyncPrepare_l();
             }
         } else {
-            int64_t bitrate;
-            if (getBitrate(&bitrate)) {
-                size_t cachedSize = mCachedSource->cachedSize();
-                int64_t cachedDurationUs = cachedSize * 8000000ll / bitrate;
-
+            bool eos2;
+            int64_t cachedDurationUs;
+            if (getCachedDuration_l(&cachedDurationUs, &eos2) && mDurationUs > 0) {
                 int percentage = 100.0 * (double)cachedDurationUs / mDurationUs;
                 if (percentage > 100) {
                     percentage = 100;
@@ -730,7 +731,7 @@
 
                 notifyListener_l(MEDIA_BUFFERING_UPDATE, percentage);
             } else {
-                // We don't know the bitrate of the stream, use absolute size
+                // We don't know the bitrate/duration of the stream, use absolute size
                 // limits to maintain the cache.
 
                 if ((mFlags & PLAYING) && !eos
@@ -1868,21 +1869,28 @@
     TimeSource *ts =
         ((mFlags & AUDIO_AT_EOS) || !(mFlags & AUDIOPLAYER_STARTED))
             ? &mSystemTimeSource : mTimeSource;
+    int64_t systemTimeUs = mSystemTimeSource.getRealTimeUs();
+    int64_t looperTimeUs = ALooper::GetNowUs();
 
     if (mFlags & FIRST_FRAME) {
         modifyFlags(FIRST_FRAME, CLEAR);
         mSinceLastDropped = 0;
-        mTimeSourceDeltaUs = ts->getRealTimeUs() - timeUs;
+        mClockEstimator->reset();
+        mTimeSourceDeltaUs = estimateRealTimeUs(ts, systemTimeUs) - timeUs;
     }
 
     int64_t realTimeUs, mediaTimeUs;
     if (!(mFlags & AUDIO_AT_EOS) && mAudioPlayer != NULL
         && mAudioPlayer->getMediaTimeMapping(&realTimeUs, &mediaTimeUs)) {
+        ALOGV("updating TSdelta (%" PRId64 " => %" PRId64 " change %" PRId64 ")",
+              mTimeSourceDeltaUs, realTimeUs - mediaTimeUs,
+              mTimeSourceDeltaUs - (realTimeUs - mediaTimeUs));
+        ATRACE_INT("TS delta change (ms)", (mTimeSourceDeltaUs - (realTimeUs - mediaTimeUs)) / 1E3);
         mTimeSourceDeltaUs = realTimeUs - mediaTimeUs;
     }
 
     if (wasSeeking == SEEK_VIDEO_ONLY) {
-        int64_t nowUs = ts->getRealTimeUs() - mTimeSourceDeltaUs;
+        int64_t nowUs = estimateRealTimeUs(ts, systemTimeUs) - mTimeSourceDeltaUs;
 
         int64_t latenessUs = nowUs - timeUs;
 
@@ -1893,12 +1901,13 @@
         }
     }
 
+    int64_t latenessUs = 0;
     if (wasSeeking == NO_SEEK) {
         // Let's display the first frame after seeking right away.
 
-        int64_t nowUs = ts->getRealTimeUs() - mTimeSourceDeltaUs;
+        int64_t nowUs = estimateRealTimeUs(ts, systemTimeUs) - mTimeSourceDeltaUs;
 
-        int64_t latenessUs = nowUs - timeUs;
+        latenessUs = nowUs - timeUs;
 
         ATRACE_INT("Video Lateness (ms)", latenessUs / 1E3);
 
@@ -1952,9 +1961,9 @@
             }
         }
 
-        if (latenessUs < -10000) {
-            // We're more than 10ms early.
-            postVideoEvent_l(10000);
+        if (latenessUs < -30000) {
+            // We're more than 30ms early, schedule at most 20 ms before time due
+            postVideoEvent_l(latenessUs < -60000 ? 30000 : -latenessUs - 20000);
             return;
         }
     }
@@ -1968,6 +1977,8 @@
 
     if (mVideoRenderer != NULL) {
         mSinceLastDropped++;
+        mVideoBuffer->meta_data()->setInt64(kKeyTime, looperTimeUs - latenessUs);
+
         mVideoRenderer->render(mVideoBuffer);
         if (!mVideoRenderingStarted) {
             mVideoRenderingStarted = true;
@@ -2017,14 +2028,26 @@
 
         int64_t nextTimeUs;
         CHECK(mVideoBuffer->meta_data()->findInt64(kKeyTime, &nextTimeUs));
-        int64_t delayUs = nextTimeUs - ts->getRealTimeUs() + mTimeSourceDeltaUs;
-        postVideoEvent_l(delayUs > 10000 ? 10000 : delayUs < 0 ? 0 : delayUs);
+        systemTimeUs = mSystemTimeSource.getRealTimeUs();
+        int64_t delayUs = nextTimeUs - estimateRealTimeUs(ts, systemTimeUs) + mTimeSourceDeltaUs;
+        ATRACE_INT("Frame delta (ms)", (nextTimeUs - timeUs) / 1E3);
+        ALOGV("next frame in %" PRId64, delayUs);
+        // try to schedule 30ms before time due
+        postVideoEvent_l(delayUs > 60000 ? 30000 : (delayUs < 30000 ? 0 : delayUs - 30000));
         return;
     }
 
     postVideoEvent_l();
 }
 
+int64_t AwesomePlayer::estimateRealTimeUs(TimeSource *ts, int64_t systemTimeUs) {
+    if (ts == &mSystemTimeSource) {
+        return systemTimeUs;
+    } else {
+        return (int64_t)mClockEstimator->estimate(systemTimeUs, ts->getRealTimeUs());
+    }
+}
+
 void AwesomePlayer::postVideoEvent_l(int64_t delayUs) {
     ATRACE_CALL();
 
diff --git a/media/libstagefright/ClockEstimator.cpp b/media/libstagefright/ClockEstimator.cpp
new file mode 100644
index 0000000..34d1e42
--- /dev/null
+++ b/media/libstagefright/ClockEstimator.cpp
@@ -0,0 +1,177 @@
+/*
+**
+** Copyright 2014, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "ClockEstimator"
+#include <utils/Log.h>
+
+#include <math.h>
+#include <media/stagefright/ClockEstimator.h>
+
+#include <media/stagefright/foundation/ADebug.h>
+
+namespace android {
+
+WindowedLinearFitEstimator::WindowedLinearFitEstimator(
+        size_t headLength, double headFactor, size_t mainLength, double tailFactor)
+    : mHeadFactorInv(1. / headFactor),
+      mTailFactor(tailFactor),
+      mHistoryLength(mainLength + headLength),
+      mHeadLength(headLength) {
+    reset();
+    mXHistory.resize(mHistoryLength);
+    mYHistory.resize(mHistoryLength);
+    mFirstWeight = pow(headFactor, mHeadLength);
+}
+
+WindowedLinearFitEstimator::LinearFit::LinearFit() {
+    reset();
+}
+
+void WindowedLinearFitEstimator::LinearFit::reset() {
+    mX = mXX = mY = mYY = mXY = mW = 0.;
+}
+
+double WindowedLinearFitEstimator::LinearFit::size() const {
+    double s = mW * mW + mX * mX + mY * mY + mXX * mXX + mXY * mXY + mYY * mYY;
+    if (s > 1e72) {
+        // 1e72 corresponds to clock monotonic time of about 8 years
+        ALOGW("estimator is overflowing: w=%g x=%g y=%g xx=%g xy=%g yy=%g",
+              mW, mX, mY, mXX, mXY, mYY);
+    }
+    return s;
+}
+
+void WindowedLinearFitEstimator::LinearFit::add(double x, double y, double w) {
+    mW += w;
+    mX += w * x;
+    mY += w * y;
+    mXX += w * x * x;
+    mXY += w * x * y;
+    mYY += w * y * y;
+}
+
+void WindowedLinearFitEstimator::LinearFit::combine(const LinearFit &lf) {
+    mW += lf.mW;
+    mX += lf.mX;
+    mY += lf.mY;
+    mXX += lf.mXX;
+    mXY += lf.mXY;
+    mYY += lf.mYY;
+}
+
+void WindowedLinearFitEstimator::LinearFit::scale(double w) {
+    mW *= w;
+    mX *= w;
+    mY *= w;
+    mXX *= w;
+    mXY *= w;
+    mYY *= w;
+}
+
+double WindowedLinearFitEstimator::LinearFit::interpolate(double x) {
+    double div = mW * mXX - mX * mX;
+    if (fabs(div) < 1e-5 * mW * mW) {
+        // this only should happen on the first value
+        return x;
+        // assuming a = 1, we could also return x + (mY - mX) / mW;
+    }
+    double a_div = (mW * mXY - mX * mY);
+    double b_div = (mXX * mY - mX * mXY);
+    ALOGV("a=%.4g b=%.4g in=%g out=%g",
+            a_div / div, b_div / div, x, (a_div * x + b_div) / div);
+    return (a_div * x + b_div) / div;
+}
+
+double WindowedLinearFitEstimator::estimate(double x, double y) {
+    /*
+     * TODO: We could update the head by adding the new sample to it
+     * and amplifying it, but this approach can lead to unbounded
+     * error. Instead, we recalculate the head at each step, which
+     * is computationally more expensive. We could balance the two
+     * methods by recalculating just before the error becomes
+     * significant.
+     */
+    const bool update_head = false;
+    if (update_head) {
+        // add new sample to the head
+        mHead.scale(mHeadFactorInv); // amplify head
+        mHead.add(x, y, mFirstWeight);
+    }
+
+    /*
+     * TRICKY: place elements into the circular buffer at decreasing
+     * indices, so that we can access past elements by addition
+     * (thereby avoiding potentially negative indices.)
+     */
+    if (mNumSamples >= mHeadLength) {
+        // move last head sample from head to the main window
+        size_t lastHeadIx = (mSampleIx + mHeadLength) % mHistoryLength;
+        if (update_head) {
+            mHead.add(mXHistory[lastHeadIx], mYHistory[lastHeadIx], -1.); // remove
+        }
+        mMain.add(mXHistory[lastHeadIx], mYHistory[lastHeadIx], 1.);
+        if (mNumSamples >= mHistoryLength) {
+            // move last main sample from main window to tail
+            mMain.add(mXHistory[mSampleIx], mYHistory[mSampleIx], -1.); // remove
+            mTail.add(mXHistory[mSampleIx], mYHistory[mSampleIx], 1.);
+            mTail.scale(mTailFactor); // attenuate tail
+        }
+    }
+
+    mXHistory.editItemAt(mSampleIx) = x;
+    mYHistory.editItemAt(mSampleIx) = y;
+    if (mNumSamples < mHistoryLength) {
+        ++mNumSamples;
+    }
+
+    // recalculate head unless we were using the update method
+    if (!update_head) {
+        mHead.reset();
+        double w = mFirstWeight;
+        for (size_t headIx = 0; headIx < mHeadLength && headIx < mNumSamples; ++headIx) {
+            size_t ix = (mSampleIx + headIx) % mHistoryLength;
+            mHead.add(mXHistory[ix], mYHistory[ix], w);
+            w *= mHeadFactorInv;
+        }
+    }
+
+    if (mSampleIx > 0) {
+        --mSampleIx;
+    } else {
+        mSampleIx = mHistoryLength - 1;
+    }
+
+    // return estimation result
+    LinearFit total;
+    total.combine(mHead);
+    total.combine(mMain);
+    total.combine(mTail);
+    return total.interpolate(x);
+}
+
+void WindowedLinearFitEstimator::reset() {
+    mHead.reset();
+    mMain.reset();
+    mTail.reset();
+    mNumSamples = 0;
+    mSampleIx = mHistoryLength - 1;
+}
+
+}; // namespace android
+
+
diff --git a/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp b/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp
index 515e4d3..8f356b6 100644
--- a/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp
+++ b/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp
@@ -355,7 +355,12 @@
         outHeader->nFlags = 0;
         int err = vorbis_dsp_synthesis(mState, &pack, 1);
         if (err != 0) {
+            // FIXME temporary workaround for log spam
+#if !defined(__arm__) && !defined(__aarch64__)
+            ALOGV("vorbis_dsp_synthesis returned %d", err);
+#else
             ALOGW("vorbis_dsp_synthesis returned %d", err);
+#endif
         } else {
             numFrames = vorbis_dsp_pcmout(
                     mState, (int16_t *)outHeader->pBuffer,
diff --git a/media/libstagefright/httplive/PlaylistFetcher.cpp b/media/libstagefright/httplive/PlaylistFetcher.cpp
index 5011bc1..c34f3cb 100644
--- a/media/libstagefright/httplive/PlaylistFetcher.cpp
+++ b/media/libstagefright/httplive/PlaylistFetcher.cpp
@@ -916,6 +916,7 @@
 
         if (err == -EAGAIN) {
             // bad starting sequence number hint
+            mTSParser.clear();
             postMonitorQueue();
             return;
         }
diff --git a/media/libstagefright/include/AwesomePlayer.h b/media/libstagefright/include/AwesomePlayer.h
index a81bbba..77d65e0 100644
--- a/media/libstagefright/include/AwesomePlayer.h
+++ b/media/libstagefright/include/AwesomePlayer.h
@@ -32,6 +32,7 @@
 namespace android {
 
 struct AudioPlayer;
+struct ClockEstimator;
 struct DataSource;
 struct MediaBuffer;
 struct MediaExtractor;
@@ -236,6 +237,7 @@
 
     MediaBuffer *mVideoBuffer;
 
+    sp<ClockEstimator> mClockEstimator;
     sp<HTTPBase> mConnectingDataSource;
     sp<NuCachedSource2> mCachedSource;
 
@@ -296,6 +298,7 @@
 
     bool getBitrate(int64_t *bitrate);
 
+    int64_t estimateRealTimeUs(TimeSource *ts, int64_t systemTimeUs);
     void finishSeekIfNecessary(int64_t videoTimeUs);
     void ensureCacheIsFetching_l();
 
diff --git a/services/audioflinger/Android.mk b/services/audioflinger/Android.mk
index 27e38a3..8d0a705 100644
--- a/services/audioflinger/Android.mk
+++ b/services/audioflinger/Android.mk
@@ -61,7 +61,8 @@
 LOCAL_MODULE:= libaudioflinger
 LOCAL_32_BIT_ONLY := true
 
-LOCAL_SRC_FILES += FastMixer.cpp FastMixerState.cpp AudioWatchdog.cpp FastThreadState.cpp
+LOCAL_SRC_FILES += FastMixer.cpp FastMixerState.cpp AudioWatchdog.cpp
+LOCAL_SRC_FILES += FastThread.cpp FastThreadState.cpp
 
 LOCAL_CFLAGS += -DSTATE_QUEUE_INSTANTIATIONS='"StateQueueInstantiations.cpp"'
 
diff --git a/services/audioflinger/Configuration.h b/services/audioflinger/Configuration.h
index 0754d9d..6a8aeb1 100644
--- a/services/audioflinger/Configuration.h
+++ b/services/audioflinger/Configuration.h
@@ -31,6 +31,7 @@
 
 // uncomment to enable fast mixer to take performance samples for later statistical analysis
 #define FAST_MIXER_STATISTICS
+// FIXME rename to FAST_THREAD_STATISTICS
 
 // uncomment for debugging timing problems related to StateQueue::push()
 //#define STATE_QUEUE_DUMP
diff --git a/services/audioflinger/FastMixer.cpp b/services/audioflinger/FastMixer.cpp
index ca0d65e..5cb42cc 100644
--- a/services/audioflinger/FastMixer.cpp
+++ b/services/audioflinger/FastMixer.cpp
@@ -40,619 +40,385 @@
 #include "AudioMixer.h"
 #include "FastMixer.h"
 
-#define FAST_HOT_IDLE_NS     1000000L   // 1 ms: time to sleep while hot idling
-#define FAST_DEFAULT_NS    999999999L   // ~1 sec: default time to sleep
-#define MIN_WARMUP_CYCLES          2    // minimum number of loop cycles to wait for warmup
-#define MAX_WARMUP_CYCLES         10    // maximum number of loop cycles to wait for warmup
-
 #define FCC_2                       2   // fixed channel count assumption
 
 namespace android {
 
-// Fast mixer thread
-bool FastMixer::threadLoop()
+/*static*/ const FastMixerState FastMixer::initial;
+
+FastMixer::FastMixer() : FastThread(),
+    slopNs(0),
+    // fastTrackNames
+    // generations
+    outputSink(NULL),
+    outputSinkGen(0),
+    mixer(NULL),
+    mixBuffer(NULL),
+    mixBufferState(UNDEFINED),
+    format(Format_Invalid),
+    sampleRate(0),
+    fastTracksGen(0),
+    totalNativeFramesWritten(0),
+    // timestamp
+    nativeFramesWrittenButNotPresented(0)   // the = 0 is to silence the compiler
 {
-    static const FastMixerState initial;
-    const FastMixerState *previous = &initial, *current = &initial;
-    FastMixerState preIdle; // copy of state before we went into idle
-    struct timespec oldTs = {0, 0};
-    bool oldTsValid = false;
-    long slopNs = 0;    // accumulated time we've woken up too early (> 0) or too late (< 0)
-    long sleepNs = -1;  // -1: busy wait, 0: sched_yield, > 0: nanosleep
-    int fastTrackNames[FastMixerState::kMaxFastTracks]; // handles used by mixer to identify tracks
-    int generations[FastMixerState::kMaxFastTracks];    // last observed mFastTracks[i].mGeneration
+    // FIXME pass initial as parameter to base class constructor, and make it static local
+    previous = &initial;
+    current = &initial;
+
+    mDummyDumpState = &dummyDumpState;
+
     unsigned i;
     for (i = 0; i < FastMixerState::kMaxFastTracks; ++i) {
         fastTrackNames[i] = -1;
         generations[i] = 0;
     }
-    NBAIO_Sink *outputSink = NULL;
-    int outputSinkGen = 0;
-    AudioMixer* mixer = NULL;
-    short *mixBuffer = NULL;
-    enum {UNDEFINED, MIXED, ZEROED} mixBufferState = UNDEFINED;
-    NBAIO_Format format = Format_Invalid;
-    unsigned sampleRate = 0;
-    int fastTracksGen = 0;
-    long periodNs = 0;      // expected period; the time required to render one mix buffer
-    long underrunNs = 0;    // underrun likely when write cycle is greater than this value
-    long overrunNs = 0;     // overrun likely when write cycle is less than this value
-    long forceNs = 0;       // if overrun detected, force the write cycle to take this much time
-    long warmupNs = 0;      // warmup complete when write cycle is greater than to this value
-    FastMixerDumpState dummyDumpState, *dumpState = &dummyDumpState;
-    bool ignoreNextOverrun = true;  // used to ignore initial overrun and first after an underrun
 #ifdef FAST_MIXER_STATISTICS
-    struct timespec oldLoad = {0, 0};    // previous value of clock_gettime(CLOCK_THREAD_CPUTIME_ID)
-    bool oldLoadValid = false;  // whether oldLoad is valid
-    uint32_t bounds = 0;
-    bool full = false;      // whether we have collected at least mSamplingN samples
-#ifdef CPU_FREQUENCY_STATISTICS
-    ThreadCpuUsage tcu;     // for reading the current CPU clock frequency in kHz
+    oldLoad.tv_sec = 0;
+    oldLoad.tv_nsec = 0;
 #endif
+}
+
+FastMixer::~FastMixer()
+{
+}
+
+FastMixerStateQueue* FastMixer::sq()
+{
+    return &mSQ;
+}
+
+const FastThreadState *FastMixer::poll()
+{
+    return mSQ.poll();
+}
+
+void FastMixer::setLog(NBLog::Writer *logWriter)
+{
+    if (mixer != NULL) {
+        mixer->setLog(logWriter);
+    }
+}
+
+void FastMixer::onIdle()
+{
+    preIdle = *(const FastMixerState *)current;
+    current = &preIdle;
+}
+
+void FastMixer::onExit()
+{
+    delete mixer;
+    delete[] mixBuffer;
+}
+
+bool FastMixer::isSubClassCommand(FastThreadState::Command command)
+{
+    switch ((FastMixerState::Command) command) {
+    case FastMixerState::MIX:
+    case FastMixerState::WRITE:
+    case FastMixerState::MIX_WRITE:
+        return true;
+    default:
+        return false;
+    }
+}
+
+void FastMixer::onStateChange()
+{
+    const FastMixerState * const current = (const FastMixerState *) this->current;
+    const FastMixerState * const previous = (const FastMixerState *) this->previous;
+    FastMixerDumpState * const dumpState = (FastMixerDumpState *) this->dumpState;
+    const size_t frameCount = current->mFrameCount;
+
+    // handle state change here, but since we want to diff the state,
+    // we're prepared for previous == &initial the first time through
+    unsigned previousTrackMask;
+
+    // check for change in output HAL configuration
+    NBAIO_Format previousFormat = format;
+    if (current->mOutputSinkGen != outputSinkGen) {
+        outputSink = current->mOutputSink;
+        outputSinkGen = current->mOutputSinkGen;
+        if (outputSink == NULL) {
+            format = Format_Invalid;
+            sampleRate = 0;
+        } else {
+            format = outputSink->format();
+            sampleRate = Format_sampleRate(format);
+            ALOG_ASSERT(Format_channelCount(format) == FCC_2);
+        }
+        dumpState->mSampleRate = sampleRate;
+    }
+
+    if ((!Format_isEqual(format, previousFormat)) || (frameCount != previous->mFrameCount)) {
+        // FIXME to avoid priority inversion, don't delete here
+        delete mixer;
+        mixer = NULL;
+        delete[] mixBuffer;
+        mixBuffer = NULL;
+        if (frameCount > 0 && sampleRate > 0) {
+            // FIXME new may block for unbounded time at internal mutex of the heap
+            //       implementation; it would be better to have normal mixer allocate for us
+            //       to avoid blocking here and to prevent possible priority inversion
+            mixer = new AudioMixer(frameCount, sampleRate, FastMixerState::kMaxFastTracks);
+            mixBuffer = new short[frameCount * FCC_2];
+            periodNs = (frameCount * 1000000000LL) / sampleRate;    // 1.00
+            underrunNs = (frameCount * 1750000000LL) / sampleRate;  // 1.75
+            overrunNs = (frameCount * 500000000LL) / sampleRate;    // 0.50
+            forceNs = (frameCount * 950000000LL) / sampleRate;      // 0.95
+            warmupNs = (frameCount * 500000000LL) / sampleRate;     // 0.50
+        } else {
+            periodNs = 0;
+            underrunNs = 0;
+            overrunNs = 0;
+            forceNs = 0;
+            warmupNs = 0;
+        }
+        mixBufferState = UNDEFINED;
+#if !LOG_NDEBUG
+        for (unsigned i = 0; i < FastMixerState::kMaxFastTracks; ++i) {
+            fastTrackNames[i] = -1;
+        }
 #endif
-    unsigned coldGen = 0;   // last observed mColdGen
-    bool isWarm = false;    // true means ready to mix, false means wait for warmup before mixing
-    struct timespec measuredWarmupTs = {0, 0};  // how long did it take for warmup to complete
-    uint32_t warmupCycles = 0;  // counter of number of loop cycles required to warmup
-    NBAIO_Sink* teeSink = NULL; // if non-NULL, then duplicate write() to this non-blocking sink
-    NBLog::Writer dummyLogWriter, *logWriter = &dummyLogWriter;
-    uint32_t totalNativeFramesWritten = 0;  // copied to dumpState->mFramesWritten
+        // we need to reconfigure all active tracks
+        previousTrackMask = 0;
+        fastTracksGen = current->mFastTracksGen - 1;
+        dumpState->mFrameCount = frameCount;
+    } else {
+        previousTrackMask = previous->mTrackMask;
+    }
 
-    // next 2 fields are valid only when timestampStatus == NO_ERROR
-    AudioTimestamp timestamp;
-    uint32_t nativeFramesWrittenButNotPresented = 0;    // the = 0 is to silence the compiler
-    status_t timestampStatus = INVALID_OPERATION;
+    // check for change in active track set
+    const unsigned currentTrackMask = current->mTrackMask;
+    dumpState->mTrackMask = currentTrackMask;
+    if (current->mFastTracksGen != fastTracksGen) {
+        ALOG_ASSERT(mixBuffer != NULL);
+        int name;
 
-    for (;;) {
-
-        // either nanosleep, sched_yield, or busy wait
-        if (sleepNs >= 0) {
-            if (sleepNs > 0) {
-                ALOG_ASSERT(sleepNs < 1000000000);
-                const struct timespec req = {0, sleepNs};
-                nanosleep(&req, NULL);
-            } else {
-                sched_yield();
-            }
-        }
-        // default to long sleep for next cycle
-        sleepNs = FAST_DEFAULT_NS;
-
-        // poll for state change
-        const FastMixerState *next = mSQ.poll();
-        if (next == NULL) {
-            // continue to use the default initial state until a real state is available
-            ALOG_ASSERT(current == &initial && previous == &initial);
-            next = current;
-        }
-
-        FastMixerState::Command command = next->mCommand;
-        if (next != current) {
-
-            // As soon as possible of learning of a new dump area, start using it
-            dumpState = next->mDumpState != NULL ? next->mDumpState : &dummyDumpState;
-            teeSink = next->mTeeSink;
-            logWriter = next->mNBLogWriter != NULL ? next->mNBLogWriter : &dummyLogWriter;
+        // process removed tracks first to avoid running out of track names
+        unsigned removedTracks = previousTrackMask & ~currentTrackMask;
+        while (removedTracks != 0) {
+            int i = __builtin_ctz(removedTracks);
+            removedTracks &= ~(1 << i);
+            const FastTrack* fastTrack = &current->mFastTracks[i];
+            ALOG_ASSERT(fastTrack->mBufferProvider == NULL);
             if (mixer != NULL) {
-                mixer->setLog(logWriter);
-            }
-
-            // We want to always have a valid reference to the previous (non-idle) state.
-            // However, the state queue only guarantees access to current and previous states.
-            // So when there is a transition from a non-idle state into an idle state, we make a
-            // copy of the last known non-idle state so it is still available on return from idle.
-            // The possible transitions are:
-            //  non-idle -> non-idle    update previous from current in-place
-            //  non-idle -> idle        update previous from copy of current
-            //  idle     -> idle        don't update previous
-            //  idle     -> non-idle    don't update previous
-            if (!(current->mCommand & FastMixerState::IDLE)) {
-                if (command & FastMixerState::IDLE) {
-                    preIdle = *current;
-                    current = &preIdle;
-                    oldTsValid = false;
-#ifdef FAST_MIXER_STATISTICS
-                    oldLoadValid = false;
-#endif
-                    ignoreNextOverrun = true;
-                }
-                previous = current;
-            }
-            current = next;
-        }
-#if !LOG_NDEBUG
-        next = NULL;    // not referenced again
-#endif
-
-        dumpState->mCommand = command;
-
-        switch (command) {
-        case FastMixerState::INITIAL:
-        case FastMixerState::HOT_IDLE:
-            sleepNs = FAST_HOT_IDLE_NS;
-            continue;
-        case FastMixerState::COLD_IDLE:
-            // only perform a cold idle command once
-            // FIXME consider checking previous state and only perform if previous != COLD_IDLE
-            if (current->mColdGen != coldGen) {
-                int32_t *coldFutexAddr = current->mColdFutexAddr;
-                ALOG_ASSERT(coldFutexAddr != NULL);
-                int32_t old = android_atomic_dec(coldFutexAddr);
-                if (old <= 0) {
-                    __futex_syscall4(coldFutexAddr, FUTEX_WAIT_PRIVATE, old - 1, NULL);
-                }
-                int policy = sched_getscheduler(0);
-                if (!(policy == SCHED_FIFO || policy == SCHED_RR)) {
-                    ALOGE("did not receive expected priority boost");
-                }
-                // This may be overly conservative; there could be times that the normal mixer
-                // requests such a brief cold idle that it doesn't require resetting this flag.
-                isWarm = false;
-                measuredWarmupTs.tv_sec = 0;
-                measuredWarmupTs.tv_nsec = 0;
-                warmupCycles = 0;
-                sleepNs = -1;
-                coldGen = current->mColdGen;
-#ifdef FAST_MIXER_STATISTICS
-                bounds = 0;
-                full = false;
-#endif
-                oldTsValid = !clock_gettime(CLOCK_MONOTONIC, &oldTs);
-                timestampStatus = INVALID_OPERATION;
-            } else {
-                sleepNs = FAST_HOT_IDLE_NS;
-            }
-            continue;
-        case FastMixerState::EXIT:
-            delete mixer;
-            delete[] mixBuffer;
-            return false;
-        case FastMixerState::MIX:
-        case FastMixerState::WRITE:
-        case FastMixerState::MIX_WRITE:
-            break;
-        default:
-            LOG_ALWAYS_FATAL("bad command %d", command);
-        }
-
-        // there is a non-idle state available to us; did the state change?
-        size_t frameCount = current->mFrameCount;
-        if (current != previous) {
-
-            // handle state change here, but since we want to diff the state,
-            // we're prepared for previous == &initial the first time through
-            unsigned previousTrackMask;
-
-            // check for change in output HAL configuration
-            NBAIO_Format previousFormat = format;
-            if (current->mOutputSinkGen != outputSinkGen) {
-                outputSink = current->mOutputSink;
-                outputSinkGen = current->mOutputSinkGen;
-                if (outputSink == NULL) {
-                    format = Format_Invalid;
-                    sampleRate = 0;
-                } else {
-                    format = outputSink->format();
-                    sampleRate = Format_sampleRate(format);
-                    ALOG_ASSERT(Format_channelCount(format) == FCC_2);
-                }
-                dumpState->mSampleRate = sampleRate;
-            }
-
-            if ((!Format_isEqual(format, previousFormat)) || (frameCount != previous->mFrameCount)) {
-                // FIXME to avoid priority inversion, don't delete here
-                delete mixer;
-                mixer = NULL;
-                delete[] mixBuffer;
-                mixBuffer = NULL;
-                if (frameCount > 0 && sampleRate > 0) {
-                    // FIXME new may block for unbounded time at internal mutex of the heap
-                    //       implementation; it would be better to have normal mixer allocate for us
-                    //       to avoid blocking here and to prevent possible priority inversion
-                    mixer = new AudioMixer(frameCount, sampleRate, FastMixerState::kMaxFastTracks);
-                    mixBuffer = new short[frameCount * FCC_2];
-                    periodNs = (frameCount * 1000000000LL) / sampleRate;    // 1.00
-                    underrunNs = (frameCount * 1750000000LL) / sampleRate;  // 1.75
-                    overrunNs = (frameCount * 500000000LL) / sampleRate;    // 0.50
-                    forceNs = (frameCount * 950000000LL) / sampleRate;      // 0.95
-                    warmupNs = (frameCount * 500000000LL) / sampleRate;     // 0.50
-                } else {
-                    periodNs = 0;
-                    underrunNs = 0;
-                    overrunNs = 0;
-                    forceNs = 0;
-                    warmupNs = 0;
-                }
-                mixBufferState = UNDEFINED;
-#if !LOG_NDEBUG
-                for (i = 0; i < FastMixerState::kMaxFastTracks; ++i) {
-                    fastTrackNames[i] = -1;
-                }
-#endif
-                // we need to reconfigure all active tracks
-                previousTrackMask = 0;
-                fastTracksGen = current->mFastTracksGen - 1;
-                dumpState->mFrameCount = frameCount;
-            } else {
-                previousTrackMask = previous->mTrackMask;
-            }
-
-            // check for change in active track set
-            unsigned currentTrackMask = current->mTrackMask;
-            dumpState->mTrackMask = currentTrackMask;
-            if (current->mFastTracksGen != fastTracksGen) {
-                ALOG_ASSERT(mixBuffer != NULL);
-                int name;
-
-                // process removed tracks first to avoid running out of track names
-                unsigned removedTracks = previousTrackMask & ~currentTrackMask;
-                while (removedTracks != 0) {
-                    i = __builtin_ctz(removedTracks);
-                    removedTracks &= ~(1 << i);
-                    const FastTrack* fastTrack = &current->mFastTracks[i];
-                    ALOG_ASSERT(fastTrack->mBufferProvider == NULL);
-                    if (mixer != NULL) {
-                        name = fastTrackNames[i];
-                        ALOG_ASSERT(name >= 0);
-                        mixer->deleteTrackName(name);
-                    }
-#if !LOG_NDEBUG
-                    fastTrackNames[i] = -1;
-#endif
-                    // don't reset track dump state, since other side is ignoring it
-                    generations[i] = fastTrack->mGeneration;
-                }
-
-                // now process added tracks
-                unsigned addedTracks = currentTrackMask & ~previousTrackMask;
-                while (addedTracks != 0) {
-                    i = __builtin_ctz(addedTracks);
-                    addedTracks &= ~(1 << i);
-                    const FastTrack* fastTrack = &current->mFastTracks[i];
-                    AudioBufferProvider *bufferProvider = fastTrack->mBufferProvider;
-                    ALOG_ASSERT(bufferProvider != NULL && fastTrackNames[i] == -1);
-                    if (mixer != NULL) {
-                        // calling getTrackName with default channel mask and a random invalid
-                        //   sessionId (no effects here)
-                        name = mixer->getTrackName(AUDIO_CHANNEL_OUT_STEREO, -555);
-                        ALOG_ASSERT(name >= 0);
-                        fastTrackNames[i] = name;
-                        mixer->setBufferProvider(name, bufferProvider);
-                        mixer->setParameter(name, AudioMixer::TRACK, AudioMixer::MAIN_BUFFER,
-                                (void *) mixBuffer);
-                        // newly allocated track names default to full scale volume
-                        mixer->setParameter(name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK,
-                                (void *)(uintptr_t)fastTrack->mChannelMask);
-                        mixer->enable(name);
-                    }
-                    generations[i] = fastTrack->mGeneration;
-                }
-
-                // finally process (potentially) modified tracks; these use the same slot
-                // but may have a different buffer provider or volume provider
-                unsigned modifiedTracks = currentTrackMask & previousTrackMask;
-                while (modifiedTracks != 0) {
-                    i = __builtin_ctz(modifiedTracks);
-                    modifiedTracks &= ~(1 << i);
-                    const FastTrack* fastTrack = &current->mFastTracks[i];
-                    if (fastTrack->mGeneration != generations[i]) {
-                        // this track was actually modified
-                        AudioBufferProvider *bufferProvider = fastTrack->mBufferProvider;
-                        ALOG_ASSERT(bufferProvider != NULL);
-                        if (mixer != NULL) {
-                            name = fastTrackNames[i];
-                            ALOG_ASSERT(name >= 0);
-                            mixer->setBufferProvider(name, bufferProvider);
-                            if (fastTrack->mVolumeProvider == NULL) {
-                                mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME0,
-                                        (void *)0x1000);
-                                mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME1,
-                                        (void *)0x1000);
-                            }
-                            mixer->setParameter(name, AudioMixer::RESAMPLE,
-                                    AudioMixer::REMOVE, NULL);
-                            mixer->setParameter(name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK,
-                                    (void *)(uintptr_t) fastTrack->mChannelMask);
-                            // already enabled
-                        }
-                        generations[i] = fastTrack->mGeneration;
-                    }
-                }
-
-                fastTracksGen = current->mFastTracksGen;
-
-                dumpState->mNumTracks = popcount(currentTrackMask);
-            }
-
-#if 1   // FIXME shouldn't need this
-            // only process state change once
-            previous = current;
-#endif
-        }
-
-        // do work using current state here
-        if ((command & FastMixerState::MIX) && (mixer != NULL) && isWarm) {
-            ALOG_ASSERT(mixBuffer != NULL);
-            // for each track, update volume and check for underrun
-            unsigned currentTrackMask = current->mTrackMask;
-            while (currentTrackMask != 0) {
-                i = __builtin_ctz(currentTrackMask);
-                currentTrackMask &= ~(1 << i);
-                const FastTrack* fastTrack = &current->mFastTracks[i];
-
-                // Refresh the per-track timestamp
-                if (timestampStatus == NO_ERROR) {
-                    uint32_t trackFramesWrittenButNotPresented =
-                        nativeFramesWrittenButNotPresented;
-                    uint32_t trackFramesWritten = fastTrack->mBufferProvider->framesReleased();
-                    // Can't provide an AudioTimestamp before first frame presented,
-                    // or during the brief 32-bit wraparound window
-                    if (trackFramesWritten >= trackFramesWrittenButNotPresented) {
-                        AudioTimestamp perTrackTimestamp;
-                        perTrackTimestamp.mPosition =
-                                trackFramesWritten - trackFramesWrittenButNotPresented;
-                        perTrackTimestamp.mTime = timestamp.mTime;
-                        fastTrack->mBufferProvider->onTimestamp(perTrackTimestamp);
-                    }
-                }
-
-                int name = fastTrackNames[i];
+                name = fastTrackNames[i];
                 ALOG_ASSERT(name >= 0);
-                if (fastTrack->mVolumeProvider != NULL) {
-                    uint32_t vlr = fastTrack->mVolumeProvider->getVolumeLR();
-                    mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME0,
-                            (void *)(uintptr_t)(vlr & 0xFFFF));
-                    mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME1,
-                            (void *)(uintptr_t)(vlr >> 16));
-                }
-                // FIXME The current implementation of framesReady() for fast tracks
-                // takes a tryLock, which can block
-                // up to 1 ms.  If enough active tracks all blocked in sequence, this would result
-                // in the overall fast mix cycle being delayed.  Should use a non-blocking FIFO.
-                size_t framesReady = fastTrack->mBufferProvider->framesReady();
-                if (ATRACE_ENABLED()) {
-                    // I wish we had formatted trace names
-                    char traceName[16];
-                    strcpy(traceName, "fRdy");
-                    traceName[4] = i + (i < 10 ? '0' : 'A' - 10);
-                    traceName[5] = '\0';
-                    ATRACE_INT(traceName, framesReady);
-                }
-                FastTrackDump *ftDump = &dumpState->mTracks[i];
-                FastTrackUnderruns underruns = ftDump->mUnderruns;
-                if (framesReady < frameCount) {
-                    if (framesReady == 0) {
-                        underruns.mBitFields.mEmpty++;
-                        underruns.mBitFields.mMostRecent = UNDERRUN_EMPTY;
-                        mixer->disable(name);
-                    } else {
-                        // allow mixing partial buffer
-                        underruns.mBitFields.mPartial++;
-                        underruns.mBitFields.mMostRecent = UNDERRUN_PARTIAL;
-                        mixer->enable(name);
+                mixer->deleteTrackName(name);
+            }
+#if !LOG_NDEBUG
+            fastTrackNames[i] = -1;
+#endif
+            // don't reset track dump state, since other side is ignoring it
+            generations[i] = fastTrack->mGeneration;
+        }
+
+        // now process added tracks
+        unsigned addedTracks = currentTrackMask & ~previousTrackMask;
+        while (addedTracks != 0) {
+            int i = __builtin_ctz(addedTracks);
+            addedTracks &= ~(1 << i);
+            const FastTrack* fastTrack = &current->mFastTracks[i];
+            AudioBufferProvider *bufferProvider = fastTrack->mBufferProvider;
+            ALOG_ASSERT(bufferProvider != NULL && fastTrackNames[i] == -1);
+            if (mixer != NULL) {
+                // calling getTrackName with default channel mask and a random invalid
+                //   sessionId (no effects here)
+                name = mixer->getTrackName(AUDIO_CHANNEL_OUT_STEREO, -555);
+                ALOG_ASSERT(name >= 0);
+                fastTrackNames[i] = name;
+                mixer->setBufferProvider(name, bufferProvider);
+                mixer->setParameter(name, AudioMixer::TRACK, AudioMixer::MAIN_BUFFER,
+                        (void *) mixBuffer);
+                // newly allocated track names default to full scale volume
+                mixer->setParameter(name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK,
+                        (void *)(uintptr_t)fastTrack->mChannelMask);
+                mixer->enable(name);
+            }
+            generations[i] = fastTrack->mGeneration;
+        }
+
+        // finally process (potentially) modified tracks; these use the same slot
+        // but may have a different buffer provider or volume provider
+        unsigned modifiedTracks = currentTrackMask & previousTrackMask;
+        while (modifiedTracks != 0) {
+            int i = __builtin_ctz(modifiedTracks);
+            modifiedTracks &= ~(1 << i);
+            const FastTrack* fastTrack = &current->mFastTracks[i];
+            if (fastTrack->mGeneration != generations[i]) {
+                // this track was actually modified
+                AudioBufferProvider *bufferProvider = fastTrack->mBufferProvider;
+                ALOG_ASSERT(bufferProvider != NULL);
+                if (mixer != NULL) {
+                    name = fastTrackNames[i];
+                    ALOG_ASSERT(name >= 0);
+                    mixer->setBufferProvider(name, bufferProvider);
+                    if (fastTrack->mVolumeProvider == NULL) {
+                        mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME0,
+                                (void *)0x1000);
+                        mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME1,
+                                (void *)0x1000);
                     }
+                    mixer->setParameter(name, AudioMixer::RESAMPLE,
+                            AudioMixer::REMOVE, NULL);
+                    mixer->setParameter(name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK,
+                            (void *)(uintptr_t) fastTrack->mChannelMask);
+                    // already enabled
+                }
+                generations[i] = fastTrack->mGeneration;
+            }
+        }
+
+        fastTracksGen = current->mFastTracksGen;
+
+        dumpState->mNumTracks = popcount(currentTrackMask);
+    }
+}
+
+void FastMixer::onWork()
+{
+    const FastMixerState * const current = (const FastMixerState *) this->current;
+    FastMixerDumpState * const dumpState = (FastMixerDumpState *) this->dumpState;
+    const FastMixerState::Command command = this->command;
+    const size_t frameCount = current->mFrameCount;
+
+    if ((command & FastMixerState::MIX) && (mixer != NULL) && isWarm) {
+        ALOG_ASSERT(mixBuffer != NULL);
+        // for each track, update volume and check for underrun
+        unsigned currentTrackMask = current->mTrackMask;
+        while (currentTrackMask != 0) {
+            int i = __builtin_ctz(currentTrackMask);
+            currentTrackMask &= ~(1 << i);
+            const FastTrack* fastTrack = &current->mFastTracks[i];
+
+            // Refresh the per-track timestamp
+            if (timestampStatus == NO_ERROR) {
+                uint32_t trackFramesWrittenButNotPresented =
+                    nativeFramesWrittenButNotPresented;
+                uint32_t trackFramesWritten = fastTrack->mBufferProvider->framesReleased();
+                // Can't provide an AudioTimestamp before first frame presented,
+                // or during the brief 32-bit wraparound window
+                if (trackFramesWritten >= trackFramesWrittenButNotPresented) {
+                    AudioTimestamp perTrackTimestamp;
+                    perTrackTimestamp.mPosition =
+                            trackFramesWritten - trackFramesWrittenButNotPresented;
+                    perTrackTimestamp.mTime = timestamp.mTime;
+                    fastTrack->mBufferProvider->onTimestamp(perTrackTimestamp);
+                }
+            }
+
+            int name = fastTrackNames[i];
+            ALOG_ASSERT(name >= 0);
+            if (fastTrack->mVolumeProvider != NULL) {
+                uint32_t vlr = fastTrack->mVolumeProvider->getVolumeLR();
+                mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME0,
+                        (void *)(uintptr_t)(vlr & 0xFFFF));
+                mixer->setParameter(name, AudioMixer::VOLUME, AudioMixer::VOLUME1,
+                        (void *)(uintptr_t)(vlr >> 16));
+            }
+            // FIXME The current implementation of framesReady() for fast tracks
+            // takes a tryLock, which can block
+            // up to 1 ms.  If enough active tracks all blocked in sequence, this would result
+            // in the overall fast mix cycle being delayed.  Should use a non-blocking FIFO.
+            size_t framesReady = fastTrack->mBufferProvider->framesReady();
+            if (ATRACE_ENABLED()) {
+                // I wish we had formatted trace names
+                char traceName[16];
+                strcpy(traceName, "fRdy");
+                traceName[4] = i + (i < 10 ? '0' : 'A' - 10);
+                traceName[5] = '\0';
+                ATRACE_INT(traceName, framesReady);
+            }
+            FastTrackDump *ftDump = &dumpState->mTracks[i];
+            FastTrackUnderruns underruns = ftDump->mUnderruns;
+            if (framesReady < frameCount) {
+                if (framesReady == 0) {
+                    underruns.mBitFields.mEmpty++;
+                    underruns.mBitFields.mMostRecent = UNDERRUN_EMPTY;
+                    mixer->disable(name);
                 } else {
-                    underruns.mBitFields.mFull++;
-                    underruns.mBitFields.mMostRecent = UNDERRUN_FULL;
+                    // allow mixing partial buffer
+                    underruns.mBitFields.mPartial++;
+                    underruns.mBitFields.mMostRecent = UNDERRUN_PARTIAL;
                     mixer->enable(name);
                 }
-                ftDump->mUnderruns = underruns;
-                ftDump->mFramesReady = framesReady;
-            }
-
-            int64_t pts;
-            if (outputSink == NULL || (OK != outputSink->getNextWriteTimestamp(&pts))) {
-                pts = AudioBufferProvider::kInvalidPTS;
-            }
-
-            // process() is CPU-bound
-            mixer->process(pts);
-            mixBufferState = MIXED;
-        } else if (mixBufferState == MIXED) {
-            mixBufferState = UNDEFINED;
-        }
-        bool attemptedWrite = false;
-        //bool didFullWrite = false;    // dumpsys could display a count of partial writes
-        if ((command & FastMixerState::WRITE) && (outputSink != NULL) && (mixBuffer != NULL)) {
-            if (mixBufferState == UNDEFINED) {
-                memset(mixBuffer, 0, frameCount * FCC_2 * sizeof(short));
-                mixBufferState = ZEROED;
-            }
-            if (teeSink != NULL) {
-                (void) teeSink->write(mixBuffer, frameCount);
-            }
-            // FIXME write() is non-blocking and lock-free for a properly implemented NBAIO sink,
-            //       but this code should be modified to handle both non-blocking and blocking sinks
-            dumpState->mWriteSequence++;
-            ATRACE_BEGIN("write");
-            ssize_t framesWritten = outputSink->write(mixBuffer, frameCount);
-            ATRACE_END();
-            dumpState->mWriteSequence++;
-            if (framesWritten >= 0) {
-                ALOG_ASSERT((size_t) framesWritten <= frameCount);
-                totalNativeFramesWritten += framesWritten;
-                dumpState->mFramesWritten = totalNativeFramesWritten;
-                //if ((size_t) framesWritten == frameCount) {
-                //    didFullWrite = true;
-                //}
             } else {
-                dumpState->mWriteErrors++;
+                underruns.mBitFields.mFull++;
+                underruns.mBitFields.mMostRecent = UNDERRUN_FULL;
+                mixer->enable(name);
             }
-            attemptedWrite = true;
-            // FIXME count # of writes blocked excessively, CPU usage, etc. for dump
-
-            timestampStatus = outputSink->getTimestamp(timestamp);
-            if (timestampStatus == NO_ERROR) {
-                uint32_t totalNativeFramesPresented = timestamp.mPosition;
-                if (totalNativeFramesPresented <= totalNativeFramesWritten) {
-                    nativeFramesWrittenButNotPresented =
-                        totalNativeFramesWritten - totalNativeFramesPresented;
-                } else {
-                    // HAL reported that more frames were presented than were written
-                    timestampStatus = INVALID_OPERATION;
-                }
-            }
+            ftDump->mUnderruns = underruns;
+            ftDump->mFramesReady = framesReady;
         }
 
-        // To be exactly periodic, compute the next sleep time based on current time.
-        // This code doesn't have long-term stability when the sink is non-blocking.
-        // FIXME To avoid drift, use the local audio clock or watch the sink's fill status.
-        struct timespec newTs;
-        int rc = clock_gettime(CLOCK_MONOTONIC, &newTs);
-        if (rc == 0) {
-            //logWriter->logTimestamp(newTs);
-            if (oldTsValid) {
-                time_t sec = newTs.tv_sec - oldTs.tv_sec;
-                long nsec = newTs.tv_nsec - oldTs.tv_nsec;
-                ALOGE_IF(sec < 0 || (sec == 0 && nsec < 0),
-                        "clock_gettime(CLOCK_MONOTONIC) failed: was %ld.%09ld but now %ld.%09ld",
-                        oldTs.tv_sec, oldTs.tv_nsec, newTs.tv_sec, newTs.tv_nsec);
-                if (nsec < 0) {
-                    --sec;
-                    nsec += 1000000000;
-                }
-                // To avoid an initial underrun on fast tracks after exiting standby,
-                // do not start pulling data from tracks and mixing until warmup is complete.
-                // Warmup is considered complete after the earlier of:
-                //      MIN_WARMUP_CYCLES write() attempts and last one blocks for at least warmupNs
-                //      MAX_WARMUP_CYCLES write() attempts.
-                // This is overly conservative, but to get better accuracy requires a new HAL API.
-                if (!isWarm && attemptedWrite) {
-                    measuredWarmupTs.tv_sec += sec;
-                    measuredWarmupTs.tv_nsec += nsec;
-                    if (measuredWarmupTs.tv_nsec >= 1000000000) {
-                        measuredWarmupTs.tv_sec++;
-                        measuredWarmupTs.tv_nsec -= 1000000000;
-                    }
-                    ++warmupCycles;
-                    if ((nsec > warmupNs && warmupCycles >= MIN_WARMUP_CYCLES) ||
-                            (warmupCycles >= MAX_WARMUP_CYCLES)) {
-                        isWarm = true;
-                        dumpState->mMeasuredWarmupTs = measuredWarmupTs;
-                        dumpState->mWarmupCycles = warmupCycles;
-                    }
-                }
-                sleepNs = -1;
-                if (isWarm) {
-                    if (sec > 0 || nsec > underrunNs) {
-                        ATRACE_NAME("underrun");
-                        // FIXME only log occasionally
-                        ALOGV("underrun: time since last cycle %d.%03ld sec",
-                                (int) sec, nsec / 1000000L);
-                        dumpState->mUnderruns++;
-                        ignoreNextOverrun = true;
-                    } else if (nsec < overrunNs) {
-                        if (ignoreNextOverrun) {
-                            ignoreNextOverrun = false;
-                        } else {
-                            // FIXME only log occasionally
-                            ALOGV("overrun: time since last cycle %d.%03ld sec",
-                                    (int) sec, nsec / 1000000L);
-                            dumpState->mOverruns++;
-                        }
-                        // This forces a minimum cycle time. It:
-                        //  - compensates for an audio HAL with jitter due to sample rate conversion
-                        //  - works with a variable buffer depth audio HAL that never pulls at a
-                        //    rate < than overrunNs per buffer.
-                        //  - recovers from overrun immediately after underrun
-                        // It doesn't work with a non-blocking audio HAL.
-                        sleepNs = forceNs - nsec;
-                    } else {
-                        ignoreNextOverrun = false;
-                    }
-                }
-#ifdef FAST_MIXER_STATISTICS
-                if (isWarm) {
-                    // advance the FIFO queue bounds
-                    size_t i = bounds & (dumpState->mSamplingN - 1);
-                    bounds = (bounds & 0xFFFF0000) | ((bounds + 1) & 0xFFFF);
-                    if (full) {
-                        bounds += 0x10000;
-                    } else if (!(bounds & (dumpState->mSamplingN - 1))) {
-                        full = true;
-                    }
-                    // compute the delta value of clock_gettime(CLOCK_MONOTONIC)
-                    uint32_t monotonicNs = nsec;
-                    if (sec > 0 && sec < 4) {
-                        monotonicNs += sec * 1000000000;
-                    }
-                    // compute raw CPU load = delta value of clock_gettime(CLOCK_THREAD_CPUTIME_ID)
-                    uint32_t loadNs = 0;
-                    struct timespec newLoad;
-                    rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &newLoad);
-                    if (rc == 0) {
-                        if (oldLoadValid) {
-                            sec = newLoad.tv_sec - oldLoad.tv_sec;
-                            nsec = newLoad.tv_nsec - oldLoad.tv_nsec;
-                            if (nsec < 0) {
-                                --sec;
-                                nsec += 1000000000;
-                            }
-                            loadNs = nsec;
-                            if (sec > 0 && sec < 4) {
-                                loadNs += sec * 1000000000;
-                            }
-                        } else {
-                            // first time through the loop
-                            oldLoadValid = true;
-                        }
-                        oldLoad = newLoad;
-                    }
-#ifdef CPU_FREQUENCY_STATISTICS
-                    // get the absolute value of CPU clock frequency in kHz
-                    int cpuNum = sched_getcpu();
-                    uint32_t kHz = tcu.getCpukHz(cpuNum);
-                    kHz = (kHz << 4) | (cpuNum & 0xF);
-#endif
-                    // save values in FIFO queues for dumpsys
-                    // these stores #1, #2, #3 are not atomic with respect to each other,
-                    // or with respect to store #4 below
-                    dumpState->mMonotonicNs[i] = monotonicNs;
-                    dumpState->mLoadNs[i] = loadNs;
-#ifdef CPU_FREQUENCY_STATISTICS
-                    dumpState->mCpukHz[i] = kHz;
-#endif
-                    // this store #4 is not atomic with respect to stores #1, #2, #3 above, but
-                    // the newest open & oldest closed halves are atomic with respect to each other
-                    dumpState->mBounds = bounds;
-                    ATRACE_INT("cycle_ms", monotonicNs / 1000000);
-                    ATRACE_INT("load_us", loadNs / 1000);
-                }
-#endif
-            } else {
-                // first time through the loop
-                oldTsValid = true;
-                sleepNs = periodNs;
-                ignoreNextOverrun = true;
-            }
-            oldTs = newTs;
+        int64_t pts;
+        if (outputSink == NULL || (OK != outputSink->getNextWriteTimestamp(&pts))) {
+            pts = AudioBufferProvider::kInvalidPTS;
+        }
+
+        // process() is CPU-bound
+        mixer->process(pts);
+        mixBufferState = MIXED;
+    } else if (mixBufferState == MIXED) {
+        mixBufferState = UNDEFINED;
+    }
+    //bool didFullWrite = false;    // dumpsys could display a count of partial writes
+    if ((command & FastMixerState::WRITE) && (outputSink != NULL) && (mixBuffer != NULL)) {
+        if (mixBufferState == UNDEFINED) {
+            memset(mixBuffer, 0, frameCount * FCC_2 * sizeof(short));
+            mixBufferState = ZEROED;
+        }
+        // if non-NULL, then duplicate write() to this non-blocking sink
+        NBAIO_Sink* teeSink;
+        if ((teeSink = current->mTeeSink) != NULL) {
+            (void) teeSink->write(mixBuffer, frameCount);
+        }
+        // FIXME write() is non-blocking and lock-free for a properly implemented NBAIO sink,
+        //       but this code should be modified to handle both non-blocking and blocking sinks
+        dumpState->mWriteSequence++;
+        ATRACE_BEGIN("write");
+        ssize_t framesWritten = outputSink->write(mixBuffer, frameCount);
+        ATRACE_END();
+        dumpState->mWriteSequence++;
+        if (framesWritten >= 0) {
+            ALOG_ASSERT((size_t) framesWritten <= frameCount);
+            totalNativeFramesWritten += framesWritten;
+            dumpState->mFramesWritten = totalNativeFramesWritten;
+            //if ((size_t) framesWritten == frameCount) {
+            //    didFullWrite = true;
+            //}
         } else {
-            // monotonic clock is broken
-            oldTsValid = false;
-            sleepNs = periodNs;
+            dumpState->mWriteErrors++;
         }
+        attemptedWrite = true;
+        // FIXME count # of writes blocked excessively, CPU usage, etc. for dump
 
-
-    }   // for (;;)
-
-    // never return 'true'; Thread::_threadLoop() locks mutex which can result in priority inversion
+        timestampStatus = outputSink->getTimestamp(timestamp);
+        if (timestampStatus == NO_ERROR) {
+            uint32_t totalNativeFramesPresented = timestamp.mPosition;
+            if (totalNativeFramesPresented <= totalNativeFramesWritten) {
+                nativeFramesWrittenButNotPresented =
+                    totalNativeFramesWritten - totalNativeFramesPresented;
+            } else {
+                // HAL reported that more frames were presented than were written
+                timestampStatus = INVALID_OPERATION;
+            }
+        }
+    }
 }
 
 FastMixerDumpState::FastMixerDumpState(
 #ifdef FAST_MIXER_STATISTICS
         uint32_t samplingN
 #endif
-        ) :
-    mCommand(FastMixerState::INITIAL), mWriteSequence(0), mFramesWritten(0),
-    mNumTracks(0), mWriteErrors(0), mUnderruns(0), mOverruns(0),
-    mSampleRate(0), mFrameCount(0), /* mMeasuredWarmupTs({0, 0}), */ mWarmupCycles(0),
+        ) : FastThreadDumpState(),
+    mWriteSequence(0), mFramesWritten(0),
+    mNumTracks(0), mWriteErrors(0),
+    mSampleRate(0), mFrameCount(0),
     mTrackMask(0)
-#ifdef FAST_MIXER_STATISTICS
-    , mSamplingN(0), mBounds(0)
-#endif
 {
-    mMeasuredWarmupTs.tv_sec = 0;
-    mMeasuredWarmupTs.tv_nsec = 0;
 #ifdef FAST_MIXER_STATISTICS
     increaseSamplingN(samplingN);
 #endif
diff --git a/services/audioflinger/FastMixer.h b/services/audioflinger/FastMixer.h
index 7aeddef..981c1a7 100644
--- a/services/audioflinger/FastMixer.h
+++ b/services/audioflinger/FastMixer.h
@@ -18,123 +18,65 @@
 #define ANDROID_AUDIO_FAST_MIXER_H
 
 #include <utils/Debug.h>
+#if 1   // FIXME move to where used
 extern "C" {
 #include "../private/bionic_futex.h"
 }
+#endif
 #include "FastThread.h"
 #include "StateQueue.h"
 #include "FastMixerState.h"
+#include "FastMixerDumpState.h"
 
 namespace android {
 
+class AudioMixer;
+
 typedef StateQueue<FastMixerState> FastMixerStateQueue;
 
 class FastMixer : public FastThread {
 
 public:
-            FastMixer() : FastThread() { }
-    virtual ~FastMixer() { }
+            FastMixer();
+    virtual ~FastMixer();
 
-            FastMixerStateQueue* sq() { return &mSQ; }
+            FastMixerStateQueue* sq();
 
 private:
-    virtual bool                threadLoop();
             FastMixerStateQueue mSQ;
 
+    // callouts
+    virtual const FastThreadState *poll();
+    virtual void setLog(NBLog::Writer *logWriter);
+    virtual void onIdle();
+    virtual void onExit();
+    virtual bool isSubClassCommand(FastThreadState::Command command);
+    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;
+    short *mixBuffer;
+    enum {UNDEFINED, MIXED, ZEROED} mixBufferState;
+    NBAIO_Format format;
+    unsigned sampleRate;
+    int fastTracksGen;
+    FastMixerDumpState dummyDumpState;
+    uint32_t totalNativeFramesWritten;  // copied to dumpState->mFramesWritten
+
+    // next 2 fields are valid only when timestampStatus == NO_ERROR
+    AudioTimestamp timestamp;
+    uint32_t nativeFramesWrittenButNotPresented;
+
 };  // class FastMixer
 
-// Describes the underrun status for a single "pull" attempt
-enum FastTrackUnderrunStatus {
-    UNDERRUN_FULL,      // framesReady() is full frame count, no underrun
-    UNDERRUN_PARTIAL,   // framesReady() is non-zero but < full frame count, partial underrun
-    UNDERRUN_EMPTY,     // framesReady() is zero, total underrun
-};
-
-// Underrun counters are not reset to zero for new tracks or if track generation changes.
-// This packed representation is used to keep the information atomic.
-union FastTrackUnderruns {
-    FastTrackUnderruns() { mAtomic = 0;
-            COMPILE_TIME_ASSERT_FUNCTION_SCOPE(sizeof(FastTrackUnderruns) == sizeof(uint32_t)); }
-    FastTrackUnderruns(const FastTrackUnderruns& copyFrom) : mAtomic(copyFrom.mAtomic) { }
-    FastTrackUnderruns& operator=(const FastTrackUnderruns& rhs)
-            { if (this != &rhs) mAtomic = rhs.mAtomic; return *this; }
-    struct {
-#define UNDERRUN_BITS 10
-#define UNDERRUN_MASK ((1 << UNDERRUN_BITS) - 1)
-        uint32_t mFull    : UNDERRUN_BITS; // framesReady() is full frame count
-        uint32_t mPartial : UNDERRUN_BITS; // framesReady() is non-zero but < full frame count
-        uint32_t mEmpty   : UNDERRUN_BITS; // framesReady() is zero
-        FastTrackUnderrunStatus mMostRecent : 2;    // status of most recent framesReady()
-    }        mBitFields;
-private:
-    uint32_t mAtomic;
-};
-
-// Represents the dump state of a fast track
-struct FastTrackDump {
-    FastTrackDump() : mFramesReady(0) { }
-    /*virtual*/ ~FastTrackDump() { }
-    FastTrackUnderruns mUnderruns;
-    size_t mFramesReady;        // most recent value only; no long-term statistics kept
-};
-
-// The FastMixerDumpState keeps a cache of FastMixer statistics that can be logged by dumpsys.
-// Each individual native word-sized field is accessed atomically.  But the
-// overall structure is non-atomic, that is there may be an inconsistency between fields.
-// No barriers or locks are used for either writing or reading.
-// Only POD types are permitted, and the contents shouldn't be trusted (i.e. do range checks).
-// It has a different lifetime than the FastMixer, and so it can't be a member of FastMixer.
-struct FastMixerDumpState {
-    FastMixerDumpState(
-#ifdef FAST_MIXER_STATISTICS
-            uint32_t samplingN = kSamplingNforLowRamDevice
-#endif
-            );
-    /*virtual*/ ~FastMixerDumpState();
-
-    void dump(int fd) const;    // should only be called on a stable copy, not the original
-
-    FastMixerState::Command mCommand;   // current command
-    uint32_t mWriteSequence;    // incremented before and after each write()
-    uint32_t mFramesWritten;    // total number of frames written successfully
-    uint32_t mNumTracks;        // total number of active fast tracks
-    uint32_t mWriteErrors;      // total number of write() errors
-    uint32_t mUnderruns;        // total number of underruns
-    uint32_t mOverruns;         // total number of overruns
-    uint32_t mSampleRate;
-    size_t   mFrameCount;
-    struct timespec mMeasuredWarmupTs;  // measured warmup time
-    uint32_t mWarmupCycles;     // number of loop cycles required to warmup
-    uint32_t mTrackMask;        // mask of active tracks
-    FastTrackDump   mTracks[FastMixerState::kMaxFastTracks];
-
-#ifdef FAST_MIXER_STATISTICS
-    // Recently collected samples of per-cycle monotonic time, thread CPU time, and CPU frequency.
-    // kSamplingN is max size of sampling frame (statistics), and must be a power of 2 <= 0x8000.
-    // The sample arrays are virtually allocated based on this compile-time constant,
-    // but are only initialized and used based on the runtime parameter mSamplingN.
-    static const uint32_t kSamplingN = 0x8000;
-    // Compile-time constant for a "low RAM device", must be a power of 2 <= kSamplingN.
-    // This value was chosen such that each array uses 1 small page (4 Kbytes).
-    static const uint32_t kSamplingNforLowRamDevice = 0x400;
-    // Corresponding runtime maximum size of sample arrays, must be a power of 2 <= kSamplingN.
-    uint32_t mSamplingN;
-    // The bounds define the interval of valid samples, and are represented as follows:
-    //      newest open (excluded) endpoint   = lower 16 bits of bounds, modulo N
-    //      oldest closed (included) endpoint = upper 16 bits of bounds, modulo N
-    // Number of valid samples is newest - oldest.
-    uint32_t mBounds;                   // bounds for mMonotonicNs, mThreadCpuNs, and mCpukHz
-    // The elements in the *Ns arrays are in units of nanoseconds <= 3999999999.
-    uint32_t mMonotonicNs[kSamplingN];  // delta monotonic (wall clock) time
-    uint32_t mLoadNs[kSamplingN];       // delta CPU load in time
-#ifdef CPU_FREQUENCY_STATISTICS
-    uint32_t mCpukHz[kSamplingN];       // absolute CPU clock frequency in kHz, bits 0-3 are CPU#
-#endif
-    // Increase sampling window after construction, must be a power of 2 <= kSamplingN
-    void    increaseSamplingN(uint32_t samplingN);
-#endif
-};
-
 }   // namespace android
 
 #endif  // ANDROID_AUDIO_FAST_MIXER_H
diff --git a/services/audioflinger/FastMixerDumpState.h b/services/audioflinger/FastMixerDumpState.h
new file mode 100644
index 0000000..6a1e4649
--- /dev/null
+++ b/services/audioflinger/FastMixerDumpState.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_AUDIO_FAST_MIXER_DUMP_STATE_H
+#define ANDROID_AUDIO_FAST_MIXER_DUMP_STATE_H
+
+#include "Configuration.h"
+
+namespace android {
+
+// Describes the underrun status for a single "pull" attempt
+enum FastTrackUnderrunStatus {
+    UNDERRUN_FULL,      // framesReady() is full frame count, no underrun
+    UNDERRUN_PARTIAL,   // framesReady() is non-zero but < full frame count, partial underrun
+    UNDERRUN_EMPTY,     // framesReady() is zero, total underrun
+};
+
+// Underrun counters are not reset to zero for new tracks or if track generation changes.
+// This packed representation is used to keep the information atomic.
+union FastTrackUnderruns {
+    FastTrackUnderruns() { mAtomic = 0;
+            COMPILE_TIME_ASSERT_FUNCTION_SCOPE(sizeof(FastTrackUnderruns) == sizeof(uint32_t)); }
+    FastTrackUnderruns(const FastTrackUnderruns& copyFrom) : mAtomic(copyFrom.mAtomic) { }
+    FastTrackUnderruns& operator=(const FastTrackUnderruns& rhs)
+            { if (this != &rhs) mAtomic = rhs.mAtomic; return *this; }
+    struct {
+#define UNDERRUN_BITS 10
+#define UNDERRUN_MASK ((1 << UNDERRUN_BITS) - 1)
+        uint32_t mFull    : UNDERRUN_BITS; // framesReady() is full frame count
+        uint32_t mPartial : UNDERRUN_BITS; // framesReady() is non-zero but < full frame count
+        uint32_t mEmpty   : UNDERRUN_BITS; // framesReady() is zero
+        FastTrackUnderrunStatus mMostRecent : 2;    // status of most recent framesReady()
+    }        mBitFields;
+private:
+    uint32_t mAtomic;
+};
+
+// Represents the dump state of a fast track
+struct FastTrackDump {
+    FastTrackDump() : mFramesReady(0) { }
+    /*virtual*/ ~FastTrackDump() { }
+    FastTrackUnderruns mUnderruns;
+    size_t mFramesReady;        // most recent value only; no long-term statistics kept
+};
+
+// The FastMixerDumpState keeps a cache of FastMixer statistics that can be logged by dumpsys.
+// Each individual native word-sized field is accessed atomically.  But the
+// overall structure is non-atomic, that is there may be an inconsistency between fields.
+// No barriers or locks are used for either writing or reading.
+// Only POD types are permitted, and the contents shouldn't be trusted (i.e. do range checks).
+// It has a different lifetime than the FastMixer, and so it can't be a member of FastMixer.
+struct FastMixerDumpState : FastThreadDumpState {
+    FastMixerDumpState(
+#ifdef FAST_MIXER_STATISTICS
+            uint32_t samplingN = kSamplingNforLowRamDevice
+#endif
+            );
+    /*virtual*/ ~FastMixerDumpState();
+
+    void dump(int fd) const;    // should only be called on a stable copy, not the original
+
+    uint32_t mWriteSequence;    // incremented before and after each write()
+    uint32_t mFramesWritten;    // total number of frames written successfully
+    uint32_t mNumTracks;        // total number of active fast tracks
+    uint32_t mWriteErrors;      // total number of write() errors
+    uint32_t mSampleRate;
+    size_t   mFrameCount;
+    uint32_t mTrackMask;        // mask of active tracks
+    FastTrackDump   mTracks[FastMixerState::kMaxFastTracks];
+
+#ifdef FAST_MIXER_STATISTICS
+    // Compile-time constant for a "low RAM device", must be a power of 2 <= kSamplingN.
+    // This value was chosen such that each array uses 1 small page (4 Kbytes).
+    static const uint32_t kSamplingNforLowRamDevice = 0x400;
+    // Increase sampling window after construction, must be a power of 2 <= kSamplingN
+    void    increaseSamplingN(uint32_t samplingN);
+#endif
+};
+
+}   // android
+
+#endif  // ANDROID_AUDIO_FAST_MIXER_DUMP_STATE_H
diff --git a/services/audioflinger/FastMixerState.cpp b/services/audioflinger/FastMixerState.cpp
index 4631274..8e6d0d4 100644
--- a/services/audioflinger/FastMixerState.cpp
+++ b/services/audioflinger/FastMixerState.cpp
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include "Configuration.h"
 #include "FastMixerState.h"
 
 namespace android {
@@ -30,9 +29,9 @@
 }
 
 FastMixerState::FastMixerState() : FastThreadState(),
+    // mFastTracks
     mFastTracksGen(0), mTrackMask(0), mOutputSink(NULL), mOutputSinkGen(0),
-    mFrameCount(0),
-    mDumpState(NULL), mTeeSink(NULL)
+    mFrameCount(0), mTeeSink(NULL)
 {
 }
 
diff --git a/services/audioflinger/FastMixerState.h b/services/audioflinger/FastMixerState.h
index 10696e8..be1a376 100644
--- a/services/audioflinger/FastMixerState.h
+++ b/services/audioflinger/FastMixerState.h
@@ -71,7 +71,6 @@
         MIX_WRITE = 0x18;       // mix tracks and write to output sink
 
     // This might be a one-time configuration rather than per-state
-    FastMixerDumpState* mDumpState; // if non-NULL, then update dump state periodically
     NBAIO_Sink* mTeeSink;       // if non-NULL, then duplicate write()s to this non-blocking sink
 };  // struct FastMixerState
 
diff --git a/services/audioflinger/FastThread.cpp b/services/audioflinger/FastThread.cpp
new file mode 100644
index 0000000..8a216b3
--- /dev/null
+++ b/services/audioflinger/FastThread.cpp
@@ -0,0 +1,348 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "FastThread"
+//#define LOG_NDEBUG 0
+
+#define ATRACE_TAG ATRACE_TAG_AUDIO
+
+#include "Configuration.h"
+#include <utils/Log.h>
+extern "C" {
+#include "../private/bionic_futex.h"
+}
+#include <utils/Trace.h>
+#include "FastThread.h"
+
+#define FAST_DEFAULT_NS    999999999L   // ~1 sec: default time to sleep
+#define FAST_HOT_IDLE_NS     1000000L   // 1 ms: time to sleep while hot idling
+#define MIN_WARMUP_CYCLES          2    // minimum number of loop cycles to wait for warmup
+#define MAX_WARMUP_CYCLES         10    // maximum number of loop cycles to wait for warmup
+
+namespace android {
+
+FastThread::FastThread() : Thread(false /*canCallJava*/),
+    // re-initialized to &initial by subclass constructor
+     previous(NULL), current(NULL),
+    /* oldTs({0, 0}), */
+    oldTsValid(false),
+    sleepNs(-1),
+    periodNs(0),
+    underrunNs(0),
+    overrunNs(0),
+    forceNs(0),
+    warmupNs(0),
+    // re-initialized to &dummyDumpState by subclass constructor
+    mDummyDumpState(NULL),
+    dumpState(NULL),
+    ignoreNextOverrun(true),
+#ifdef FAST_MIXER_STATISTICS
+    // oldLoad
+    oldLoadValid(false),
+    bounds(0),
+    full(false),
+    // tcu
+#endif
+    coldGen(0),
+    isWarm(false),
+    /* measuredWarmupTs({0, 0}), */
+    warmupCycles(0),
+    // dummyLogWriter
+    logWriter(&dummyLogWriter),
+    timestampStatus(INVALID_OPERATION),
+
+    command(FastThreadState::INITIAL),
+#if 0
+    frameCount(0),
+#endif
+    attemptedWrite(false)
+{
+    oldTs.tv_sec = 0;
+    oldTs.tv_nsec = 0;
+    measuredWarmupTs.tv_sec = 0;
+    measuredWarmupTs.tv_nsec = 0;
+}
+
+FastThread::~FastThread()
+{
+}
+
+bool FastThread::threadLoop()
+{
+    for (;;) {
+
+        // either nanosleep, sched_yield, or busy wait
+        if (sleepNs >= 0) {
+            if (sleepNs > 0) {
+                ALOG_ASSERT(sleepNs < 1000000000);
+                const struct timespec req = {0, sleepNs};
+                nanosleep(&req, NULL);
+            } else {
+                sched_yield();
+            }
+        }
+        // default to long sleep for next cycle
+        sleepNs = FAST_DEFAULT_NS;
+
+        // poll for state change
+        const FastThreadState *next = poll();
+        if (next == NULL) {
+            // continue to use the default initial state until a real state is available
+            // FIXME &initial not available, should save address earlier
+            //ALOG_ASSERT(current == &initial && previous == &initial);
+            next = current;
+        }
+
+        command = next->mCommand;
+        if (next != current) {
+
+            // As soon as possible of learning of a new dump area, start using it
+            dumpState = next->mDumpState != NULL ? next->mDumpState : mDummyDumpState;
+            logWriter = next->mNBLogWriter != NULL ? next->mNBLogWriter : &dummyLogWriter;
+            setLog(logWriter);
+
+            // We want to always have a valid reference to the previous (non-idle) state.
+            // However, the state queue only guarantees access to current and previous states.
+            // So when there is a transition from a non-idle state into an idle state, we make a
+            // copy of the last known non-idle state so it is still available on return from idle.
+            // The possible transitions are:
+            //  non-idle -> non-idle    update previous from current in-place
+            //  non-idle -> idle        update previous from copy of current
+            //  idle     -> idle        don't update previous
+            //  idle     -> non-idle    don't update previous
+            if (!(current->mCommand & FastThreadState::IDLE)) {
+                if (command & FastThreadState::IDLE) {
+                    onIdle();
+                    oldTsValid = false;
+#ifdef FAST_MIXER_STATISTICS
+                    oldLoadValid = false;
+#endif
+                    ignoreNextOverrun = true;
+                }
+                previous = current;
+            }
+            current = next;
+        }
+#if !LOG_NDEBUG
+        next = NULL;    // not referenced again
+#endif
+
+        dumpState->mCommand = command;
+
+        // << current, previous, command, dumpState >>
+
+        switch (command) {
+        case FastThreadState::INITIAL:
+        case FastThreadState::HOT_IDLE:
+            sleepNs = FAST_HOT_IDLE_NS;
+            continue;
+        case FastThreadState::COLD_IDLE:
+            // only perform a cold idle command once
+            // FIXME consider checking previous state and only perform if previous != COLD_IDLE
+            if (current->mColdGen != coldGen) {
+                int32_t *coldFutexAddr = current->mColdFutexAddr;
+                ALOG_ASSERT(coldFutexAddr != NULL);
+                int32_t old = android_atomic_dec(coldFutexAddr);
+                if (old <= 0) {
+                    __futex_syscall4(coldFutexAddr, FUTEX_WAIT_PRIVATE, old - 1, NULL);
+                }
+                int policy = sched_getscheduler(0);
+                if (!(policy == SCHED_FIFO || policy == SCHED_RR)) {
+                    ALOGE("did not receive expected priority boost");
+                }
+                // This may be overly conservative; there could be times that the normal mixer
+                // requests such a brief cold idle that it doesn't require resetting this flag.
+                isWarm = false;
+                measuredWarmupTs.tv_sec = 0;
+                measuredWarmupTs.tv_nsec = 0;
+                warmupCycles = 0;
+                sleepNs = -1;
+                coldGen = current->mColdGen;
+#ifdef FAST_MIXER_STATISTICS
+                bounds = 0;
+                full = false;
+#endif
+                oldTsValid = !clock_gettime(CLOCK_MONOTONIC, &oldTs);
+                timestampStatus = INVALID_OPERATION;
+            } else {
+                sleepNs = FAST_HOT_IDLE_NS;
+            }
+            continue;
+        case FastThreadState::EXIT:
+            onExit();
+            return false;
+        default:
+            LOG_ALWAYS_FATAL_IF(!isSubClassCommand(command));
+            break;
+        }
+
+        // there is a non-idle state available to us; did the state change?
+        if (current != previous) {
+            onStateChange();
+#if 1   // FIXME shouldn't need this
+            // only process state change once
+            previous = current;
+#endif
+        }
+
+        // do work using current state here
+        attemptedWrite = false;
+        onWork();
+
+        // To be exactly periodic, compute the next sleep time based on current time.
+        // This code doesn't have long-term stability when the sink is non-blocking.
+        // FIXME To avoid drift, use the local audio clock or watch the sink's fill status.
+        struct timespec newTs;
+        int rc = clock_gettime(CLOCK_MONOTONIC, &newTs);
+        if (rc == 0) {
+            //logWriter->logTimestamp(newTs);
+            if (oldTsValid) {
+                time_t sec = newTs.tv_sec - oldTs.tv_sec;
+                long nsec = newTs.tv_nsec - oldTs.tv_nsec;
+                ALOGE_IF(sec < 0 || (sec == 0 && nsec < 0),
+                        "clock_gettime(CLOCK_MONOTONIC) failed: was %ld.%09ld but now %ld.%09ld",
+                        oldTs.tv_sec, oldTs.tv_nsec, newTs.tv_sec, newTs.tv_nsec);
+                if (nsec < 0) {
+                    --sec;
+                    nsec += 1000000000;
+                }
+                // To avoid an initial underrun on fast tracks after exiting standby,
+                // do not start pulling data from tracks and mixing until warmup is complete.
+                // Warmup is considered complete after the earlier of:
+                //      MIN_WARMUP_CYCLES write() attempts and last one blocks for at least warmupNs
+                //      MAX_WARMUP_CYCLES write() attempts.
+                // This is overly conservative, but to get better accuracy requires a new HAL API.
+                if (!isWarm && attemptedWrite) {
+                    measuredWarmupTs.tv_sec += sec;
+                    measuredWarmupTs.tv_nsec += nsec;
+                    if (measuredWarmupTs.tv_nsec >= 1000000000) {
+                        measuredWarmupTs.tv_sec++;
+                        measuredWarmupTs.tv_nsec -= 1000000000;
+                    }
+                    ++warmupCycles;
+                    if ((nsec > warmupNs && warmupCycles >= MIN_WARMUP_CYCLES) ||
+                            (warmupCycles >= MAX_WARMUP_CYCLES)) {
+                        isWarm = true;
+                        dumpState->mMeasuredWarmupTs = measuredWarmupTs;
+                        dumpState->mWarmupCycles = warmupCycles;
+                    }
+                }
+                sleepNs = -1;
+                if (isWarm) {
+                    if (sec > 0 || nsec > underrunNs) {
+                        ATRACE_NAME("underrun");
+                        // FIXME only log occasionally
+                        ALOGV("underrun: time since last cycle %d.%03ld sec",
+                                (int) sec, nsec / 1000000L);
+                        dumpState->mUnderruns++;
+                        ignoreNextOverrun = true;
+                    } else if (nsec < overrunNs) {
+                        if (ignoreNextOverrun) {
+                            ignoreNextOverrun = false;
+                        } else {
+                            // FIXME only log occasionally
+                            ALOGV("overrun: time since last cycle %d.%03ld sec",
+                                    (int) sec, nsec / 1000000L);
+                            dumpState->mOverruns++;
+                        }
+                        // This forces a minimum cycle time. It:
+                        //  - compensates for an audio HAL with jitter due to sample rate conversion
+                        //  - works with a variable buffer depth audio HAL that never pulls at a
+                        //    rate < than overrunNs per buffer.
+                        //  - recovers from overrun immediately after underrun
+                        // It doesn't work with a non-blocking audio HAL.
+                        sleepNs = forceNs - nsec;
+                    } else {
+                        ignoreNextOverrun = false;
+                    }
+                }
+#ifdef FAST_MIXER_STATISTICS
+                if (isWarm) {
+                    // advance the FIFO queue bounds
+                    size_t i = bounds & (dumpState->mSamplingN - 1);
+                    bounds = (bounds & 0xFFFF0000) | ((bounds + 1) & 0xFFFF);
+                    if (full) {
+                        bounds += 0x10000;
+                    } else if (!(bounds & (dumpState->mSamplingN - 1))) {
+                        full = true;
+                    }
+                    // compute the delta value of clock_gettime(CLOCK_MONOTONIC)
+                    uint32_t monotonicNs = nsec;
+                    if (sec > 0 && sec < 4) {
+                        monotonicNs += sec * 1000000000;
+                    }
+                    // compute raw CPU load = delta value of clock_gettime(CLOCK_THREAD_CPUTIME_ID)
+                    uint32_t loadNs = 0;
+                    struct timespec newLoad;
+                    rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &newLoad);
+                    if (rc == 0) {
+                        if (oldLoadValid) {
+                            sec = newLoad.tv_sec - oldLoad.tv_sec;
+                            nsec = newLoad.tv_nsec - oldLoad.tv_nsec;
+                            if (nsec < 0) {
+                                --sec;
+                                nsec += 1000000000;
+                            }
+                            loadNs = nsec;
+                            if (sec > 0 && sec < 4) {
+                                loadNs += sec * 1000000000;
+                            }
+                        } else {
+                            // first time through the loop
+                            oldLoadValid = true;
+                        }
+                        oldLoad = newLoad;
+                    }
+#ifdef CPU_FREQUENCY_STATISTICS
+                    // get the absolute value of CPU clock frequency in kHz
+                    int cpuNum = sched_getcpu();
+                    uint32_t kHz = tcu.getCpukHz(cpuNum);
+                    kHz = (kHz << 4) | (cpuNum & 0xF);
+#endif
+                    // save values in FIFO queues for dumpsys
+                    // these stores #1, #2, #3 are not atomic with respect to each other,
+                    // or with respect to store #4 below
+                    dumpState->mMonotonicNs[i] = monotonicNs;
+                    dumpState->mLoadNs[i] = loadNs;
+#ifdef CPU_FREQUENCY_STATISTICS
+                    dumpState->mCpukHz[i] = kHz;
+#endif
+                    // this store #4 is not atomic with respect to stores #1, #2, #3 above, but
+                    // the newest open & oldest closed halves are atomic with respect to each other
+                    dumpState->mBounds = bounds;
+                    ATRACE_INT("cycle_ms", monotonicNs / 1000000);
+                    ATRACE_INT("load_us", loadNs / 1000);
+                }
+#endif
+            } else {
+                // first time through the loop
+                oldTsValid = true;
+                sleepNs = periodNs;
+                ignoreNextOverrun = true;
+            }
+            oldTs = newTs;
+        } else {
+            // monotonic clock is broken
+            oldTsValid = false;
+            sleepNs = periodNs;
+        }
+
+    }   // for (;;)
+
+    // never return 'true'; Thread::_threadLoop() locks mutex which can result in priority inversion
+}
+
+}   // namespace android
diff --git a/services/audioflinger/FastThread.h b/services/audioflinger/FastThread.h
index 6caf7bd..1330334 100644
--- a/services/audioflinger/FastThread.h
+++ b/services/audioflinger/FastThread.h
@@ -17,7 +17,12 @@
 #ifndef ANDROID_AUDIO_FAST_THREAD_H
 #define ANDROID_AUDIO_FAST_THREAD_H
 
+#include "Configuration.h"
+#ifdef CPU_FREQUENCY_STATISTICS
+#include <cpustats/ThreadCpuUsage.h>
+#endif
 #include <utils/Thread.h>
+#include "FastThreadState.h"
 
 namespace android {
 
@@ -25,11 +30,60 @@
 class FastThread : public Thread {
 
 public:
-            FastThread() : Thread(false /*canCallJava*/) { }
-    virtual ~FastThread() { }
+            FastThread();
+    virtual ~FastThread();
+
+private:
+    // implement Thread::threadLoop()
+    virtual bool threadLoop();
 
 protected:
-    virtual bool threadLoop() = 0;
+    // callouts to subclass in same lexical order as they were in original FastMixer.cpp
+    // FIXME need comments
+    virtual const FastThreadState *poll() = 0;
+    virtual void setLog(NBLog::Writer *logWriter __unused) { }
+    virtual void onIdle() = 0;
+    virtual void onExit() = 0;
+    virtual bool isSubClassCommand(FastThreadState::Command command) = 0;
+    virtual void onStateChange() = 0;
+    virtual void onWork() = 0;
+
+    // FIXME these former local variables need comments and to be renamed to have an "m" prefix
+    const FastThreadState *previous;
+    const FastThreadState *current;
+    struct timespec oldTs;
+    bool oldTsValid;
+    long sleepNs;   // -1: busy wait, 0: sched_yield, > 0: nanosleep
+    long periodNs;      // expected period; the time required to render one mix buffer
+    long underrunNs;    // underrun likely when write cycle is greater than this value
+    long overrunNs;     // overrun likely when write cycle is less than this value
+    long forceNs;       // if overrun detected, force the write cycle to take this much time
+    long warmupNs;      // warmup complete when write cycle is greater than to this value
+    FastThreadDumpState *mDummyDumpState;
+    FastThreadDumpState *dumpState;
+    bool ignoreNextOverrun;  // used to ignore initial overrun and first after an underrun
+#ifdef FAST_MIXER_STATISTICS
+    struct timespec oldLoad;    // previous value of clock_gettime(CLOCK_THREAD_CPUTIME_ID)
+    bool oldLoadValid;  // whether oldLoad is valid
+    uint32_t bounds;
+    bool full;          // whether we have collected at least mSamplingN samples
+#ifdef CPU_FREQUENCY_STATISTICS
+    ThreadCpuUsage tcu;     // for reading the current CPU clock frequency in kHz
+#endif
+#endif
+    unsigned coldGen;   // last observed mColdGen
+    bool isWarm;        // true means ready to mix, false means wait for warmup before mixing
+    struct timespec measuredWarmupTs;  // how long did it take for warmup to complete
+    uint32_t warmupCycles;  // counter of number of loop cycles required to warmup
+    NBLog::Writer dummyLogWriter;
+    NBLog::Writer *logWriter;
+    status_t timestampStatus;
+
+    FastThreadState::Command command;
+#if 0
+    size_t frameCount;
+#endif
+    bool attemptedWrite;
 
 };  // class FastThread
 
diff --git a/services/audioflinger/FastThreadState.cpp b/services/audioflinger/FastThreadState.cpp
index 427ada5..d4d6255 100644
--- a/services/audioflinger/FastThreadState.cpp
+++ b/services/audioflinger/FastThreadState.cpp
@@ -14,12 +14,14 @@
  * limitations under the License.
  */
 
+#include "Configuration.h"
 #include "FastThreadState.h"
 
 namespace android {
 
 FastThreadState::FastThreadState() :
-    mCommand(INITIAL), mColdFutexAddr(NULL), mColdGen(0), mNBLogWriter(NULL)
+    mCommand(INITIAL), mColdFutexAddr(NULL), mColdGen(0), mDumpState(NULL), mNBLogWriter(NULL)
+
 {
 }
 
@@ -27,4 +29,21 @@
 {
 }
 
+
+FastThreadDumpState::FastThreadDumpState() :
+    mCommand(FastThreadState::INITIAL), mUnderruns(0), mOverruns(0),
+    /* mMeasuredWarmupTs({0, 0}), */
+    mWarmupCycles(0)
+#ifdef FAST_MIXER_STATISTICS
+    , mSamplingN(0), mBounds(0)
+#endif
+{
+    mMeasuredWarmupTs.tv_sec = 0;
+    mMeasuredWarmupTs.tv_nsec = 0;
+}
+
+FastThreadDumpState::~FastThreadDumpState()
+{
+}
+
 }   // namespace android
diff --git a/services/audioflinger/FastThreadState.h b/services/audioflinger/FastThreadState.h
index 148fb7b..1ab8a0a 100644
--- a/services/audioflinger/FastThreadState.h
+++ b/services/audioflinger/FastThreadState.h
@@ -17,11 +17,14 @@
 #ifndef ANDROID_AUDIO_FAST_THREAD_STATE_H
 #define ANDROID_AUDIO_FAST_THREAD_STATE_H
 
+#include "Configuration.h"
 #include <stdint.h>
 #include <media/nbaio/NBLog.h>
 
 namespace android {
 
+struct FastThreadDumpState;
+
 // Represents a single state of a FastThread
 struct FastThreadState {
                 FastThreadState();
@@ -35,14 +38,51 @@
         IDLE = 3,               // either HOT_IDLE or COLD_IDLE
         EXIT = 4;               // exit from thread
         // additional values defined per subclass
-    Command     mCommand;
-
+    Command     mCommand;       // current command
     int32_t*    mColdFutexAddr; // for COLD_IDLE only, pointer to the associated futex
     unsigned    mColdGen;       // increment when COLD_IDLE is requested so it's only performed once
 
+    // This might be a one-time configuration rather than per-state
+    FastThreadDumpState* mDumpState; // if non-NULL, then update dump state periodically
     NBLog::Writer* mNBLogWriter; // non-blocking logger
+
 };  // struct FastThreadState
 
+
+// FIXME extract common part of comment at FastMixerDumpState
+struct FastThreadDumpState {
+    FastThreadDumpState();
+    /*virtual*/ ~FastThreadDumpState();
+
+    FastThreadState::Command mCommand;   // current command
+    uint32_t mUnderruns;        // total number of underruns
+    uint32_t mOverruns;         // total number of overruns
+    struct timespec mMeasuredWarmupTs;  // measured warmup time
+    uint32_t mWarmupCycles;     // number of loop cycles required to warmup
+
+#ifdef FAST_MIXER_STATISTICS
+    // Recently collected samples of per-cycle monotonic time, thread CPU time, and CPU frequency.
+    // kSamplingN is max size of sampling frame (statistics), and must be a power of 2 <= 0x8000.
+    // The sample arrays are virtually allocated based on this compile-time constant,
+    // but are only initialized and used based on the runtime parameter mSamplingN.
+    static const uint32_t kSamplingN = 0x8000;
+    // Corresponding runtime maximum size of sample arrays, must be a power of 2 <= kSamplingN.
+    uint32_t mSamplingN;
+    // The bounds define the interval of valid samples, and are represented as follows:
+    //      newest open (excluded) endpoint   = lower 16 bits of bounds, modulo N
+    //      oldest closed (included) endpoint = upper 16 bits of bounds, modulo N
+    // Number of valid samples is newest - oldest.
+    uint32_t mBounds;                   // bounds for mMonotonicNs, mThreadCpuNs, and mCpukHz
+    // The elements in the *Ns arrays are in units of nanoseconds <= 3999999999.
+    uint32_t mMonotonicNs[kSamplingN];  // delta monotonic (wall clock) time
+    uint32_t mLoadNs[kSamplingN];       // delta CPU load in time
+#ifdef CPU_FREQUENCY_STATISTICS
+    uint32_t mCpukHz[kSamplingN];       // absolute CPU clock frequency in kHz, bits 0-3 are CPU#
+#endif
+#endif
+
+};  // struct FastThreadDumpState
+
 }   // android
 
 #endif  // ANDROID_AUDIO_FAST_THREAD_STATE_H