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