AudioStreamInternal.h revision 71f35bb687476694882a617ba4a810a0bb56fe23 
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 AAUDIO_AUDIOSTREAMINTERNAL_H
18#define AAUDIO_AUDIOSTREAMINTERNAL_H
19
20#include <stdint.h>
21#include <aaudio/AAudio.h>
22
23#include "binding/IAAudioService.h"
24#include "binding/AudioEndpointParcelable.h"
25#include "client/IsochronousClockModel.h"
26#include "client/AudioEndpoint.h"
27#include "core/AudioStream.h"
28
29#include "binding/AAudioServiceInterface.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 = false);
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    // TODO use aaudio_clockid_t all the way down to AudioClock
53    aaudio_result_t getTimestamp(clockid_t clockId,
54                                       int64_t *framePosition,
55                                       int64_t *timeNanoseconds) override;
56
57
58
59    virtual aaudio_result_t updateStateWhileWaiting() override;
60
61    // =========== End ABSTRACT methods ===========================
62
63    aaudio_result_t open(const AudioStreamBuilder &builder) override;
64
65    aaudio_result_t close() override;
66
67    aaudio_result_t write(const void *buffer,
68                             int32_t numFrames,
69                             int64_t timeoutNanoseconds) override;
70
71    aaudio_result_t setBufferSize(int32_t requestedFrames) override;
72
73    int32_t getBufferSize() const override;
74
75    int32_t getBufferCapacity() const override;
76
77    int32_t getFramesPerBurst() const override;
78
79    int64_t getFramesRead() override;
80
81    int32_t getXRunCount() const override {
82        return mXRunCount;
83    }
84
85    aaudio_result_t registerThread() override;
86
87    aaudio_result_t unregisterThread() override;
88
89    // Called internally from 'C'
90    void *callbackLoop();
91
92protected:
93
94    aaudio_result_t processCommands();
95
96    aaudio_result_t requestPauseInternal();
97    aaudio_result_t requestStopInternal();
98
99    aaudio_result_t stopCallback();
100
101/**
102 * Low level write that will not block. It will just write as much as it can.
103 *
104 * It passed back a recommended time to wake up if wakeTimePtr is not NULL.
105 *
106 * @return the number of frames written or a negative error code.
107 */
108    aaudio_result_t writeNow(const void *buffer,
109                                     int32_t numFrames,
110                                     int64_t currentTimeNanos,
111                                     int64_t *wakeTimePtr);
112
113    void onFlushFromServer();
114
115    aaudio_result_t onEventFromServer(AAudioServiceMessage *message);
116
117    aaudio_result_t onTimestampFromServer(AAudioServiceMessage *message);
118
119    // Calculate timeout for an operation involving framesPerOperation.
120    int64_t calculateReasonableTimeout(int32_t framesPerOperation);
121
122private:
123    /*
124     * Asynchronous write with data conversion.
125     * @param buffer
126     * @param numFrames
127     * @return fdrames written or negative error
128     */
129    aaudio_result_t writeNowWithConversion(const void *buffer,
130                                     int32_t numFrames);
131    void processTimestamp(uint64_t position, int64_t time);
132
133
134    const char *getLocationName() const {
135        return mInService ? "SERVICE" : "CLIENT";
136    }
137
138    // Adjust timing model based on timestamp from service.
139
140    IsochronousClockModel    mClockModel;      // timing model for chasing the HAL
141    AudioEndpoint            mAudioEndpoint;   // sink for writes
142    aaudio_handle_t          mServiceStreamHandle; // opaque handle returned from service
143
144    AudioEndpointParcelable  mEndPointParcelable; // description of the buffers filled by service
145    EndpointDescriptor       mEndpointDescriptor; // buffer description with resolved addresses
146
147    aaudio_audio_format_t    mDeviceFormat = AAUDIO_FORMAT_UNSPECIFIED;
148
149    uint8_t                 *mCallbackBuffer = nullptr;
150    int32_t                  mCallbackFrames = 0;
151
152    // Offset from underlying frame position.
153    int64_t                  mFramesOffsetFromService = 0; // offset for timestamps
154    int64_t                  mLastFramesRead = 0; // used to prevent retrograde motion
155    int32_t                  mFramesPerBurst;     // frames per HAL transfer
156    int32_t                  mXRunCount = 0;      // how many underrun events?
157    float                    mVolume = 1.0;       // volume that the server told us to use
158
159    AAudioServiceInterface  &mServiceInterface;   // abstract interface to the service
160
161    // The service uses this for SHARED mode.
162    bool                     mInService = false;  // Are running in the client or the service?
163};
164
165} /* namespace aaudio */
166
167#endif //AAUDIO_AUDIOSTREAMINTERNAL_H
168