NdkMediaFormat.cpp revision 7c9b141d551fde406f199f0dd21582f8551aea23 
1/*
2 * Copyright (C) 2014 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 "NdkMediaFormat"
19
20
21#include "NdkMediaFormat.h"
22
23#include <utils/Log.h>
24#include <utils/StrongPointer.h>
25#include <media/stagefright/foundation/ABuffer.h>
26#include <media/stagefright/foundation/AMessage.h>
27#include <media/stagefright/MetaData.h>
28#include <android_runtime/AndroidRuntime.h>
29#include <android_util_Binder.h>
30
31#include <jni.h>
32
33using namespace android;
34
35struct AMediaFormat {
36    sp<AMessage> mFormat;
37    String8 mDebug;
38    KeyedVector<String8, String8> mStringCache;
39};
40
41extern "C" {
42
43// private functions for conversion to/from AMessage
44AMediaFormat* AMediaFormat_fromMsg(void* data) {
45    ALOGV("private ctor");
46    AMediaFormat* mData = new AMediaFormat();
47    mData->mFormat = *((sp<AMessage>*)data);
48    return mData;
49}
50
51void AMediaFormat_getFormat(AMediaFormat* mData, void* dest) {
52    *((sp<AMessage>*)dest) = mData->mFormat;
53}
54
55
56/*
57 * public function follow
58 */
59AMediaFormat *AMediaFormat_new() {
60    ALOGV("ctor");
61    sp<AMessage> msg = new AMessage();
62    return AMediaFormat_fromMsg(&msg);
63}
64
65int AMediaFormat_delete(AMediaFormat *mData) {
66    ALOGV("dtor");
67    delete mData;
68    return OK;
69}
70
71
72const char* AMediaFormat_toString(AMediaFormat *mData) {
73    sp<AMessage> f = mData->mFormat;
74    String8 ret;
75    int num = f->countEntries();
76    for (int i = 0; i < num; i++) {
77        if (i != 0) {
78            ret.append(", ");
79        }
80        AMessage::Type t;
81        const char *name = f->getEntryNameAt(i, &t);
82        ret.append(name);
83        ret.append(": ");
84        switch (t) {
85            case AMessage::kTypeInt32:
86            {
87                int32_t val;
88                f->findInt32(name, &val);
89                ret.appendFormat("int32(%d)", val);
90                break;
91            }
92            case AMessage::kTypeInt64:
93            {
94                int64_t val;
95                f->findInt64(name, &val);
96                ret.appendFormat("int64(%lld)", val);
97                break;
98            }
99            case AMessage::kTypeSize:
100            {
101                size_t val;
102                f->findSize(name, &val);
103                ret.appendFormat("size_t(%d)", val);
104                break;
105            }
106            case AMessage::kTypeFloat:
107            {
108                float val;
109                f->findFloat(name, &val);
110                ret.appendFormat("float(%f)", val);
111                break;
112            }
113            case AMessage::kTypeDouble:
114            {
115                double val;
116                f->findDouble(name, &val);
117                ret.appendFormat("double(%f)", val);
118                break;
119            }
120            case AMessage::kTypeString:
121            {
122                AString val;
123                f->findString(name, &val);
124                ret.appendFormat("string(%s)", val.c_str());
125                break;
126            }
127            case AMessage::kTypeBuffer:
128            {
129                ret.appendFormat("data");
130                break;
131            }
132            default:
133            {
134                ret.appendFormat("unknown(%d)", t);
135                break;
136            }
137        }
138    }
139    ret.append("}");
140    mData->mDebug = ret;
141    return mData->mDebug.string();
142}
143
144bool AMediaFormat_getInt32(AMediaFormat* mData, const char *name, int32_t *out) {
145    return mData->mFormat->findInt32(name, out);
146}
147
148bool AMediaFormat_getInt64(AMediaFormat* mData, const char *name, int64_t *out) {
149    return mData->mFormat->findInt64(name, out);
150}
151
152bool AMediaFormat_getFloat(AMediaFormat* mData, const char *name, float *out) {
153    return mData->mFormat->findFloat(name, out);
154}
155
156bool AMediaFormat_getDouble(AMediaFormat* mData, const char *name, double *out) {
157    return mData->mFormat->findDouble(name, out);
158}
159
160bool AMediaFormat_getSize(AMediaFormat* mData, const char *name, size_t *out) {
161    return mData->mFormat->findSize(name, out);
162}
163
164bool AMediaFormat_getString(AMediaFormat* mData, const char *name, const char **out) {
165
166    for (size_t i = 0; i < mData->mStringCache.size(); i++) {
167        if (strcmp(mData->mStringCache.keyAt(i).string(), name) == 0) {
168            mData->mStringCache.removeItemsAt(i, 1);
169            break;
170        }
171    }
172
173    AString tmp;
174    if (mData->mFormat->findString(name, &tmp)) {
175        String8 ret(tmp.c_str());
176        mData->mStringCache.add(String8(name), ret);
177        *out = ret.string();
178        return true;
179    }
180    return false;
181}
182
183const char* AMEDIAFORMAT_KEY_AAC_PROFILE = "aac-profile";
184const char* AMEDIAFORMAT_KEY_BIT_RATE = "bitrate";
185const char* AMEDIAFORMAT_KEY_CHANNEL_COUNT = "channel-count";
186const char* AMEDIAFORMAT_KEY_CHANNEL_MASK = "channel-mask";
187const char* AMEDIAFORMAT_KEY_COLOR_FORMAT = "color-format";
188const char* AMEDIAFORMAT_KEY_DURATION = "durationUs";
189const char* AMEDIAFORMAT_KEY_FLAC_COMPRESSION_LEVEL = "flac-compression-level";
190const char* AMEDIAFORMAT_KEY_FRAME_RATE = "frame-rate";
191const char* AMEDIAFORMAT_KEY_HEIGHT = "height";
192const char* AMEDIAFORMAT_KEY_IS_ADTS = "is-adts";
193const char* AMEDIAFORMAT_KEY_IS_AUTOSELECT = "is-autoselect";
194const char* AMEDIAFORMAT_KEY_IS_DEFAULT = "is-default";
195const char* AMEDIAFORMAT_KEY_IS_FORCED_SUBTITLE = "is-forced-subtitle";
196const char* AMEDIAFORMAT_KEY_I_FRAME_INTERVAL = "i-frame-interval";
197const char* AMEDIAFORMAT_KEY_LANGUAGE = "language";
198const char* AMEDIAFORMAT_KEY_MAX_HEIGHT = "max-height";
199const char* AMEDIAFORMAT_KEY_MAX_INPUT_SIZE = "max-input-size";
200const char* AMEDIAFORMAT_KEY_MAX_WIDTH = "max-width";
201const char* AMEDIAFORMAT_KEY_MIME = "mime";
202const char* AMEDIAFORMAT_KEY_PUSH_BLANK_BUFFERS_ON_STOP = "push-blank-buffers-on-shutdown";
203const char* AMEDIAFORMAT_KEY_REPEAT_PREVIOUS_FRAME_AFTER = "repeat-previous-frame-after";
204const char* AMEDIAFORMAT_KEY_SAMPLE_RATE = "sample-rate";
205const char* AMEDIAFORMAT_KEY_WIDTH = "width";
206const char* AMEDIAFORMAT_KEY_STRIDE = "stride";
207
208
209} // extern "C"
210
211
212