[go: nahoru, domu]
1/*
2**
3** Copyright 2012, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#ifndef INCLUDING_FROM_AUDIOFLINGER_H
19    #error This header file should only be included from AudioFlinger.h
20#endif
21
22// record track
23class RecordTrack : public TrackBase {
24public:
25                        RecordTrack(RecordThread *thread,
26                                const sp<Client>& client,
27                                uint32_t sampleRate,
28                                audio_format_t format,
29                                audio_channel_mask_t channelMask,
30                                size_t frameCount,
31                                void *buffer,
32                                audio_session_t sessionId,
33                                int uid,
34                                IAudioFlinger::track_flags_t flags,
35                                track_type type);
36    virtual             ~RecordTrack();
37    virtual status_t    initCheck() const;
38
39    virtual status_t    start(AudioSystem::sync_event_t event, audio_session_t triggerSession);
40    virtual void        stop();
41
42            void        destroy();
43
44            void        invalidate();
45            // clear the buffer overflow flag
46            void        clearOverflow() { mOverflow = false; }
47            // set the buffer overflow flag and return previous value
48            bool        setOverflow() { bool tmp = mOverflow; mOverflow = true;
49                                                return tmp; }
50
51    static  void        appendDumpHeader(String8& result);
52            void        dump(char* buffer, size_t size, bool active);
53
54            void        handleSyncStartEvent(const sp<SyncEvent>& event);
55            void        clearSyncStartEvent();
56
57            void        updateTrackFrameInfo(int64_t trackFramesReleased,
58                                             int64_t sourceFramesRead,
59                                             uint32_t halSampleRate,
60                                             const ExtendedTimestamp &timestamp);
61private:
62    friend class AudioFlinger;  // for mState
63
64                        RecordTrack(const RecordTrack&);
65                        RecordTrack& operator = (const RecordTrack&);
66
67    // AudioBufferProvider interface
68    virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
69    // releaseBuffer() not overridden
70
71    bool                mOverflow;  // overflow on most recent attempt to fill client buffer
72
73            AudioBufferProvider::Buffer mSink;  // references client's buffer sink in shared memory
74
75            // sync event triggering actual audio capture. Frames read before this event will
76            // be dropped and therefore not read by the application.
77            sp<SyncEvent>                       mSyncStartEvent;
78
79            // number of captured frames to drop after the start sync event has been received.
80            // when < 0, maximum frames to drop before starting capture even if sync event is
81            // not received
82            ssize_t                             mFramesToDrop;
83
84            // used by resampler to find source frames
85            ResamplerBufferProvider            *mResamplerBufferProvider;
86
87            // used by the record thread to convert frames to proper destination format
88            RecordBufferConverter              *mRecordBufferConverter;
89};
90
91// playback track, used by PatchPanel
92class PatchRecord : virtual public RecordTrack, public PatchProxyBufferProvider {
93public:
94
95    PatchRecord(RecordThread *recordThread,
96                uint32_t sampleRate,
97                audio_channel_mask_t channelMask,
98                audio_format_t format,
99                size_t frameCount,
100                void *buffer,
101                IAudioFlinger::track_flags_t flags);
102    virtual             ~PatchRecord();
103
104    // AudioBufferProvider interface
105    virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
106    virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
107
108    // PatchProxyBufferProvider interface
109    virtual status_t    obtainBuffer(Proxy::Buffer *buffer,
110                                     const struct timespec *timeOut = NULL);
111    virtual void        releaseBuffer(Proxy::Buffer *buffer);
112
113    void setPeerProxy(PatchProxyBufferProvider *proxy) { mPeerProxy = proxy; }
114
115private:
116    sp<ClientProxy>             mProxy;
117    PatchProxyBufferProvider*   mPeerProxy;
118    struct timespec             mPeerTimeout;
119};  // end of PatchRecord
120