android_media_MediaRecorder.cpp revision da996f390e17e16f2dfa60e972e7ebc4f868f37e 
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
63// Returns true if it throws an exception.
64static bool process_media_recorder_call(JNIEnv *env, status_t opStatus, const char* exception, const char* message)
65{
66    LOGV("process_media_recorder_call");
67    if (opStatus == (status_t)INVALID_OPERATION) {
68        jniThrowException(env, "java/lang/IllegalStateException", NULL);
69        return true;
70    } else if (opStatus != (status_t)OK) {
71        jniThrowException(env, exception, message);
72        return true;
73    }
74    return false;
75}
76
77static void android_media_MediaRecorder_setCamera(JNIEnv* env, jobject thiz, jobject camera)
78{
79    sp<Camera> c = get_native_camera(env, camera);
80    MediaRecorder *mr = (MediaRecorder*)env->GetIntField(thiz, fields.context);
81    process_media_recorder_call(env, mr->setCamera(c->remote()),
82            "java/lang/RuntimeException", "setCamera failed.");
83}
84
85static void
86android_media_MediaRecorder_setVideoSource(JNIEnv *env, jobject thiz, jint vs)
87{
88    LOGV("setVideoSource(%d)", vs);
89    if (vs < VIDEO_SOURCE_DEFAULT || vs > VIDEO_SOURCE_CAMERA) {
90        jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid video source");
91        return;
92    }
93    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
94    process_media_recorder_call(env, mr->setVideoSource(vs), "java/lang/RuntimeException", "setVideoSource failed.");
95}
96
97static void
98android_media_MediaRecorder_setAudioSource(JNIEnv *env, jobject thiz, jint as)
99{
100    LOGV("setAudioSource(%d)", as);
101    if (as < AUDIO_SOURCE_DEFAULT || as > AUDIO_SOURCE_MIC) {
102        jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid audio source");
103        return;
104    }
105    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
106    process_media_recorder_call(env, mr->setAudioSource(as), "java/lang/RuntimeException", "setAudioSource failed.");
107}
108
109static void
110android_media_MediaRecorder_setOutputFormat(JNIEnv *env, jobject thiz, jint of)
111{
112    LOGV("setOutputFormat(%d)", of);
113    if (of < OUTPUT_FORMAT_DEFAULT || of >= OUTPUT_FORMAT_LIST_END) {
114        jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid output format");
115        return;
116    }
117    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
118    process_media_recorder_call(env, mr->setOutputFormat(of), "java/lang/RuntimeException", "setOutputFormat failed.");
119}
120
121static void
122android_media_MediaRecorder_setVideoEncoder(JNIEnv *env, jobject thiz, jint ve)
123{
124    LOGV("setVideoEncoder(%d)", ve);
125    if (ve < VIDEO_ENCODER_DEFAULT || ve > VIDEO_ENCODER_MPEG_4_SP) {
126        jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid video encoder");
127        return;
128    }
129    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
130    process_media_recorder_call(env, mr->setVideoEncoder(ve), "java/lang/RuntimeException", "setVideoEncoder failed.");
131}
132
133static void
134android_media_MediaRecorder_setAudioEncoder(JNIEnv *env, jobject thiz, jint ae)
135{
136    LOGV("setAudioEncoder(%d)", ae);
137    if (ae < AUDIO_ENCODER_DEFAULT || ae > AUDIO_ENCODER_AMR_NB) {
138        jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid audio encoder");
139        return;
140    }
141    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
142    process_media_recorder_call(env, mr->setAudioEncoder(ae), "java/lang/RuntimeException", "setAudioEncoder failed.");
143}
144
145static void
146android_media_MediaRecorder_setOutputFileFD(JNIEnv *env, jobject thiz, jobject fileDescriptor, jlong offset, jlong length)
147{
148    LOGV("setOutputFile");
149    if (fileDescriptor == NULL) {
150        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
151        return;
152    }
153    int fd = getParcelFileDescriptorFD(env, fileDescriptor);
154    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
155    status_t opStatus = mr->setOutputFile(fd, offset, length);
156    process_media_recorder_call(env, opStatus, "java/io/IOException", "setOutputFile failed.");
157}
158
159static void
160android_media_MediaRecorder_setVideoSize(JNIEnv *env, jobject thiz, jint width, jint height)
161{
162    LOGV("setVideoSize(%d, %d)", width, height);
163    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
164
165    if (width <= 0 || height <= 0) {
166        jniThrowException(env, "java/lang/IllegalArgumentException", "invalid video size");
167        return;
168    }
169    process_media_recorder_call(env, mr->setVideoSize(width, height), "java/lang/RuntimeException", "setVideoSize failed.");
170}
171
172static void
173android_media_MediaRecorder_setVideoFrameRate(JNIEnv *env, jobject thiz, jint rate)
174{
175    LOGV("setVideoFrameRate(%d)", rate);
176    if (rate <= 0 || rate > MEDIA_RECORDER_MAX_FRAME_RATE) {
177        jniThrowException(env, "java/lang/IllegalArgumentException", "invalid frame rate");
178        return;
179    }
180    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
181    process_media_recorder_call(env, mr->setVideoFrameRate(rate), "java/lang/RuntimeException", "setVideoFrameRate failed.");
182}
183
184static void
185android_media_MediaRecorder_prepare(JNIEnv *env, jobject thiz)
186{
187    LOGV("prepare");
188    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
189
190    jobject surface = env->GetObjectField(thiz, fields.surface);
191    if (surface != NULL) {
192        const sp<Surface>& native_surface = get_surface(env, surface);
193        LOGI("prepare: surface=%p (id=%d)", native_surface.get(), native_surface->ID());
194        if (process_media_recorder_call(env, mr->setPreviewSurface(native_surface), "java/lang/RuntimeException", "setPreviewSurface failed.")) {
195            return;
196        }
197    }
198    process_media_recorder_call(env, mr->prepare(), "java/io/IOException", "prepare failed.");
199}
200
201static int
202android_media_MediaRecorder_native_getMaxAmplitude(JNIEnv *env, jobject thiz)
203{
204    LOGV("getMaxAmplitude");
205    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
206    int result = 0;
207    process_media_recorder_call(env, mr->getMaxAmplitude(&result), "java/lang/RuntimeException", "getMaxAmplitude failed.");
208    return result;
209}
210
211static void
212android_media_MediaRecorder_start(JNIEnv *env, jobject thiz)
213{
214    LOGV("start");
215    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
216    process_media_recorder_call(env, mr->start(), "java/lang/RuntimeException", "start failed.");
217}
218
219static void
220android_media_MediaRecorder_stop(JNIEnv *env, jobject thiz)
221{
222    LOGV("stop");
223    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
224    process_media_recorder_call(env, mr->stop(), "java/lang/RuntimeException", "stop failed.");
225}
226
227static void
228android_media_MediaRecorder_reset(JNIEnv *env, jobject thiz)
229{
230    LOGV("reset");
231    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
232    process_media_recorder_call(env, mr->reset(), "java/lang/RuntimeException", "reset failed.");
233}
234
235static void
236android_media_MediaRecorder_release(JNIEnv *env, jobject thiz)
237{
238    LOGV("release");
239    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
240    env->SetIntField(thiz, fields.context, 0);
241    delete mr;
242}
243
244static void
245android_media_MediaRecorder_native_setup(JNIEnv *env, jobject thiz)
246{
247    LOGV("setup");
248    MediaRecorder *mr = new MediaRecorder();
249    if (mr->initCheck() == NO_ERROR) {
250        env->SetIntField(thiz, fields.context, (int)mr);
251    } else {
252        delete mr;
253        jniThrowException(env, "java/lang/IOException", "Unable to initialize camera");
254    }
255}
256
257static void
258android_media_MediaRecorder_native_finalize(JNIEnv *env, jobject thiz)
259{
260    LOGV("finalize");
261    MediaRecorder *mr = (MediaRecorder *)env->GetIntField(thiz, fields.context);
262    delete mr;
263}
264
265// ----------------------------------------------------------------------------
266
267static JNINativeMethod gMethods[] = {
268    {"setCamera",            "(Landroid/hardware/Camera;)V",    (void *)android_media_MediaRecorder_setCamera},
269    {"setVideoSource",       "(I)V",                            (void *)android_media_MediaRecorder_setVideoSource},
270    {"setAudioSource",       "(I)V",                            (void *)android_media_MediaRecorder_setAudioSource},
271    {"setOutputFormat",      "(I)V",                            (void *)android_media_MediaRecorder_setOutputFormat},
272    {"setVideoEncoder",      "(I)V",                            (void *)android_media_MediaRecorder_setVideoEncoder},
273    {"setAudioEncoder",      "(I)V",                            (void *)android_media_MediaRecorder_setAudioEncoder},
274    {"_setOutputFile",       "(Ljava/io/FileDescriptor;JJ)V",   (void *)android_media_MediaRecorder_setOutputFileFD},
275    {"setVideoSize",         "(II)V",                           (void *)android_media_MediaRecorder_setVideoSize},
276    {"setVideoFrameRate",    "(I)V",                            (void *)android_media_MediaRecorder_setVideoFrameRate},
277    {"_prepare",             "()V",                             (void *)android_media_MediaRecorder_prepare},
278    {"getMaxAmplitude",      "()I",                             (void *)android_media_MediaRecorder_native_getMaxAmplitude},
279    {"start",                "()V",                             (void *)android_media_MediaRecorder_start},
280    {"stop",                 "()V",                             (void *)android_media_MediaRecorder_stop},
281    {"reset",                "()V",                             (void *)android_media_MediaRecorder_reset},
282    {"release",              "()V",                             (void *)android_media_MediaRecorder_release},
283    {"native_setup",         "()V",                             (void *)android_media_MediaRecorder_native_setup},
284    {"native_finalize",      "()V",                             (void *)android_media_MediaRecorder_native_finalize},
285};
286
287static const char* const kClassPathName = "android/media/MediaRecorder";
288
289int register_android_media_MediaRecorder(JNIEnv *env)
290{
291    jclass clazz;
292
293    clazz = env->FindClass("android/media/MediaRecorder");
294    if (clazz == NULL) {
295        LOGE("Can't find android/media/MediaRecorder");
296        return -1;
297    }
298
299    fields.context = env->GetFieldID(clazz, "mNativeContext", "I");
300    if (fields.context == NULL) {
301        LOGE("Can't find MediaRecorder.mNativeContext");
302        return -1;
303    }
304
305    fields.surface = env->GetFieldID(clazz, "mSurface", "Landroid/view/Surface;");
306    if (fields.surface == NULL) {
307        LOGE("Can't find MediaRecorder.mSurface");
308        return -1;
309    }
310
311    jclass surface = env->FindClass("android/view/Surface");
312    if (surface == NULL) {
313        LOGE("Can't find android/view/Surface");
314        return -1;
315    }
316
317    fields.surface_native = env->GetFieldID(surface, "mSurface", "I");
318    if (fields.surface_native == NULL) {
319        LOGE("Can't find Surface fields");
320        return -1;
321    }
322
323    return AndroidRuntime::registerNativeMethods(env,
324                "android/media/MediaRecorder", gMethods, NELEM(gMethods));
325}
326
327
328