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