Remove TimedAudioTrack and associated code

    virtual ~AudioBufferProvider() {}

    // value representing an invalid presentation timestamp

    static const int64_t kInvalidPTS = 0x7FFFFFFFFFFFFFFFLL;    // <stdint.h> is too painful

    // pts is the local time when the next sample yielded by getNextBuffer

    // will be rendered.

    // Pass kInvalidPTS if the PTS is unknown or not applicable.

    // On entry:

    //  buffer              != NULL

    //  buffer->raw         unused

    //  status              != NO_ERROR

    //  buffer->raw         NULL

    //  buffer->frameCount  0

    virtual status_t getNextBuffer(Buffer* buffer, int64_t pts = kInvalidPTS) = 0;

    virtual status_t getNextBuffer(Buffer* buffer) = 0;

    // Release (a portion of) the buffer previously obtained by getNextBuffer().

    // It is permissible to call releaseBuffer() multiple times per getNextBuffer().

    mutable Mutex           mLock;

    bool                    mIsTimed;

    int                     mPreviousPriority;          // before start()

    SchedPolicy             mPreviousSchedulingGroup;

    bool                    mAwaitBoost;    // thread should wait for priority boost before running

    sp<AudioSystem::AudioDeviceCallback> mDeviceCallback;

};

class TimedAudioTrack : public AudioTrack

{

public:

    TimedAudioTrack();

    /* allocate a shared memory buffer that can be passed to queueTimedBuffer */

    status_t allocateTimedBuffer(size_t size, sp<IMemory>* buffer);

    /* queue a buffer obtained via allocateTimedBuffer for playback at the

       given timestamp.  PTS units are microseconds on the media time timeline.

       The media time transform (set with setMediaTimeTransform) set by the

       audio producer will handle converting from media time to local time

       (perhaps going through the common time timeline in the case of

       synchronized multiroom audio case) */

    status_t queueTimedBuffer(const sp<IMemory>& buffer, int64_t pts);

    /* define a transform between media time and either common time or

       local time */

    enum TargetTimeline {LOCAL_TIME, COMMON_TIME};

    status_t setMediaTimeTransform(const LinearTransform& xform,

                                   TargetTimeline target);

};

}; // namespace android

#endif // ANDROID_AUDIOTRACK_H

    // or-able bits shared by createTrack and openRecord, but not all combinations make sense

    enum {

        TRACK_DEFAULT = 0,  // client requests a default AudioTrack

        TRACK_TIMED   = 1,  // client requests a TimedAudioTrack

        // FIXME: obsolete

        // TRACK_TIMED= 1,  // client requests a TimedAudioTrack

        TRACK_FAST    = 2,  // client requests a fast AudioTrack or AudioRecord

        TRACK_OFFLOAD = 4,  // client requests offload to hw codec

        TRACK_DIRECT = 8,   // client requests a direct output

#include <utils/Errors.h>

#include <binder/IInterface.h>

#include <binder/IMemory.h>

#include <utils/LinearTransform.h>

#include <utils/String8.h>

#include <media/AudioTimestamp.h>

     */

    virtual status_t    attachAuxEffect(int effectId) = 0;

    /* Allocate a shared memory buffer suitable for holding timed audio

       samples */

    virtual status_t    allocateTimedBuffer(size_t size,

                                            sp<IMemory>* buffer) = 0;

    /* Queue a buffer obtained via allocateTimedBuffer for playback at the given

       timestamp */

    virtual status_t    queueTimedBuffer(const sp<IMemory>& buffer,

                                         int64_t pts) = 0;

    /* Define the linear transform that will be applied to the timestamps

       given to queueTimedBuffer (which are expressed in media time).

       Target specifies whether this transform converts media time to local time

       or Tungsten time. The values for target are defined in AudioTrack.h */

    virtual status_t    setMediaTimeTransform(const LinearTransform& xform,

                                              int target) = 0;

    /* Send parameters to the audio hardware */

    virtual status_t    setParameters(const String8& keyValuePairs) = 0;

    //virtual size_t framesOverrun();

    //virtual size_t overruns();

    virtual ssize_t availableToRead();

    virtual ssize_t read(void *buffer, size_t count, int64_t readPTS);

    virtual ssize_t readVia(readVia_t via, size_t total, void *user,

                            int64_t readPTS, size_t block);

    virtual ssize_t read(void *buffer, size_t count);

    virtual ssize_t readVia(readVia_t via, size_t total, void *user, size_t block);

private:

    AudioBufferProvider * const mProvider;