blob: 89f2b448494437c86fae8a82ace18820ca0d1734 [file] [log] [blame]
Andreas Hubere2b10282010-11-23 11:41:34 -08001/*
2 * Copyright (C) 2010 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_NDEBUG 0
18#define LOG_TAG "IStreamSource"
19#include <utils/Log.h>
20
21#include <media/IStreamSource.h>
22
23#include <binder/IMemory.h>
24#include <binder/Parcel.h>
25
26namespace android {
27
28enum {
29 // IStreamSource
30 SET_LISTENER = IBinder::FIRST_CALL_TRANSACTION,
31 SET_BUFFERS,
32 ON_BUFFER_AVAILABLE,
33
34 // IStreamListener
35 QUEUE_BUFFER,
36 QUEUE_COMMAND,
37};
38
39struct BpStreamSource : public BpInterface<IStreamSource> {
40 BpStreamSource(const sp<IBinder> &impl)
41 : BpInterface<IStreamSource>(impl) {
42 }
43
44 virtual void setListener(const sp<IStreamListener> &listener) {
45 Parcel data, reply;
46 data.writeInterfaceToken(IStreamSource::getInterfaceDescriptor());
47 data.writeStrongBinder(listener->asBinder());
48 remote()->transact(SET_LISTENER, data, &reply);
49 }
50
51 virtual void setBuffers(const Vector<sp<IMemory> > &buffers) {
52 Parcel data, reply;
53 data.writeInterfaceToken(IStreamSource::getInterfaceDescriptor());
54 data.writeInt32(static_cast<int32_t>(buffers.size()));
55 for (size_t i = 0; i < buffers.size(); ++i) {
56 data.writeStrongBinder(buffers.itemAt(i)->asBinder());
57 }
58 remote()->transact(SET_BUFFERS, data, &reply);
59 }
60
61 virtual void onBufferAvailable(size_t index) {
62 Parcel data, reply;
63 data.writeInterfaceToken(IStreamSource::getInterfaceDescriptor());
64 data.writeInt32(static_cast<int32_t>(index));
65 remote()->transact(
66 ON_BUFFER_AVAILABLE, data, &reply, IBinder::FLAG_ONEWAY);
67 }
68};
69
70IMPLEMENT_META_INTERFACE(StreamSource, "android.hardware.IStreamSource");
71
72status_t BnStreamSource::onTransact(
73 uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
74 switch (code) {
75 case SET_LISTENER:
76 {
77 CHECK_INTERFACE(IStreamSource, data, reply);
78 setListener(
79 interface_cast<IStreamListener>(data.readStrongBinder()));
80 break;
81 }
82
83 case SET_BUFFERS:
84 {
85 CHECK_INTERFACE(IStreamSource, data, reply);
86 size_t n = static_cast<size_t>(data.readInt32());
87 Vector<sp<IMemory> > buffers;
88 for (size_t i = 0; i < n; ++i) {
89 sp<IMemory> mem =
90 interface_cast<IMemory>(data.readStrongBinder());
91
92 buffers.push(mem);
93 }
94 setBuffers(buffers);
95 break;
96 }
97
98 case ON_BUFFER_AVAILABLE:
99 {
100 CHECK_INTERFACE(IStreamSource, data, reply);
101 onBufferAvailable(static_cast<size_t>(data.readInt32()));
102 break;
103 }
104
105 default:
106 return BBinder::onTransact(code, data, reply, flags);
107 }
108
109 return OK;
110}
111
112////////////////////////////////////////////////////////////////////////////////
113
114struct BpStreamListener : public BpInterface<IStreamListener> {
115 BpStreamListener(const sp<IBinder> &impl)
116 : BpInterface<IStreamListener>(impl) {
117 }
118
119 virtual void queueBuffer(size_t index, size_t size) {
120 Parcel data, reply;
121 data.writeInterfaceToken(IStreamListener::getInterfaceDescriptor());
122 data.writeInt32(static_cast<int32_t>(index));
123 data.writeInt32(static_cast<int32_t>(size));
124
125 remote()->transact(QUEUE_BUFFER, data, &reply, IBinder::FLAG_ONEWAY);
126 }
127
128 virtual void queueCommand(Command cmd) {
129 Parcel data, reply;
130 data.writeInterfaceToken(IStreamListener::getInterfaceDescriptor());
131 data.writeInt32(static_cast<int32_t>(cmd));
132
133 remote()->transact(QUEUE_COMMAND, data, &reply, IBinder::FLAG_ONEWAY);
134 }
135};
136
137IMPLEMENT_META_INTERFACE(StreamListener, "android.hardware.IStreamListener");
138
139status_t BnStreamListener::onTransact(
140 uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
141 switch (code) {
142 case QUEUE_BUFFER:
143 {
144 CHECK_INTERFACE(IStreamListener, data, reply);
145 size_t index = static_cast<size_t>(data.readInt32());
146 size_t size = static_cast<size_t>(data.readInt32());
147
148 queueBuffer(index, size);
149 break;
150 }
151
152 case QUEUE_COMMAND:
153 {
154 CHECK_INTERFACE(IStreamListener, data, reply);
155 Command cmd = static_cast<Command>(data.readInt32());
156
157 queueCommand(cmd);
158 break;
159 }
160
161 default:
162 return BBinder::onTransact(code, data, reply, flags);
163 }
164
165 return OK;
166}
167
168} // namespace android