android_media_Utils.cpp revision b842599e51e2d3611503c3c7db1111358f99186d 
1/*
2 * Copyright 2011, 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 "AndroidMediaUtils"
19
20#include <utils/Log.h>
21#include "android_media_Utils.h"
22
23#include <media/stagefright/foundation/ADebug.h>
24#include <media/stagefright/foundation/ABuffer.h>
25#include <media/stagefright/foundation/AMessage.h>
26
27namespace android {
28
29bool ConvertKeyValueArraysToKeyedVector(
30        JNIEnv *env, jobjectArray keys, jobjectArray values,
31        KeyedVector<String8, String8>* keyedVector) {
32
33    int nKeyValuePairs = 0;
34    bool failed = false;
35    if (keys != NULL && values != NULL) {
36        nKeyValuePairs = env->GetArrayLength(keys);
37        failed = (nKeyValuePairs != env->GetArrayLength(values));
38    }
39
40    if (!failed) {
41        failed = ((keys != NULL && values == NULL) ||
42                  (keys == NULL && values != NULL));
43    }
44
45    if (failed) {
46        ALOGE("keys and values arrays have different length");
47        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
48        return false;
49    }
50
51    for (int i = 0; i < nKeyValuePairs; ++i) {
52        // No need to check on the ArrayIndexOutOfBoundsException, since
53        // it won't happen here.
54        jstring key = (jstring) env->GetObjectArrayElement(keys, i);
55        jstring value = (jstring) env->GetObjectArrayElement(values, i);
56
57        const char* keyStr = env->GetStringUTFChars(key, NULL);
58        if (!keyStr) {  // OutOfMemoryError
59            return false;
60        }
61
62        const char* valueStr = env->GetStringUTFChars(value, NULL);
63        if (!valueStr) {  // OutOfMemoryError
64            env->ReleaseStringUTFChars(key, keyStr);
65            return false;
66        }
67
68        keyedVector->add(String8(keyStr), String8(valueStr));
69
70        env->ReleaseStringUTFChars(key, keyStr);
71        env->ReleaseStringUTFChars(value, valueStr);
72        env->DeleteLocalRef(key);
73        env->DeleteLocalRef(value);
74    }
75    return true;
76}
77
78static jobject makeIntegerObject(JNIEnv *env, int32_t value) {
79    jclass clazz = env->FindClass("java/lang/Integer");
80    CHECK(clazz != NULL);
81
82    jmethodID integerConstructID = env->GetMethodID(clazz, "<init>", "(I)V");
83    CHECK(integerConstructID != NULL);
84
85    return env->NewObject(clazz, integerConstructID, value);
86}
87
88static jobject makeLongObject(JNIEnv *env, int64_t value) {
89    jclass clazz = env->FindClass("java/lang/Long");
90    CHECK(clazz != NULL);
91
92    jmethodID longConstructID = env->GetMethodID(clazz, "<init>", "(J)V");
93    CHECK(longConstructID != NULL);
94
95    return env->NewObject(clazz, longConstructID, value);
96}
97
98static jobject makeFloatObject(JNIEnv *env, float value) {
99    jclass clazz = env->FindClass("java/lang/Float");
100    CHECK(clazz != NULL);
101
102    jmethodID floatConstructID = env->GetMethodID(clazz, "<init>", "(F)V");
103    CHECK(floatConstructID != NULL);
104
105    return env->NewObject(clazz, floatConstructID, value);
106}
107
108static jobject makeByteBufferObject(
109        JNIEnv *env, const void *data, size_t size) {
110    jbyteArray byteArrayObj = env->NewByteArray(size);
111    env->SetByteArrayRegion(byteArrayObj, 0, size, (const jbyte *)data);
112
113    jclass clazz = env->FindClass("java/nio/ByteBuffer");
114    CHECK(clazz != NULL);
115
116    jmethodID byteBufWrapID =
117        env->GetStaticMethodID(clazz, "wrap", "([B)Ljava/nio/ByteBuffer;");
118    CHECK(byteBufWrapID != NULL);
119
120    jobject byteBufObj = env->CallStaticObjectMethod(
121            clazz, byteBufWrapID, byteArrayObj);
122
123    env->DeleteLocalRef(byteArrayObj); byteArrayObj = NULL;
124
125    return byteBufObj;
126}
127
128static void SetMapInt32(
129        JNIEnv *env, jobject hashMapObj, jmethodID hashMapPutID,
130        const char *key, int32_t value) {
131    jstring keyObj = env->NewStringUTF(key);
132    jobject valueObj = makeIntegerObject(env, value);
133
134    jobject res = env->CallObjectMethod(
135            hashMapObj, hashMapPutID, keyObj, valueObj);
136
137    env->DeleteLocalRef(valueObj); valueObj = NULL;
138    env->DeleteLocalRef(keyObj); keyObj = NULL;
139}
140
141status_t ConvertMessageToMap(
142        JNIEnv *env, const sp<AMessage> &msg, jobject *map) {
143    jclass hashMapClazz = env->FindClass("java/util/HashMap");
144
145    if (hashMapClazz == NULL) {
146        return -EINVAL;
147    }
148
149    jmethodID hashMapConstructID =
150        env->GetMethodID(hashMapClazz, "<init>", "()V");
151
152    if (hashMapConstructID == NULL) {
153        return -EINVAL;
154    }
155
156    jmethodID hashMapPutID =
157        env->GetMethodID(
158                hashMapClazz,
159                "put",
160                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
161
162    if (hashMapPutID == NULL) {
163        return -EINVAL;
164    }
165
166    jobject hashMap = env->NewObject(hashMapClazz, hashMapConstructID);
167
168    for (size_t i = 0; i < msg->countEntries(); ++i) {
169        AMessage::Type valueType;
170        const char *key = msg->getEntryNameAt(i, &valueType);
171
172        jobject valueObj = NULL;
173
174        switch (valueType) {
175            case AMessage::kTypeInt32:
176            {
177                int32_t val;
178                CHECK(msg->findInt32(key, &val));
179
180                valueObj = makeIntegerObject(env, val);
181                break;
182            }
183
184            case AMessage::kTypeInt64:
185            {
186                int64_t val;
187                CHECK(msg->findInt64(key, &val));
188
189                valueObj = makeLongObject(env, val);
190                break;
191            }
192
193            case AMessage::kTypeFloat:
194            {
195                float val;
196                CHECK(msg->findFloat(key, &val));
197
198                valueObj = makeFloatObject(env, val);
199                break;
200            }
201
202            case AMessage::kTypeString:
203            {
204                AString val;
205                CHECK(msg->findString(key, &val));
206
207                valueObj = env->NewStringUTF(val.c_str());
208                break;
209            }
210
211            case AMessage::kTypeBuffer:
212            {
213                sp<ABuffer> buffer;
214                CHECK(msg->findBuffer(key, &buffer));
215
216                valueObj = makeByteBufferObject(
217                        env, buffer->data(), buffer->size());
218                break;
219            }
220
221            case AMessage::kTypeRect:
222            {
223                int32_t left, top, right, bottom;
224                CHECK(msg->findRect(key, &left, &top, &right, &bottom));
225
226                SetMapInt32(
227                        env,
228                        hashMap,
229                        hashMapPutID,
230                        StringPrintf("%s-left", key).c_str(),
231                        left);
232
233                SetMapInt32(
234                        env,
235                        hashMap,
236                        hashMapPutID,
237                        StringPrintf("%s-top", key).c_str(),
238                        top);
239
240                SetMapInt32(
241                        env,
242                        hashMap,
243                        hashMapPutID,
244                        StringPrintf("%s-right", key).c_str(),
245                        right);
246
247                SetMapInt32(
248                        env,
249                        hashMap,
250                        hashMapPutID,
251                        StringPrintf("%s-bottom", key).c_str(),
252                        bottom);
253                break;
254            }
255
256            default:
257                break;
258        }
259
260        if (valueObj != NULL) {
261            jstring keyObj = env->NewStringUTF(key);
262
263            jobject res = env->CallObjectMethod(
264                    hashMap, hashMapPutID, keyObj, valueObj);
265
266            env->DeleteLocalRef(keyObj); keyObj = NULL;
267            env->DeleteLocalRef(valueObj); valueObj = NULL;
268        }
269    }
270
271    *map = hashMap;
272
273    return OK;
274}
275
276status_t ConvertKeyValueArraysToMessage(
277        JNIEnv *env, jobjectArray keys, jobjectArray values,
278        sp<AMessage> *out) {
279    jclass stringClass = env->FindClass("java/lang/String");
280    CHECK(stringClass != NULL);
281
282    jclass integerClass = env->FindClass("java/lang/Integer");
283    CHECK(integerClass != NULL);
284
285    jclass floatClass = env->FindClass("java/lang/Float");
286    CHECK(floatClass != NULL);
287
288    jclass byteBufClass = env->FindClass("java/nio/ByteBuffer");
289    CHECK(byteBufClass != NULL);
290
291    sp<AMessage> msg = new AMessage;
292
293    jsize numEntries = 0;
294
295    if (keys != NULL) {
296        if (values == NULL) {
297            return -EINVAL;
298        }
299
300        numEntries = env->GetArrayLength(keys);
301
302        if (numEntries != env->GetArrayLength(values)) {
303            return -EINVAL;
304        }
305    } else if (values != NULL) {
306        return -EINVAL;
307    }
308
309    for (jsize i = 0; i < numEntries; ++i) {
310        jobject keyObj = env->GetObjectArrayElement(keys, i);
311
312        if (!env->IsInstanceOf(keyObj, stringClass)) {
313            return -EINVAL;
314        }
315
316        const char *tmp = env->GetStringUTFChars((jstring)keyObj, NULL);
317
318        if (tmp == NULL) {
319            return -ENOMEM;
320        }
321
322        AString key = tmp;
323
324        env->ReleaseStringUTFChars((jstring)keyObj, tmp);
325        tmp = NULL;
326
327        jobject valueObj = env->GetObjectArrayElement(values, i);
328
329        if (env->IsInstanceOf(valueObj, stringClass)) {
330            const char *value = env->GetStringUTFChars((jstring)valueObj, NULL);
331
332            if (value == NULL) {
333                return -ENOMEM;
334            }
335
336            msg->setString(key.c_str(), value);
337
338            env->ReleaseStringUTFChars((jstring)valueObj, value);
339            value = NULL;
340        } else if (env->IsInstanceOf(valueObj, integerClass)) {
341            jmethodID intValueID =
342                env->GetMethodID(integerClass, "intValue", "()I");
343            CHECK(intValueID != NULL);
344
345            jint value = env->CallIntMethod(valueObj, intValueID);
346
347            msg->setInt32(key.c_str(), value);
348        } else if (env->IsInstanceOf(valueObj, floatClass)) {
349            jmethodID floatValueID =
350                env->GetMethodID(floatClass, "floatValue", "()F");
351            CHECK(floatValueID != NULL);
352
353            jfloat value = env->CallFloatMethod(valueObj, floatValueID);
354
355            msg->setFloat(key.c_str(), value);
356        } else if (env->IsInstanceOf(valueObj, byteBufClass)) {
357            jmethodID positionID =
358                env->GetMethodID(byteBufClass, "position", "()I");
359            CHECK(positionID != NULL);
360
361            jmethodID limitID =
362                env->GetMethodID(byteBufClass, "limit", "()I");
363            CHECK(limitID != NULL);
364
365            jint position = env->CallIntMethod(valueObj, positionID);
366            jint limit = env->CallIntMethod(valueObj, limitID);
367
368            sp<ABuffer> buffer = new ABuffer(limit - position);
369
370            void *data = env->GetDirectBufferAddress(valueObj);
371
372            if (data != NULL) {
373                memcpy(buffer->data(),
374                       (const uint8_t *)data + position,
375                       buffer->size());
376            } else {
377                jmethodID arrayID =
378                    env->GetMethodID(byteBufClass, "array", "()[B");
379                CHECK(arrayID != NULL);
380
381                jbyteArray byteArray =
382                    (jbyteArray)env->CallObjectMethod(valueObj, arrayID);
383                CHECK(byteArray != NULL);
384
385                env->GetByteArrayRegion(
386                        byteArray,
387                        position,
388                        buffer->size(),
389                        (jbyte *)buffer->data());
390
391                env->DeleteLocalRef(byteArray); byteArray = NULL;
392            }
393
394            msg->setBuffer(key.c_str(), buffer);
395        }
396    }
397
398    *out = msg;
399
400    return OK;
401}
402
403}  // namespace android
404
405