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