| /* |
| * Copyright (C) 2021 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "NativeMediaFormatUnitTest" |
| #include <log/log.h> |
| |
| #include <jni.h> |
| #include <media/NdkMediaFormat.h> |
| |
| #include <cinttypes> |
| #include <map> |
| #include <string> |
| |
| static const char story[] = {"What if after you die, God asks you: 'so how was heaven'"}; |
| static const char dragon[] = {"e4 c5 Nf3 d6 d4 cxd4 Nxd4 Nf6 Nc3 g6"}; |
| |
| class Rect { |
| public: |
| int left; |
| int top; |
| int right; |
| int bottom; |
| |
| Rect(int a, int b, int c, int d) : left{a}, top{b}, right{c}, bottom{d} {}; |
| }; |
| |
| class Buffer { |
| public: |
| char* buffer; |
| size_t size; |
| |
| explicit Buffer(char* buffer = nullptr, size_t size = 0) : buffer{buffer}, size{size} {}; |
| }; |
| |
| class NativeMediaFormatUnitTest { |
| private: |
| std::map<int32_t, const char*> mInt32KeyValuePairs; |
| std::map<int64_t, const char*> mInt64KeyValuePairs; |
| std::map<float, const char*> mFloatKeyValuePairs; |
| std::map<double, const char*> mDoubleKeyValuePairs; |
| std::map<size_t, const char*> mSizeKeyValuePairs; |
| std::map<const char*, const char*> mStringKeyValuePairs; |
| std::map<Rect*, const char*> mWindowKeyValuePairs; |
| std::map<Buffer*, const char*> mBufferKeyValuePairs; |
| |
| public: |
| NativeMediaFormatUnitTest(); |
| ~NativeMediaFormatUnitTest(); |
| |
| bool validateFormatInt32(AMediaFormat* fmt, int offset = 0, bool isClear = false); |
| bool validateFormatInt64(AMediaFormat* fmt, int offset = 0, bool isClear = false); |
| bool validateFormatFloat(AMediaFormat* fmt, float offset = 0.0f, bool isClear = false); |
| bool validateFormatDouble(AMediaFormat* fmt, double offset = 0.0, bool isClear = false); |
| bool validateFormatSize(AMediaFormat* fmt, size_t offset = 0, bool isClear = false); |
| bool validateFormatString(AMediaFormat* fmt, int offset = 0, bool isClear = false); |
| bool validateFormatRect(AMediaFormat* fmt, int offset = 0, bool isClear = false); |
| bool validateFormatBuffer(AMediaFormat* fmt, int offset = 0, bool isClear = false); |
| bool validateFormat(AMediaFormat* fmt, int offset = 0, bool isClear = false); |
| |
| void configureFormatInt32(AMediaFormat* fmt, int offset = 0); |
| void configureFormatInt64(AMediaFormat* fmt, int offset = 0); |
| void configureFormatFloat(AMediaFormat* fmt, float offset = 0.0f); |
| void configureFormatDouble(AMediaFormat* fmt, double offset = 0.0); |
| void configureFormatSize(AMediaFormat* fmt, size_t offset = 0); |
| void configureFormatString(AMediaFormat* fmt, int offset = 0); |
| void configureFormatRect(AMediaFormat* fmt, int offset = 0); |
| void configureFormatBuffer(AMediaFormat* fmt, int offset = 0); |
| void configureFormat(AMediaFormat* fmt, int offset = 0); |
| }; |
| |
| NativeMediaFormatUnitTest::NativeMediaFormatUnitTest() { |
| mInt32KeyValuePairs.insert({118, "elements in periodic table"}); |
| mInt32KeyValuePairs.insert({5778, "surface temp. of sun in kelvin"}); |
| mInt32KeyValuePairs.insert({8611, "k2 peak in mts"}); |
| mInt32KeyValuePairs.insert({72, "heart rate in bpm"}); |
| mInt64KeyValuePairs.insert({299792458L, "vel. of em wave in free space m/s"}); |
| mInt64KeyValuePairs.insert({86400L, "number of seconds in a day"}); |
| mInt64KeyValuePairs.insert({1520200000L, "distance of earth from the sun in km"}); |
| mInt64KeyValuePairs.insert({39000000L, "forest area of the world km^2"}); |
| mFloatKeyValuePairs.insert({22.0f / 7.0f, "pi"}); |
| mFloatKeyValuePairs.insert({3.6f, "not great, not terrible"}); |
| mFloatKeyValuePairs.insert({15.999f, "atomic weight of oxygen 8"}); |
| mFloatKeyValuePairs.insert({2.7182f, "Euler's number"}); |
| mDoubleKeyValuePairs.insert({44.0 / 7, "tau"}); |
| mDoubleKeyValuePairs.insert({9.80665, "g on earth m/sec^2"}); |
| mSizeKeyValuePairs.insert({sizeof(int64_t), "size of int64_t"}); |
| mSizeKeyValuePairs.insert({sizeof(wchar_t), "size of wide char"}); |
| mSizeKeyValuePairs.insert({sizeof(intptr_t), "size of pointer variable"}); |
| mSizeKeyValuePairs.insert({sizeof *this, "size of class NativeMediaFormatUnitTest"}); |
| mStringKeyValuePairs.insert( |
| {"Discovered radium and polonium, and made huge contribution to finding treatments " |
| "for cancer", "Marie Curie"}); |
| mStringKeyValuePairs.insert({"Sun rises in the east has zero entropy", "Shannon"}); |
| mWindowKeyValuePairs.insert({new Rect{12, 15, 12, 21}, "trapezoid"}); |
| mWindowKeyValuePairs.insert({new Rect{12, 12, 12, 12}, "rhombus"}); |
| mWindowKeyValuePairs.insert({new Rect{12, 15, 12, 15}, "rectangle"}); |
| mWindowKeyValuePairs.insert({new Rect{12, 15, 18, 21}, "quadrilateral"}); |
| mBufferKeyValuePairs.insert({new Buffer(), "empty buffer"}); |
| size_t sz = strlen(story) + 1; |
| auto* quote = new Buffer{new char[sz], sz}; |
| memcpy(quote->buffer, story, sz); |
| mBufferKeyValuePairs.insert({quote, "one line story"}); |
| sz = strlen(dragon) + 1; |
| auto* chess = new Buffer(new char[sz], sz); |
| memcpy(chess->buffer, dragon, sz); |
| mBufferKeyValuePairs.insert({chess, "sicilian dragon"}); |
| } |
| |
| NativeMediaFormatUnitTest::~NativeMediaFormatUnitTest() { |
| for (auto it : mWindowKeyValuePairs) { |
| delete it.first; |
| } |
| for (auto it : mBufferKeyValuePairs) { |
| delete[] it.first->buffer; |
| delete it.first; |
| } |
| } |
| |
| bool NativeMediaFormatUnitTest::validateFormatInt32(AMediaFormat* fmt, int offset, bool isClear) { |
| bool status = true; |
| int32_t val; |
| const char* toString = AMediaFormat_toString(fmt); |
| for (auto it : mInt32KeyValuePairs) { |
| bool result = AMediaFormat_getInt32(fmt, it.second, &val); |
| if (isClear) { |
| if (result) { |
| ALOGE("MediaFormat is not expected to contain Key %s", it.second); |
| status &= false; |
| } |
| } else { |
| if (!result) { |
| ALOGE("MediaFormat doesn't contain key %s", it.second); |
| status &= false; |
| } else if (val != it.first + offset) { |
| ALOGE("MediaFormat Value for Key %s is not %d but %d", it.second, it.first + offset, |
| val); |
| status &= false; |
| } |
| if (strstr(toString, it.second) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, it.second); |
| status &= false; |
| } |
| if (strstr(toString, std::to_string(it.first + offset).c_str()) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, |
| std::to_string(it.first + offset).c_str()); |
| status &= false; |
| } |
| } |
| } |
| if (AMediaFormat_getInt32(fmt, "hello world", &val)) { |
| ALOGE("MediaFormat has value for key 'hello world' "); |
| status &= false; |
| } |
| return status; |
| } |
| |
| bool NativeMediaFormatUnitTest::validateFormatInt64(AMediaFormat* fmt, int offset, bool isClear) { |
| bool status = true; |
| int64_t val; |
| const char* toString = AMediaFormat_toString(fmt); |
| for (auto it : mInt64KeyValuePairs) { |
| bool result = AMediaFormat_getInt64(fmt, it.second, &val); |
| if (isClear) { |
| if (result) { |
| ALOGE("MediaFormat is not expected to contain Key %s", it.second); |
| status &= false; |
| } |
| } else { |
| if (!result) { |
| ALOGE("MediaFormat doesn't contain key %s", it.second); |
| status &= false; |
| } else if (val != it.first + offset) { |
| ALOGE("MediaFormat Value for Key %s is not %" PRId64 "but %" PRId64, it.second, |
| it.first + offset, val); |
| status &= false; |
| } |
| if (strstr(toString, it.second) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, it.second); |
| status &= false; |
| } |
| if (strstr(toString, std::to_string(it.first + offset).c_str()) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, |
| std::to_string(it.first + offset).c_str()); |
| status &= false; |
| } |
| } |
| } |
| if (AMediaFormat_getInt64(fmt, "hello world", &val)) { |
| ALOGE("MediaFormat has value for key 'hello world' "); |
| status &= false; |
| } |
| return status; |
| } |
| |
| bool NativeMediaFormatUnitTest::validateFormatFloat(AMediaFormat* fmt, float offset, bool isClear) { |
| bool status = true; |
| float val; |
| const char* toString = AMediaFormat_toString(fmt); |
| for (auto it : mFloatKeyValuePairs) { |
| bool result = AMediaFormat_getFloat(fmt, it.second, &val); |
| if (isClear) { |
| if (result) { |
| ALOGE("MediaFormat is not expected to contain Key %s", it.second); |
| status &= false; |
| } |
| } else { |
| if (!result) { |
| ALOGE("MediaFormat doesn't contain key %s", it.second); |
| status &= false; |
| } else if (val != it.first + offset) { |
| ALOGE("MediaFormat Value for Key %s is not %f but %f", it.second, it.first + offset, |
| val); |
| status &= false; |
| } |
| if (strstr(toString, it.second) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, it.second); |
| status &= false; |
| } |
| if (strstr(toString, std::to_string(it.first + offset).c_str()) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, |
| std::to_string(it.first + offset).c_str()); |
| status &= false; |
| } |
| } |
| } |
| if (AMediaFormat_getFloat(fmt, "hello world", &val)) { |
| ALOGE("MediaFormat has value for key 'hello world' "); |
| status &= false; |
| } |
| return status; |
| } |
| |
| bool NativeMediaFormatUnitTest::validateFormatDouble(AMediaFormat* fmt, double offset, |
| bool isClear) { |
| bool status = true; |
| double val; |
| const char* toString = AMediaFormat_toString(fmt); |
| for (auto it : mDoubleKeyValuePairs) { |
| bool result = AMediaFormat_getDouble(fmt, it.second, &val); |
| if (isClear) { |
| if (result) { |
| ALOGE("MediaFormat is not expected to contain Key %s", it.second); |
| status &= false; |
| } |
| } else { |
| if (!result) { |
| ALOGE("MediaFormat doesn't contain key %s", it.second); |
| status &= false; |
| } else if (val != it.first + offset) { |
| ALOGE("MediaFormat Value for Key %s is not %f but %f", it.second, it.first + offset, |
| val); |
| status &= false; |
| } |
| if (strstr(toString, it.second) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, it.second); |
| status &= false; |
| } |
| if (strstr(toString, std::to_string(it.first + offset).c_str()) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, |
| std::to_string(it.first + offset).c_str()); |
| status &= false; |
| } |
| } |
| } |
| if (AMediaFormat_getDouble(fmt, "hello world", &val)) { |
| ALOGE("MediaFormat has value for key 'hello world' "); |
| status &= false; |
| } |
| return status; |
| } |
| |
| bool NativeMediaFormatUnitTest::validateFormatSize(AMediaFormat* fmt, size_t offset, bool isClear) { |
| bool status = true; |
| size_t val; |
| const char* toString = AMediaFormat_toString(fmt); |
| for (auto it : mSizeKeyValuePairs) { |
| bool result = AMediaFormat_getSize(fmt, it.second, &val); |
| if (isClear) { |
| if (result) { |
| ALOGE("MediaFormat is not expected to contain Key %s", it.second); |
| status &= false; |
| } |
| } else { |
| if (!result) { |
| ALOGE("MediaFormat doesn't contain key %s", it.second); |
| status &= false; |
| } else if (val != it.first + offset) { |
| ALOGE("MediaFormat Value for Key %s is not %zu but %zu", it.second, |
| it.first + offset, val); |
| status &= false; |
| } |
| if (strstr(toString, it.second) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, it.second); |
| status &= false; |
| } |
| if (strstr(toString, std::to_string(it.first + offset).c_str()) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, |
| std::to_string(it.first + offset).c_str()); |
| status &= false; |
| } |
| } |
| } |
| if (AMediaFormat_getSize(fmt, "hello world", &val)) { |
| ALOGE("MediaFormat has value for key 'hello world' "); |
| status &= false; |
| } |
| return status; |
| } |
| |
| bool NativeMediaFormatUnitTest::validateFormatString(AMediaFormat* fmt, int offset, bool isClear) { |
| bool status = true; |
| const char* val; |
| const char* toString = AMediaFormat_toString(fmt); |
| for (auto it : mStringKeyValuePairs) { |
| bool result = AMediaFormat_getString(fmt, it.second, &val); |
| if (isClear) { |
| if (result) { |
| ALOGE("MediaFormat is not expected to contain Key %s", it.second); |
| status &= false; |
| } |
| } else { |
| std::string s = it.first + std::to_string(offset); |
| if (!result) { |
| ALOGE("MediaFormat doesn't contain key %s", it.second); |
| status &= false; |
| } else if (s != val) { |
| ALOGE("MediaFormat Value for Key %s is not %s but %s", it.second, s.c_str(), val); |
| status &= false; |
| } |
| if (strstr(toString, it.second) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, it.second); |
| status &= false; |
| } |
| if (strstr(toString, s.c_str()) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, s.c_str()); |
| status &= false; |
| } |
| } |
| } |
| if (AMediaFormat_getString(fmt, "hello world", &val)) { |
| ALOGE("MediaFormat has value for key 'hello world' "); |
| status &= false; |
| } |
| return status; |
| } |
| |
| bool NativeMediaFormatUnitTest::validateFormatRect(AMediaFormat* fmt, int offset, bool isClear) { |
| bool status = true; |
| int left, top, right, bottom; |
| const char* toString = AMediaFormat_toString(fmt); |
| for (auto it : mWindowKeyValuePairs) { |
| bool result = AMediaFormat_getRect(fmt, it.second, &left, &top, &right, &bottom); |
| if (isClear) { |
| if (result) { |
| ALOGE("MediaFormat is not expected to contain Key %s", it.second); |
| status &= false; |
| } |
| } else { |
| if (!result) { |
| ALOGE("MediaFormat doesn't contain key %s", it.second); |
| status &= false; |
| } else if (left != it.first->left + offset || top != it.first->top + offset || |
| right != it.first->right + offset || bottom != it.first->bottom + offset) { |
| ALOGE("MediaFormat Value for Key %s is not (%d, %d, %d, %d)) but (%d, %d, %d, %d)", |
| it.second, it.first->left, it.first->top, it.first->right, it.first->bottom, |
| left, top, right, bottom); |
| status &= false; |
| } |
| if (strstr(toString, it.second) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, it.second); |
| status &= false; |
| } |
| if (strstr(toString, std::to_string(it.first->left + offset).c_str()) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, |
| std::to_string(it.first->left + offset).c_str()); |
| status &= false; |
| } |
| if (strstr(toString, std::to_string(it.first->top + offset).c_str()) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, |
| std::to_string(it.first->top + offset).c_str()); |
| status &= false; |
| } |
| if (strstr(toString, std::to_string(it.first->right + offset).c_str()) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, |
| std::to_string(it.first->right + offset).c_str()); |
| status &= false; |
| } |
| if (strstr(toString, std::to_string(it.first->bottom + offset).c_str()) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, |
| std::to_string(it.first->bottom + offset).c_str()); |
| status &= false; |
| } |
| } |
| } |
| if (AMediaFormat_getRect(fmt, "hello world", &left, &top, &right, &bottom)) { |
| ALOGE("MediaFormat has value for key 'hello world' "); |
| status &= false; |
| } |
| return status; |
| } |
| |
| bool NativeMediaFormatUnitTest::validateFormatBuffer(AMediaFormat* fmt, int offset, bool isClear) { |
| bool status = true; |
| void* data; |
| size_t size; |
| const char* toString = AMediaFormat_toString(fmt); |
| for (auto it : mBufferKeyValuePairs) { |
| bool result = AMediaFormat_getBuffer(fmt, it.second, &data, &size); |
| if (isClear) { |
| if (result) { |
| ALOGE("MediaFormat is not expected to contain Key %s", it.second); |
| status &= false; |
| } |
| } else { |
| if (!result) { |
| ALOGE("MediaFormat doesn't contain key %s", it.second); |
| status &= false; |
| } else if (size != (offset == 0 ? it.first->size : it.first->size / 2)) { |
| ALOGE("MediaFormat Value for Key %s is not %zu but %zu", it.second, |
| (offset == 0 ? it.first->size : it.first->size / 2), size); |
| status &= false; |
| } else { |
| if (it.first->buffer != nullptr && |
| memcmp(data, it.first->buffer + it.first->size - size, size) != 0) { |
| ALOGE("MediaFormat Value for Key %s is not %s but %s {%zu}", it.second, |
| it.first->buffer + it.first->size - size, (char*)data, size); |
| status &= false; |
| } |
| } |
| if (strstr(toString, it.second) == nullptr) { |
| ALOGE("AMediaFormat_toString() of fmt %s doesn't contains %s", toString, it.second); |
| status &= false; |
| } |
| } |
| } |
| if (AMediaFormat_getBuffer(fmt, "hello world", &data, &size)) { |
| ALOGE("MediaFormat has value for key 'hello world' "); |
| status &= false; |
| } |
| return status; |
| } |
| |
| bool NativeMediaFormatUnitTest::validateFormat(AMediaFormat* fmt, int offset, bool isClear) { |
| bool status = validateFormatInt32(fmt, offset, isClear); |
| status &= validateFormatInt64(fmt, offset, isClear); |
| status &= validateFormatFloat(fmt, offset, isClear); |
| status &= validateFormatDouble(fmt, offset, isClear); |
| status &= validateFormatSize(fmt, offset, isClear); |
| status &= validateFormatString(fmt, offset, isClear); |
| status &= validateFormatRect(fmt, offset, isClear); |
| status &= validateFormatBuffer(fmt, offset, isClear); |
| return status; |
| } |
| |
| void NativeMediaFormatUnitTest::configureFormatInt32(AMediaFormat* fmt, int offset) { |
| for (auto it : mInt32KeyValuePairs) { |
| AMediaFormat_setInt32(fmt, it.second, it.first + offset); |
| } |
| } |
| |
| void NativeMediaFormatUnitTest::configureFormatInt64(AMediaFormat* fmt, int offset) { |
| for (auto it : mInt64KeyValuePairs) { |
| AMediaFormat_setInt64(fmt, it.second, it.first + offset); |
| } |
| } |
| |
| void NativeMediaFormatUnitTest::configureFormatFloat(AMediaFormat* fmt, float offset) { |
| for (auto it : mFloatKeyValuePairs) { |
| AMediaFormat_setFloat(fmt, it.second, it.first + offset); |
| } |
| } |
| |
| void NativeMediaFormatUnitTest::configureFormatDouble(AMediaFormat* fmt, double offset) { |
| for (auto it : mDoubleKeyValuePairs) { |
| AMediaFormat_setDouble(fmt, it.second, it.first + offset); |
| } |
| } |
| |
| void NativeMediaFormatUnitTest::configureFormatSize(AMediaFormat* fmt, size_t offset) { |
| for (auto it : mSizeKeyValuePairs) { |
| AMediaFormat_setSize(fmt, it.second, it.first + offset); |
| } |
| } |
| |
| void NativeMediaFormatUnitTest::configureFormatString(AMediaFormat* fmt, int offset) { |
| for (auto it : mStringKeyValuePairs) { |
| std::string s1 = it.first + std::to_string(offset); |
| AMediaFormat_setString(fmt, it.second, s1.c_str()); |
| } |
| } |
| |
| void NativeMediaFormatUnitTest::configureFormatRect(AMediaFormat* fmt, int offset) { |
| for (auto it : mWindowKeyValuePairs) { |
| AMediaFormat_setRect(fmt, it.second, it.first->left + offset, it.first->top + offset, |
| it.first->right + offset, it.first->bottom + offset); |
| } |
| } |
| |
| void NativeMediaFormatUnitTest::configureFormatBuffer(AMediaFormat* fmt, int offset) { |
| for (auto it : mBufferKeyValuePairs) { |
| int sz = offset == 0 ? it.first->size : it.first->size / 2; |
| AMediaFormat_setBuffer(fmt, it.second, it.first->buffer + it.first->size - sz, sz); |
| } |
| } |
| |
| void NativeMediaFormatUnitTest::configureFormat(AMediaFormat* fmt, int offset) { |
| configureFormatInt32(fmt, offset); |
| configureFormatInt64(fmt, offset); |
| configureFormatFloat(fmt, offset); |
| configureFormatDouble(fmt, offset); |
| configureFormatSize(fmt, offset); |
| configureFormatString(fmt, offset); |
| configureFormatRect(fmt, offset); |
| configureFormatBuffer(fmt, offset); |
| } |
| |
| // 1. configure format with default values and validate the same |
| // 2. copy configured format to an empty format and validate the copied format |
| // 3. overwrite copied format with default + offset values and validate the updated format |
| // 4. overwrite updated format with default values using AMediaFormat_copy API and validate the same |
| // 5. clear mediaformat and validate if keys are not present |
| static bool testMediaFormatAllNative() { |
| auto* nmf = new NativeMediaFormatUnitTest(); |
| AMediaFormat* fmtOrig = AMediaFormat_new(); |
| AMediaFormat* fmtDup = AMediaFormat_new(); |
| const int offset = 123; |
| |
| nmf->configureFormat(fmtOrig); |
| bool status = nmf->validateFormat(fmtOrig); |
| |
| AMediaFormat_copy(fmtDup, fmtOrig); |
| status &= nmf->validateFormat(fmtDup); |
| |
| nmf->configureFormat(fmtDup, offset); |
| status &= nmf->validateFormat(fmtDup, offset); |
| |
| AMediaFormat_copy(fmtDup, fmtOrig); |
| status &= nmf->validateFormat(fmtDup); |
| |
| AMediaFormat_clear(fmtDup); |
| status &= nmf->validateFormat(fmtDup, offset, true); |
| |
| AMediaFormat_delete(fmtOrig); |
| AMediaFormat_delete(fmtDup); |
| delete nmf; |
| |
| return status; |
| } |
| |
| // 1. configure format with default values and validate the same |
| // 2. copy configured format to an empty format and validate the copied format |
| // 3. overwrite copied format with default + offset values and validate the updated format |
| // 4. overwrite updated format with default values using AMediaFormat_copy API and validate the same |
| #define testMediaFormatfuncNative(func) \ |
| static bool testMediaFormat##func##Native() { \ |
| auto* nmf = new NativeMediaFormatUnitTest(); \ |
| AMediaFormat* fmtOrig = AMediaFormat_new(); \ |
| AMediaFormat* fmtDup = AMediaFormat_new(); \ |
| const int offset = 12345; \ |
| \ |
| nmf->configureFormat##func(fmtOrig); \ |
| bool status = nmf->validateFormat##func(fmtOrig); \ |
| \ |
| AMediaFormat_copy(fmtDup, fmtOrig); \ |
| status &= nmf->validateFormat##func(fmtDup); \ |
| \ |
| nmf->configureFormat##func(fmtDup, offset); \ |
| status &= nmf->validateFormat##func(fmtDup, offset); \ |
| \ |
| AMediaFormat_copy(fmtDup, fmtOrig); \ |
| status &= nmf->validateFormat##func(fmtDup); \ |
| \ |
| AMediaFormat_clear(fmtDup); \ |
| status &= nmf->validateFormat##func(fmtDup, offset, true); \ |
| AMediaFormat_delete(fmtOrig); \ |
| AMediaFormat_delete(fmtDup); \ |
| delete nmf; \ |
| return status; \ |
| } |
| |
| testMediaFormatfuncNative(Int32) |
| |
| testMediaFormatfuncNative(Int64) |
| |
| testMediaFormatfuncNative(Float) |
| |
| testMediaFormatfuncNative(Double) |
| |
| testMediaFormatfuncNative(Size) |
| |
| testMediaFormatfuncNative(String) |
| |
| testMediaFormatfuncNative(Rect) |
| |
| testMediaFormatfuncNative(Buffer) |
| |
| #define nativeTestMediaFormatfunc(func) \ |
| static jboolean nativeTestMediaFormat##func(JNIEnv*, jobject) { \ |
| return static_cast<jboolean>(testMediaFormat##func##Native()); \ |
| } |
| |
| nativeTestMediaFormatfunc(Int32) |
| |
| nativeTestMediaFormatfunc(Int64) |
| |
| nativeTestMediaFormatfunc(Float) |
| |
| nativeTestMediaFormatfunc(Double) |
| |
| nativeTestMediaFormatfunc(Size) |
| |
| nativeTestMediaFormatfunc(String) |
| |
| nativeTestMediaFormatfunc(Rect) |
| |
| nativeTestMediaFormatfunc(Buffer) |
| |
| nativeTestMediaFormatfunc(All) |
| |
| int registerAndroidMediaV2CtsMediaFormatUnitTest(JNIEnv* env) { |
| const JNINativeMethod methodTable[] = { |
| {"nativeTestMediaFormatInt32", "()Z", (void*)nativeTestMediaFormatInt32}, |
| {"nativeTestMediaFormatInt64", "()Z", (void*)nativeTestMediaFormatInt64}, |
| {"nativeTestMediaFormatFloat", "()Z", (void*)nativeTestMediaFormatFloat}, |
| {"nativeTestMediaFormatDouble", "()Z", (void*)nativeTestMediaFormatDouble}, |
| {"nativeTestMediaFormatSize", "()Z", (void*)nativeTestMediaFormatSize}, |
| {"nativeTestMediaFormatString", "()Z", (void*)nativeTestMediaFormatString}, |
| {"nativeTestMediaFormatRect", "()Z", (void*)nativeTestMediaFormatRect}, |
| {"nativeTestMediaFormatBuffer", "()Z", (void*)nativeTestMediaFormatBuffer}, |
| {"nativeTestMediaFormatAll", "()Z", (void*)nativeTestMediaFormatAll}, |
| }; |
| jclass c = env->FindClass("android/mediav2/cts/MediaFormatUnitTest"); |
| return env->RegisterNatives(c, methodTable, sizeof(methodTable) / sizeof(JNINativeMethod)); |
| } |
| |
| extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void*) { |
| JNIEnv* env; |
| if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) return JNI_ERR; |
| if (registerAndroidMediaV2CtsMediaFormatUnitTest(env) != JNI_OK) return JNI_ERR; |
| return JNI_VERSION_1_6; |
| } |
