1 /*
2 * Copyright 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 #define LOG_TAG "AudioEndpointParcelable"
18 //#define LOG_NDEBUG 0
19 #include <utils/Log.h>
20
21 #include <stdint.h>
22
23 #include <binder/Parcel.h>
24 #include <binder/Parcelable.h>
25 #include <utility/AAudioUtilities.h>
26
27 #include "binding/AAudioServiceDefinitions.h"
28 #include "binding/RingBufferParcelable.h"
29 #include "binding/AudioEndpointParcelable.h"
30
31 using android::base::unique_fd;
32 using android::media::SharedFileRegion;
33 using android::NO_ERROR;
34 using android::status_t;
35
36 using namespace aaudio;
37
AudioEndpointParcelable(Endpoint && parcelable)38 AudioEndpointParcelable::AudioEndpointParcelable(Endpoint&& parcelable)
39 : mUpMessageQueueParcelable(std::move(parcelable.upMessageQueueParcelable)),
40 mDownMessageQueueParcelable(std::move(parcelable.downMessageQueueParcelable)),
41 mUpDataQueueParcelable(std::move(parcelable.upDataQueueParcelable)),
42 mDownDataQueueParcelable(std::move(parcelable.downDataQueueParcelable)),
43 mNumSharedMemories(parcelable.sharedMemories.size()) {
44 for (size_t i = 0; i < parcelable.sharedMemories.size() && i < MAX_SHARED_MEMORIES; ++i) {
45 // Re-construct.
46 mSharedMemories[i].~SharedMemoryParcelable();
47 new(&mSharedMemories[i]) SharedMemoryParcelable(std::move(parcelable.sharedMemories[i]));
48 }
49 }
50
operator =(Endpoint && parcelable)51 AudioEndpointParcelable& AudioEndpointParcelable::operator=(Endpoint&& parcelable) {
52 this->~AudioEndpointParcelable();
53 new(this) AudioEndpointParcelable(std::move(parcelable));
54 return *this;
55 }
56
parcelable()57 Endpoint AudioEndpointParcelable::parcelable()&& {
58 Endpoint result;
59 result.upMessageQueueParcelable = std::move(mUpMessageQueueParcelable).parcelable();
60 result.downMessageQueueParcelable = std::move(mDownMessageQueueParcelable).parcelable();
61 result.upDataQueueParcelable = std::move(mUpDataQueueParcelable).parcelable();
62 result.downDataQueueParcelable = std::move(mDownDataQueueParcelable).parcelable();
63 result.sharedMemories.reserve(std::min(mNumSharedMemories, MAX_SHARED_MEMORIES));
64 for (size_t i = 0; i < mNumSharedMemories && i < MAX_SHARED_MEMORIES; ++i) {
65 result.sharedMemories.emplace_back(std::move(mSharedMemories[i]).parcelable());
66 }
67 return result;
68 }
69
70 /**
71 * Add the file descriptor to the table.
72 * @return index in table or negative error
73 */
addFileDescriptor(const unique_fd & fd,int32_t sizeInBytes)74 int32_t AudioEndpointParcelable::addFileDescriptor(const unique_fd& fd,
75 int32_t sizeInBytes) {
76 if (mNumSharedMemories >= MAX_SHARED_MEMORIES) {
77 return AAUDIO_ERROR_OUT_OF_RANGE;
78 }
79 int32_t index = mNumSharedMemories++;
80 mSharedMemories[index].setup(fd, sizeInBytes);
81 return index;
82 }
83
resolve(EndpointDescriptor * descriptor)84 aaudio_result_t AudioEndpointParcelable::resolve(EndpointDescriptor *descriptor) {
85 aaudio_result_t result = mUpMessageQueueParcelable.resolve(mSharedMemories,
86 &descriptor->upMessageQueueDescriptor);
87 if (result != AAUDIO_OK) return result;
88 result = mDownMessageQueueParcelable.resolve(mSharedMemories,
89 &descriptor->downMessageQueueDescriptor);
90 if (result != AAUDIO_OK) return result;
91
92 result = mDownDataQueueParcelable.resolve(mSharedMemories,
93 &descriptor->dataQueueDescriptor);
94 return result;
95 }
96
close()97 aaudio_result_t AudioEndpointParcelable::close() {
98 int err = 0;
99 for (int i = 0; i < mNumSharedMemories; i++) {
100 int lastErr = mSharedMemories[i].close();
101 if (lastErr < 0) err = lastErr;
102 }
103 return AAudioConvert_androidToAAudioResult(err);
104 }
105
validate() const106 aaudio_result_t AudioEndpointParcelable::validate() const {
107 if (mNumSharedMemories < 0 || mNumSharedMemories >= MAX_SHARED_MEMORIES) {
108 ALOGE("invalid mNumSharedMemories = %d", mNumSharedMemories);
109 return AAUDIO_ERROR_INTERNAL;
110 }
111 return AAUDIO_OK;
112 }
113
dump()114 void AudioEndpointParcelable::dump() {
115 ALOGD("======================================= BEGIN");
116 ALOGD("mNumSharedMemories = %d", mNumSharedMemories);
117 for (int i = 0; i < mNumSharedMemories; i++) {
118 mSharedMemories[i].dump();
119 }
120 ALOGD("mUpMessageQueueParcelable =========");
121 mUpMessageQueueParcelable.dump();
122 ALOGD("mDownMessageQueueParcelable =======");
123 mDownMessageQueueParcelable.dump();
124 ALOGD("mUpDataQueueParcelable ============");
125 mUpDataQueueParcelable.dump();
126 ALOGD("mDownDataQueueParcelable ==========");
127 mDownDataQueueParcelable.dump();
128 ALOGD("======================================= END");
129 }
130
131