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