android_media_MediaRecorder.cpp revision f013e1afd1e68af5e3b868c26a653bbfb39538f8 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "MediaRecorderJNI"
19#include <utils/Log.h>
20
21#include <ui/SurfaceComposerClient.h>
22#include <ui/ICameraService.h>
23#include <ui/Camera.h>
24#include <media/mediarecorder.h>
25#include <stdio.h>
26#include <assert.h>
27#include <limits.h>
28#include <unistd.h>
29#include <fcntl.h>
30#include <utils/threads.h>
31
32#include "jni.h"
33#include "JNIHelp.h"
34#include "android_runtime/AndroidRuntime.h"
35
36
37// ----------------------------------------------------------------------------
38
39using namespace android;
40
41// ----------------------------------------------------------------------------
42
43// helper function to extract a native Camera object from a Camera Java object
44extern sp<Camera> get_native_camera(JNIEnv *env, jobject thiz);
45
46struct fields_t {
47    jfieldID    context;
48    jfieldID    surface;
49    /* actually in android.view.Surface XXX */
50    jfieldID    surface_native;
51};
52static fields_t fields;
53
54// ----------------------------------------------------------------------------
55
56static sp<Surface> get_surface(JNIEnv* env, jobject clazz)
57{
58    LOGV("get_surface");
59    Surface* const p = (Surface*)env->GetIntField(clazz, fields.surface_native);
60    return sp<Surface>(p);
61}
62
63static void process_media_recorder_call(JNIEnv *env, status_t opStatus, const char* exception, const char* message)
64{
65    LOGV("process_media_recorder_call");
66    if (opStatus == (status_t)INVALID_OPERATION) {
67        jniThrowException(env, "java/lang/IllegalStateException", NULL);
68    } else if (opStatus != (status_t)OK) {
69        jniThrowException(env, exception, message);
70    }
71    return;
72}
73
74static void android_media_MediaRecorder_setCamera(JNIEnv* env, jobject thiz, jobject camera)
75{
76    sp<Camera> c = get_native_camera(env, camera);
77    MediaRecorder *mr = (MediaRecorder*)env->GetIntField(thiz, fields.context);
78    process_media_recorder_call(env, mr->setCamera(c->remote()),
79            "java/lang/RuntimeException", "setCamera failed.");
80}
81
82static void
83android_media_MediaRecorder_setVideoSource(JNIEnv *env, jobject thiz, jint vs)
84{
85    LOGV("setVideoSource(%d)", vs);
86    if (vs < VIDEO_SOURCE_DEFAULT || vs > VIDEO_SOURCE_CAMERA) {
87        jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid video source");
88        return;
89    }
90    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
91    process_media_recorder_call(env, mr->setVideoSource(vs), "java/lang/RuntimeException", "setVideoSource failed.");
92}
93
94static void
95android_media_MediaRecorder_setAudioSource(JNIEnv *env, jobject thiz, jint as)
96{
97    LOGV("setAudioSource(%d)", as);
98    if (as < AUDIO_SOURCE_DEFAULT || as > AUDIO_SOURCE_MIC) {
99        jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid audio source");
100        return;
101    }
102    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
103    process_media_recorder_call(env, mr->setAudioSource(as), "java/lang/RuntimeException", "setAudioSource failed.");
104}
105
106static void
107android_media_MediaRecorder_setOutputFormat(JNIEnv *env, jobject thiz, jint of)
108{
109    LOGV("setOutputFormat(%d)", of);
110    if (of < OUTPUT_FORMAT_DEFAULT || of >= OUTPUT_FORMAT_LIST_END) {
111        jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid output format");
112        return;
113    }
114    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
115    process_media_recorder_call(env, mr->setOutputFormat(of), "java/lang/RuntimeException", "setOutputFormat failed.");
116}
117
118static void
119android_media_MediaRecorder_setVideoEncoder(JNIEnv *env, jobject thiz, jint ve)
120{
121    LOGV("setVideoEncoder(%d)", ve);
122    if (ve < VIDEO_ENCODER_DEFAULT || ve > VIDEO_ENCODER_MPEG_4_SP) {
123        jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid video encoder");
124        return;
125    }
126    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
127    process_media_recorder_call(env, mr->setVideoEncoder(ve), "java/lang/RuntimeException", "setVideoEncoder failed.");
128}
129
130static void
131android_media_MediaRecorder_setAudioEncoder(JNIEnv *env, jobject thiz, jint ae)
132{
133    LOGV("setAudioEncoder(%d)", ae);
134    if (ae < AUDIO_ENCODER_DEFAULT || ae > AUDIO_ENCODER_AMR_NB) {
135        jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid audio encoder");
136        return;
137    }
138    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
139    process_media_recorder_call(env, mr->setAudioEncoder(ae), "java/lang/RuntimeException", "setAudioEncoder failed.");
140}
141
142static void
143android_media_MediaRecorder_setOutputFile(JNIEnv *env, jobject thiz, jstring path)
144{
145    LOGV("setOutputFile");
146    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
147
148    if (path == NULL) {
149        jniThrowException(env, "java/lang/IllegalArgumentException", "Path is a NULL pointer");
150        return;
151    }
152    const char *pathStr = env->GetStringUTFChars(path, NULL);
153    if (pathStr == NULL) {  // Out of memory
154        jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
155        return;
156    }
157    status_t opStatus = mr->setOutputFile(pathStr);
158
159    // Make sure that local ref is released before a potential exception
160    env->ReleaseStringUTFChars(path, pathStr);
161    process_media_recorder_call(env, opStatus, "java/lang/RuntimeException", "setOutputFile failed.");
162}
163
164static void
165android_media_MediaRecorder_setVideoSize(JNIEnv *env, jobject thiz, jint width, jint height)
166{
167    LOGV("setVideoSize(%d, %d)", width, height);
168    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
169
170    if (width <= 0 || height <= 0) {
171        jniThrowException(env, "java/lang/IllegalArgumentException", "invalid video size");
172        return;
173    }
174    process_media_recorder_call(env, mr->setVideoSize(width, height), "java/lang/RuntimeException", "setVideoSize failed.");
175}
176
177static void
178android_media_MediaRecorder_setVideoFrameRate(JNIEnv *env, jobject thiz, jint rate)
179{
180    LOGV("setVideoFrameRate(%d)", rate);
181    if (rate <= 0 || rate > MEDIA_RECORDER_MAX_FRAME_RATE) {
182        jniThrowException(env, "java/lang/IllegalArgumentException", "invalid frame rate");
183        return;
184    }
185    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
186    process_media_recorder_call(env, mr->setVideoFrameRate(rate), "java/lang/RuntimeException", "setVideoFrameRate failed.");
187}
188
189static void
190android_media_MediaRecorder_prepare(JNIEnv *env, jobject thiz)
191{
192    LOGV("prepare");
193    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
194
195    jobject surface = env->GetObjectField(thiz, fields.surface);
196    if (surface != NULL) {
197        const sp<Surface>& native_surface = get_surface(env, surface);
198        LOGI("prepare: surface=%p (id=%d)", native_surface.get(), native_surface->ID());
199        process_media_recorder_call(env, mr->setPreviewSurface(native_surface), "java/lang/RuntimeException", "setPreviewSurface failed.");
200    }
201    process_media_recorder_call(env, mr->prepare(), "java/io/IOException", "prepare failed.");
202}
203
204static int
205android_media_MediaRecorder_native_getMaxAmplitude(JNIEnv *env, jobject thiz)
206{
207    LOGV("getMaxAmplitude");
208    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
209    int result = 0;
210    process_media_recorder_call(env, mr->getMaxAmplitude(&result), "java/lang/RuntimeException", "getMaxAmplitude failed.");
211    return result;
212}
213
214static void
215android_media_MediaRecorder_start(JNIEnv *env, jobject thiz)
216{
217    LOGV("start");
218    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
219    process_media_recorder_call(env, mr->start(), "java/lang/RuntimeException", "start failed.");
220}
221
222static void
223android_media_MediaRecorder_stop(JNIEnv *env, jobject thiz)
224{
225    LOGV("stop");
226    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
227    process_media_recorder_call(env, mr->stop(), "java/lang/RuntimeException", "stop failed.");
228}
229
230static void
231android_media_MediaRecorder_reset(JNIEnv *env, jobject thiz)
232{
233    LOGV("reset");
234    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
235    process_media_recorder_call(env, mr->reset(), "java/lang/RuntimeException", "reset failed.");
236}
237
238static void
239android_media_MediaRecorder_release(JNIEnv *env, jobject thiz)
240{
241    LOGV("release");
242    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
243    env->SetIntField(thiz, fields.context, 0);
244    delete mr;
245}
246
247static void
248android_media_MediaRecorder_native_setup(JNIEnv *env, jobject thiz)
249{
250    LOGV("setup");
251    MediaRecorder *mr = new MediaRecorder();
252    if (mr->initCheck() == NO_ERROR) {
253        env->SetIntField(thiz, fields.context, (int)mr);
254    } else {
255        delete mr;
256        jniThrowException(env, "java/lang/IOException", "Unable to initialize camera");
257    }
258}
259
260static void
261android_media_MediaRecorder_native_finalize(JNIEnv *env, jobject thiz)
262{
263    LOGV("finalize");
264    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
265    delete mr;
266}
267
268// ----------------------------------------------------------------------------
269
270static JNINativeMethod gMethods[] = {
271    {"setCamera",            "(Landroid/hardware/Camera;)V",(void *)android_media_MediaRecorder_setCamera},
272    {"setVideoSource",       "(I)V",                    (void *)android_media_MediaRecorder_setVideoSource},
273    {"setAudioSource",       "(I)V",                    (void *)android_media_MediaRecorder_setAudioSource},
274    {"setOutputFormat",      "(I)V",                    (void *)android_media_MediaRecorder_setOutputFormat},
275    {"setVideoEncoder",      "(I)V",                    (void *)android_media_MediaRecorder_setVideoEncoder},
276    {"setAudioEncoder",      "(I)V",                    (void *)android_media_MediaRecorder_setAudioEncoder},
277    {"setOutputFile",        "(Ljava/lang/String;)V",   (void *)android_media_MediaRecorder_setOutputFile},
278    {"setVideoSize",         "(II)V",                   (void *)android_media_MediaRecorder_setVideoSize},
279    {"setVideoFrameRate",    "(I)V",                    (void *)android_media_MediaRecorder_setVideoFrameRate},
280    {"prepare",              "()V",                     (void *)android_media_MediaRecorder_prepare},
281    {"getMaxAmplitude",      "()I",                     (void *)android_media_MediaRecorder_native_getMaxAmplitude},
282    {"start",                "()V",                     (void *)android_media_MediaRecorder_start},
283    {"stop",                 "()V",                     (void *)android_media_MediaRecorder_stop},
284    {"reset",                "()V",                     (void *)android_media_MediaRecorder_reset},
285    {"release",              "()V",                     (void *)android_media_MediaRecorder_release},
286    {"native_setup",         "()V",                     (void *)android_media_MediaRecorder_native_setup},
287    {"native_finalize",      "()V",                     (void *)android_media_MediaRecorder_native_finalize},
288};
289
290static const char* const kClassPathName = "android/media/MediaRecorder";
291
292int register_android_media_MediaRecorder(JNIEnv *env)
293{
294    jclass clazz;
295
296    clazz = env->FindClass("android/media/MediaRecorder");
297    if (clazz == NULL) {
298        LOGE("Can't find android/media/MediaRecorder");
299        return -1;
300    }
301
302    fields.context = env->GetFieldID(clazz, "mNativeContext", "I");
303    if (fields.context == NULL) {
304        LOGE("Can't find MediaRecorder.mNativeContext");
305        return -1;
306    }
307
308    fields.surface = env->GetFieldID(clazz, "mSurface", "Landroid/view/Surface;");
309    if (fields.surface == NULL) {
310        LOGE("Can't find MediaRecorder.mSurface");
311        return -1;
312    }
313
314    jclass surface = env->FindClass("android/view/Surface");
315    if (surface == NULL) {
316        LOGE("Can't find android/view/Surface");
317        return -1;
318    }
319
320    fields.surface_native = env->GetFieldID(surface, "mSurface", "I");
321    if (fields.surface_native == NULL) {
322        LOGE("Can't find Surface fields");
323        return -1;
324    }
325
326    return AndroidRuntime::registerNativeMethods(env,
327                "android/media/MediaRecorder", gMethods, NELEM(gMethods));
328}
329
330
331