AudioStreamInternal.h revision cf5f6d2825d9a8430a291042ca9c6f68e5b666d0 
1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_AAUDIO_AUDIO_STREAM_INTERNAL_H
18#define ANDROID_AAUDIO_AUDIO_STREAM_INTERNAL_H
19
20#include <stdint.h>
21#include <aaudio/AAudio.h>
22
23#include "binding/IAAudioService.h"
24#include "binding/AudioEndpointParcelable.h"
25#include "binding/AAudioServiceInterface.h"
26#include "client/IsochronousClockModel.h"
27#include "client/AudioEndpoint.h"
28#include "core/AudioStream.h"
29#include "utility/LinearRamp.h"
30
31using android::sp;
32using android::IAAudioService;
33
34namespace aaudio {
35
36// A stream that talks to the AAudioService or directly to a HAL.
37class AudioStreamInternal : public AudioStream {
38
39public:
40    AudioStreamInternal(AAudioServiceInterface  &serviceInterface, bool inService);
41    virtual ~AudioStreamInternal();
42
43    // =========== Begin ABSTRACT methods ===========================
44    aaudio_result_t requestStart() override;
45
46    aaudio_result_t requestPause() override;
47
48    aaudio_result_t requestFlush() override;
49
50    aaudio_result_t requestStop() override;
51
52    aaudio_result_t getTimestamp(clockid_t clockId,
53                                       int64_t *framePosition,
54                                       int64_t *timeNanoseconds) override;
55
56    virtual aaudio_result_t updateStateWhileWaiting() override;
57    // =========== End ABSTRACT methods ===========================
58
59    aaudio_result_t open(const AudioStreamBuilder &builder) override;
60
61    aaudio_result_t close() override;
62
63    aaudio_result_t setBufferSize(int32_t requestedFrames) override;
64
65    int32_t getBufferSize() const override;
66
67    int32_t getBufferCapacity() const override;
68
69    int32_t getFramesPerBurst() const override;
70
71    int32_t getXRunCount() const override {
72        return mXRunCount;
73    }
74
75    aaudio_result_t registerThread() override;
76
77    aaudio_result_t unregisterThread() override;
78
79    aaudio_result_t joinThread(void** returnArg);
80
81    // Called internally from 'C'
82    virtual void *callbackLoop() = 0;
83
84
85    bool isMMap() override {
86        return true;
87    }
88
89    // Calculate timeout based on framesPerBurst
90    int64_t calculateReasonableTimeout();
91
92protected:
93
94    aaudio_result_t processData(void *buffer,
95                         int32_t numFrames,
96                         int64_t timeoutNanoseconds);
97
98/**
99 * Low level data processing that will not block. It will just read or write as much as it can.
100 *
101 * It passed back a recommended time to wake up if wakeTimePtr is not NULL.
102 *
103 * @return the number of frames processed or a negative error code.
104 */
105    virtual aaudio_result_t processDataNow(void *buffer,
106                            int32_t numFrames,
107                            int64_t currentTimeNanos,
108                            int64_t *wakeTimePtr) = 0;
109
110    aaudio_result_t processCommands();
111
112    aaudio_result_t requestPauseInternal();
113    aaudio_result_t requestStopInternal();
114
115    aaudio_result_t stopCallback();
116
117
118    void onFlushFromServer();
119
120    aaudio_result_t onEventFromServer(AAudioServiceMessage *message);
121
122    aaudio_result_t onTimestampFromServer(AAudioServiceMessage *message);
123
124    // Calculate timeout for an operation involving framesPerOperation.
125    int64_t calculateReasonableTimeout(int32_t framesPerOperation);
126
127    aaudio_audio_format_t    mDeviceFormat = AAUDIO_FORMAT_UNSPECIFIED;
128
129    IsochronousClockModel    mClockModel;      // timing model for chasing the HAL
130
131    AudioEndpoint            mAudioEndpoint;   // source for reads or sink for writes
132    aaudio_handle_t          mServiceStreamHandle; // opaque handle returned from service
133
134    int32_t                  mFramesPerBurst;     // frames per HAL transfer
135    int32_t                  mXRunCount = 0;      // how many underrun events?
136
137    LinearRamp               mVolumeRamp;
138
139    // Offset from underlying frame position.
140    int64_t                  mFramesOffsetFromService = 0; // offset for timestamps
141
142    uint8_t                 *mCallbackBuffer = nullptr;
143    int32_t                  mCallbackFrames = 0;
144
145private:
146    /*
147     * Asynchronous write with data conversion.
148     * @param buffer
149     * @param numFrames
150     * @return fdrames written or negative error
151     */
152    aaudio_result_t writeNowWithConversion(const void *buffer,
153                                     int32_t numFrames);
154
155    // Adjust timing model based on timestamp from service.
156    void processTimestamp(uint64_t position, int64_t time);
157
158    AudioEndpointParcelable  mEndPointParcelable; // description of the buffers filled by service
159    EndpointDescriptor       mEndpointDescriptor; // buffer description with resolved addresses
160    AAudioServiceInterface  &mServiceInterface;   // abstract interface to the service
161
162    // The service uses this for SHARED mode.
163    bool                     mInService = false;  // Is this running in the client or the service?
164};
165
166} /* namespace aaudio */
167
168#endif //ANDROID_AAUDIO_AUDIO_STREAM_INTERNAL_H
169