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