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
23 class RecordTrack : public TrackBase {
24 public:
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                                 uid_t uid,
34                                 audio_input_flags_t flags,
35                                 track_type type,
36                                 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
37     virtual             ~RecordTrack();
38     virtual status_t    initCheck() const;
39 
40     virtual status_t    start(AudioSystem::sync_event_t event, audio_session_t triggerSession);
41     virtual void        stop();
42 
43             void        destroy();
44 
45     virtual void        invalidate();
46             // clear the buffer overflow flag
clearOverflow()47             void        clearOverflow() { mOverflow = false; }
48             // set the buffer overflow flag and return previous value
setOverflow()49             bool        setOverflow() { bool tmp = mOverflow; mOverflow = true;
50                                                 return tmp; }
51 
52     static  void        appendDumpHeader(String8& result);
53             void        dump(char* buffer, size_t size, bool active);
54 
55             void        handleSyncStartEvent(const sp<SyncEvent>& event);
56             void        clearSyncStartEvent();
57 
58             void        updateTrackFrameInfo(int64_t trackFramesReleased,
59                                              int64_t sourceFramesRead,
60                                              uint32_t halSampleRate,
61                                              const ExtendedTimestamp &timestamp);
62 
isFastTrack()63     virtual bool        isFastTrack() const { return (mFlags & AUDIO_INPUT_FLAG_FAST) != 0; }
64 
65 private:
66     friend class AudioFlinger;  // for mState
67 
68                         RecordTrack(const RecordTrack&);
69                         RecordTrack& operator = (const RecordTrack&);
70 
71     // AudioBufferProvider interface
72     virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
73     // releaseBuffer() not overridden
74 
75     bool                mOverflow;  // overflow on most recent attempt to fill client buffer
76 
77             AudioBufferProvider::Buffer mSink;  // references client's buffer sink in shared memory
78 
79             // sync event triggering actual audio capture. Frames read before this event will
80             // be dropped and therefore not read by the application.
81             sp<SyncEvent>                       mSyncStartEvent;
82 
83             // number of captured frames to drop after the start sync event has been received.
84             // when < 0, maximum frames to drop before starting capture even if sync event is
85             // not received
86             ssize_t                             mFramesToDrop;
87 
88             // used by resampler to find source frames
89             ResamplerBufferProvider            *mResamplerBufferProvider;
90 
91             // used by the record thread to convert frames to proper destination format
92             RecordBufferConverter              *mRecordBufferConverter;
93             audio_input_flags_t                mFlags;
94 };
95 
96 // playback track, used by PatchPanel
97 class PatchRecord : virtual public RecordTrack, public PatchProxyBufferProvider {
98 public:
99 
100     PatchRecord(RecordThread *recordThread,
101                 uint32_t sampleRate,
102                 audio_channel_mask_t channelMask,
103                 audio_format_t format,
104                 size_t frameCount,
105                 void *buffer,
106                 audio_input_flags_t flags);
107     virtual             ~PatchRecord();
108 
109     // AudioBufferProvider interface
110     virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
111     virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
112 
113     // PatchProxyBufferProvider interface
114     virtual status_t    obtainBuffer(Proxy::Buffer *buffer,
115                                      const struct timespec *timeOut = NULL);
116     virtual void        releaseBuffer(Proxy::Buffer *buffer);
117 
setPeerProxy(PatchProxyBufferProvider * proxy)118     void setPeerProxy(PatchProxyBufferProvider *proxy) { mPeerProxy = proxy; }
119 
120 private:
121     sp<ClientProxy>             mProxy;
122     PatchProxyBufferProvider*   mPeerProxy;
123     struct timespec             mPeerTimeout;
124 };  // end of PatchRecord
125