IMediaRecorder.cpp revision 99ffda877980468a9ae31e013cd10fb3645df1b0 
1/*
2 **
3 ** Copyright 2008, HTC Inc.
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//#define LOG_NDEBUG 0
19#define LOG_TAG "IMediaRecorder"
20#include <utils/Log.h>
21#include <utils/Parcel.h>
22#include <ui/ISurface.h>
23#include <ui/ICamera.h>
24#include <media/IMediaPlayerClient.h>
25#include <media/IMediaRecorder.h>
26
27namespace android {
28
29enum {
30    RELEASE = IBinder::FIRST_CALL_TRANSACTION,
31    INIT,
32    CLOSE,
33    RESET,
34    STOP,
35    START,
36    PREPARE,
37    GET_MAX_AMPLITUDE,
38    SET_VIDEO_SOURCE,
39    SET_AUDIO_SOURCE,
40    SET_OUTPUT_FORMAT,
41    SET_VIDEO_ENCODER,
42    SET_AUDIO_ENCODER,
43    SET_OUTPUT_FILE_PATH,
44    SET_OUTPUT_FILE_FD,
45    SET_VIDEO_SIZE,
46    SET_VIDEO_FRAMERATE,
47    SET_PREVIEW_SURFACE,
48    SET_CAMERA,
49    SET_LISTENER
50};
51
52class BpMediaRecorder: public BpInterface<IMediaRecorder>
53{
54public:
55    BpMediaRecorder(const sp<IBinder>& impl)
56    : BpInterface<IMediaRecorder>(impl)
57    {
58    }
59
60    status_t setCamera(const sp<ICamera>& camera)
61    {
62        LOGV("setCamera(%p)", camera.get());
63        Parcel data, reply;
64        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
65        data.writeStrongBinder(camera->asBinder());
66        remote()->transact(SET_CAMERA, data, &reply);
67        return reply.readInt32();
68    }
69
70    status_t setPreviewSurface(const sp<ISurface>& surface)
71    {
72        LOGV("setPreviewSurface(%p)", surface.get());
73        Parcel data, reply;
74        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
75        data.writeStrongBinder(surface->asBinder());
76        remote()->transact(SET_PREVIEW_SURFACE, data, &reply);
77        return reply.readInt32();
78    }
79
80    status_t init()
81    {
82        LOGV("init");
83        Parcel data, reply;
84        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
85        remote()->transact(INIT, data, &reply);
86        return reply.readInt32();
87    }
88
89    status_t setVideoSource(int vs)
90    {
91        LOGV("setVideoSource(%d)", vs);
92        Parcel data, reply;
93        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
94        data.writeInt32(vs);
95        remote()->transact(SET_VIDEO_SOURCE, data, &reply);
96        return reply.readInt32();
97    }
98
99    status_t setAudioSource(int as)
100    {
101        LOGV("setAudioSource(%d)", as);
102        Parcel data, reply;
103        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
104        data.writeInt32(as);
105        remote()->transact(SET_AUDIO_SOURCE, data, &reply);
106        return reply.readInt32();
107    }
108
109    status_t setOutputFormat(int of)
110    {
111        LOGV("setOutputFormat(%d)", of);
112        Parcel data, reply;
113        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
114        data.writeInt32(of);
115        remote()->transact(SET_OUTPUT_FORMAT, data, &reply);
116        return reply.readInt32();
117    }
118
119    status_t setVideoEncoder(int ve)
120    {
121        LOGV("setVideoEncoder(%d)", ve);
122        Parcel data, reply;
123        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
124        data.writeInt32(ve);
125        remote()->transact(SET_VIDEO_ENCODER, data, &reply);
126        return reply.readInt32();
127    }
128
129    status_t setAudioEncoder(int ae)
130    {
131        LOGV("setAudioEncoder(%d)", ae);
132        Parcel data, reply;
133        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
134        data.writeInt32(ae);
135        remote()->transact(SET_AUDIO_ENCODER, data, &reply);
136        return reply.readInt32();
137    }
138
139    status_t setOutputFile(const char* path)
140    {
141        LOGV("setOutputFile(%s)", path);
142        Parcel data, reply;
143        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
144        data.writeCString(path);
145        remote()->transact(SET_OUTPUT_FILE_PATH, data, &reply);
146        return reply.readInt32();
147    }
148
149    status_t setOutputFile(int fd, int64_t offset, int64_t length) {
150        LOGV("setOutputFile(%d, %lld, %lld)", fd, offset, length);
151        Parcel data, reply;
152        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
153        data.writeFileDescriptor(fd);
154        data.writeInt64(offset);
155        data.writeInt64(length);
156        remote()->transact(SET_OUTPUT_FILE_FD, data, &reply);
157        return reply.readInt32();
158    }
159
160    status_t setVideoSize(int width, int height)
161    {
162        LOGV("setVideoSize(%dx%d)", width, height);
163        Parcel data, reply;
164        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
165        data.writeInt32(width);
166        data.writeInt32(height);
167        remote()->transact(SET_VIDEO_SIZE, data, &reply);
168        return reply.readInt32();
169    }
170
171    status_t setVideoFrameRate(int frames_per_second)
172    {
173        LOGV("setVideoFrameRate(%d)", frames_per_second);
174        Parcel data, reply;
175        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
176        data.writeInt32(frames_per_second);
177        remote()->transact(SET_VIDEO_FRAMERATE, data, &reply);
178        return reply.readInt32();
179    }
180
181    status_t setListener(const sp<IMediaPlayerClient>& listener)
182    {
183        LOGV("setListener(%p)", listener.get());
184        Parcel data, reply;
185        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
186        data.writeStrongBinder(listener->asBinder());
187        remote()->transact(SET_LISTENER, data, &reply);
188        return reply.readInt32();
189    }
190
191    status_t prepare()
192    {
193        LOGV("prepare");
194        Parcel data, reply;
195        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
196        remote()->transact(PREPARE, data, &reply);
197        return reply.readInt32();
198    }
199
200    status_t getMaxAmplitude(int* max)
201    {
202        LOGV("getMaxAmplitude");
203        Parcel data, reply;
204        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
205        remote()->transact(GET_MAX_AMPLITUDE, data, &reply);
206        *max = reply.readInt32();
207        return reply.readInt32();
208    }
209
210    status_t start()
211    {
212        LOGV("start");
213        Parcel data, reply;
214        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
215        remote()->transact(START, data, &reply);
216        return reply.readInt32();
217    }
218
219    status_t stop()
220    {
221        LOGV("stop");
222        Parcel data, reply;
223        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
224        remote()->transact(STOP, data, &reply);
225        return reply.readInt32();
226    }
227
228    status_t reset()
229    {
230        LOGV("reset");
231        Parcel data, reply;
232        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
233        remote()->transact(RESET, data, &reply);
234        return reply.readInt32();
235    }
236
237    status_t close()
238    {
239        LOGV("close");
240        Parcel data, reply;
241        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
242        remote()->transact(CLOSE, data, &reply);
243        return reply.readInt32();
244    }
245
246    status_t release()
247    {
248        LOGV("release");
249        Parcel data, reply;
250        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
251        remote()->transact(RELEASE, data, &reply);
252        return reply.readInt32();
253    }
254};
255
256IMPLEMENT_META_INTERFACE(MediaRecorder, "android.hardware.IMediaRecorder");
257
258// ----------------------------------------------------------------------
259
260#define CHECK_INTERFACE(interface, data, reply) \
261    do { if (!data.enforceInterface(interface::getInterfaceDescriptor())) { \
262        LOGW("Call incorrectly routed to " #interface); \
263        return PERMISSION_DENIED; \
264    } } while (0)
265
266status_t BnMediaRecorder::onTransact(
267                                     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
268{
269    switch(code) {
270        case RELEASE: {
271            LOGV("RELEASE");
272            CHECK_INTERFACE(IMediaRecorder, data, reply);
273            reply->writeInt32(release());
274            return NO_ERROR;
275        } break;
276        case INIT: {
277            LOGV("INIT");
278            CHECK_INTERFACE(IMediaRecorder, data, reply);
279            reply->writeInt32(init());
280            return NO_ERROR;
281        } break;
282        case CLOSE: {
283            LOGV("CLOSE");
284            CHECK_INTERFACE(IMediaRecorder, data, reply);
285            reply->writeInt32(close());
286            return NO_ERROR;
287        } break;
288        case RESET: {
289            LOGV("RESET");
290            CHECK_INTERFACE(IMediaRecorder, data, reply);
291            reply->writeInt32(reset());
292            return NO_ERROR;
293        } break;
294        case STOP: {
295            LOGV("STOP");
296            CHECK_INTERFACE(IMediaRecorder, data, reply);
297            reply->writeInt32(stop());
298            return NO_ERROR;
299        } break;
300        case START: {
301            LOGV("START");
302            CHECK_INTERFACE(IMediaRecorder, data, reply);
303            reply->writeInt32(start());
304            return NO_ERROR;
305        } break;
306        case PREPARE: {
307            LOGV("PREPARE");
308            CHECK_INTERFACE(IMediaRecorder, data, reply);
309            reply->writeInt32(prepare());
310            return NO_ERROR;
311        } break;
312        case GET_MAX_AMPLITUDE: {
313            LOGV("GET_MAX_AMPLITUDE");
314            CHECK_INTERFACE(IMediaRecorder, data, reply);
315            int max = 0;
316            status_t ret = getMaxAmplitude(&max);
317            reply->writeInt32(max);
318            reply->writeInt32(ret);
319            return NO_ERROR;
320        } break;
321        case SET_VIDEO_SOURCE: {
322            LOGV("SET_VIDEO_SOURCE");
323            CHECK_INTERFACE(IMediaRecorder, data, reply);
324            int vs = data.readInt32();
325            reply->writeInt32(setVideoSource(vs));
326            return NO_ERROR;
327        } break;
328        case SET_AUDIO_SOURCE: {
329            LOGV("SET_AUDIO_SOURCE");
330            CHECK_INTERFACE(IMediaRecorder, data, reply);
331            int as = data.readInt32();
332            reply->writeInt32(setAudioSource(as));
333            return NO_ERROR;
334        } break;
335        case SET_OUTPUT_FORMAT: {
336            LOGV("SET_OUTPUT_FORMAT");
337            CHECK_INTERFACE(IMediaRecorder, data, reply);
338            int of = data.readInt32();
339            reply->writeInt32(setOutputFormat(of));
340            return NO_ERROR;
341        } break;
342        case SET_VIDEO_ENCODER: {
343            LOGV("SET_VIDEO_ENCODER");
344            CHECK_INTERFACE(IMediaRecorder, data, reply);
345            int ve = data.readInt32();
346            reply->writeInt32(setVideoEncoder(ve));
347            return NO_ERROR;
348        } break;
349        case SET_AUDIO_ENCODER: {
350            LOGV("SET_AUDIO_ENCODER");
351            CHECK_INTERFACE(IMediaRecorder, data, reply);
352            int ae = data.readInt32();
353            reply->writeInt32(setAudioEncoder(ae));
354            return NO_ERROR;
355
356        } break;
357        case SET_OUTPUT_FILE_PATH: {
358            LOGV("SET_OUTPUT_FILE_PATH");
359            CHECK_INTERFACE(IMediaRecorder, data, reply);
360            const char* path = data.readCString();
361            reply->writeInt32(setOutputFile(path));
362            return NO_ERROR;
363        } break;
364        case SET_OUTPUT_FILE_FD: {
365            LOGV("SET_OUTPUT_FILE_FD");
366            CHECK_INTERFACE(IMediaRecorder, data, reply);
367            int fd = dup(data.readFileDescriptor());
368            int64_t offset = data.readInt64();
369            int64_t length = data.readInt64();
370            reply->writeInt32(setOutputFile(fd, offset, length));
371            return NO_ERROR;
372        } break;
373        case SET_VIDEO_SIZE: {
374            LOGV("SET_VIDEO_SIZE");
375            CHECK_INTERFACE(IMediaRecorder, data, reply);
376            int width = data.readInt32();
377            int height = data.readInt32();
378            reply->writeInt32(setVideoSize(width, height));
379            return NO_ERROR;
380        } break;
381        case SET_VIDEO_FRAMERATE: {
382            LOGV("SET_VIDEO_FRAMERATE");
383            CHECK_INTERFACE(IMediaRecorder, data, reply);
384            int frames_per_second = data.readInt32();
385            reply->writeInt32(setVideoFrameRate(frames_per_second));
386            return NO_ERROR;
387        } break;
388        case SET_LISTENER: {
389            LOGV("SET_LISTENER");
390            CHECK_INTERFACE(IMediaRecorder, data, reply);
391            sp<IMediaPlayerClient> listener =
392                interface_cast<IMediaPlayerClient>(data.readStrongBinder());
393            reply->writeInt32(setListener(listener));
394            return NO_ERROR;
395        } break;
396        case SET_PREVIEW_SURFACE: {
397            LOGV("SET_PREVIEW_SURFACE");
398            CHECK_INTERFACE(IMediaRecorder, data, reply);
399            sp<ISurface> surface = interface_cast<ISurface>(data.readStrongBinder());
400            reply->writeInt32(setPreviewSurface(surface));
401            return NO_ERROR;
402        } break;
403        case SET_CAMERA: {
404            LOGV("SET_CAMERA");
405            CHECK_INTERFACE(IMediaRecorder, data, reply);
406            sp<ICamera> camera = interface_cast<ICamera>(data.readStrongBinder());
407            reply->writeInt32(setCamera(camera));
408            return NO_ERROR;
409        } break;
410        default:
411            return BBinder::onTransact(code, data, reply, flags);
412    }
413}
414
415// ----------------------------------------------------------------------------
416
417}; // namespace android
418