| /* |
| * Copyright (C) 2020 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 "Mpeg2tsUnitTest" |
| |
| #include <utils/Log.h> |
| |
| #include <stdint.h> |
| #include <sys/stat.h> |
| |
| #include <datasource/FileSource.h> |
| #include <media/stagefright/MediaDefs.h> |
| #include <media/stagefright/MetaDataBase.h> |
| #include <media/stagefright/foundation/AUtils.h> |
| |
| #include "mpeg2ts/ATSParser.h" |
| #include "mpeg2ts/AnotherPacketSource.h" |
| |
| #include "Mpeg2tsUnitTestEnvironment.h" |
| |
| constexpr size_t kTSPacketSize = 188; |
| constexpr uint16_t kPIDMask = 0x1FFF; |
| // Max value of PID which is also used for Null packets |
| constexpr uint16_t kPIDMaxValue = 8191; |
| constexpr uint8_t kTSSyncByte = 0x47; |
| constexpr uint8_t kVideoPresent = 0x01; |
| constexpr uint8_t kAudioPresent = 0x02; |
| constexpr uint8_t kMetaDataPresent = 0x04; |
| |
| static Mpeg2tsUnitTestEnvironment *gEnv = nullptr; |
| |
| using namespace android; |
| |
| class Mpeg2tsUnitTest |
| : public ::testing ::TestWithParam< |
| tuple</*fileName*/ string, /*sourceType*/ char, /*numSource*/ uint16_t>> { |
| public: |
| Mpeg2tsUnitTest() |
| : mInputBuffer(nullptr), mSource(nullptr), mFpInput(nullptr), mParser(nullptr) {} |
| |
| ~Mpeg2tsUnitTest() { |
| if (mInputBuffer) free(mInputBuffer); |
| if (mFpInput) fclose(mFpInput); |
| mSource.clear(); |
| } |
| |
| void SetUp() override { |
| mOffset = 0; |
| mNumDataSource = 0; |
| tuple<string, char, uint16_t> params = GetParam(); |
| char sourceType = get<1>(params); |
| /* mSourceType = 0b x x x x x M A V |
| / | \ |
| metaData audio video */ |
| mMediaType = (sourceType & 0x07); |
| mNumDataSource = get<2>(params); |
| string inputFile = gEnv->getRes() + get<0>(params); |
| mFpInput = fopen(inputFile.c_str(), "rb"); |
| ASSERT_NE(mFpInput, nullptr) << "Failed to open file: " << inputFile; |
| |
| struct stat buf; |
| int8_t err = stat(inputFile.c_str(), &buf); |
| ASSERT_EQ(err, 0) << "Failed to get information for file: " << inputFile; |
| |
| long fileSize = buf.st_size; |
| mTotalPackets = fileSize / kTSPacketSize; |
| int32_t fd = fileno(mFpInput); |
| ASSERT_GE(fd, 0) << "Failed to get the integer file descriptor"; |
| |
| mSource = new FileSource(dup(fd), 0, buf.st_size); |
| ASSERT_NE(mSource, nullptr) << "Failed to get the data source!"; |
| |
| mParser = new ATSParser(); |
| ASSERT_NE(mParser, nullptr) << "Unable to create ATS parser!"; |
| mInputBuffer = (uint8_t *)malloc(kTSPacketSize); |
| ASSERT_NE(mInputBuffer, nullptr) << "Failed to allocate memory for TS packet!"; |
| } |
| |
| uint64_t mOffset; |
| uint64_t mTotalPackets; |
| uint16_t mNumDataSource; |
| |
| int8_t mMediaType; |
| |
| uint8_t *mInputBuffer; |
| string mInputFile; |
| sp<DataSource> mSource; |
| FILE *mFpInput; |
| ATSParser *mParser; |
| }; |
| |
| TEST_P(Mpeg2tsUnitTest, MediaInfoTest) { |
| bool videoFound = false; |
| bool audioFound = false; |
| bool metaDataFound = false; |
| bool syncPointPresent = false; |
| |
| int16_t totalDataSource = 0; |
| int32_t val32 = 0; |
| uint8_t numDataSource = 0; |
| uint8_t packet[kTSPacketSize]; |
| ssize_t numBytesRead = -1; |
| |
| ATSParser::SyncEvent event(mOffset); |
| static const ATSParser::SourceType mediaType[] = {ATSParser::VIDEO, ATSParser::AUDIO, |
| ATSParser::META, ATSParser::NUM_SOURCE_TYPES}; |
| const uint32_t nMediaTypes = sizeof(mediaType) / sizeof(mediaType[0]); |
| |
| while ((numBytesRead = mSource->readAt(mOffset, packet, kTSPacketSize)) == kTSPacketSize) { |
| ASSERT_TRUE(packet[0] == kTSSyncByte) << "Sync byte error!"; |
| |
| // pid is 13 bits |
| uint16_t pid = (packet[1] + (packet[2] << 8)) & kPIDMask; |
| ASSERT_TRUE(pid <= kPIDMaxValue) << "Invalid PID: " << pid; |
| |
| status_t err = mParser->feedTSPacket(packet, kTSPacketSize, &event); |
| ASSERT_EQ(err, (status_t)OK) << "Unable to feed TS packet!"; |
| |
| mOffset += numBytesRead; |
| for (int i = 0; i < nMediaTypes; i++) { |
| if (mParser->hasSource(mediaType[i])) { |
| switch (mediaType[i]) { |
| case ATSParser::VIDEO: |
| videoFound = true; |
| break; |
| case ATSParser::AUDIO: |
| audioFound = true; |
| break; |
| case ATSParser::META: |
| metaDataFound = true; |
| break; |
| case ATSParser::NUM_SOURCE_TYPES: |
| numDataSource = 3; |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| if (videoFound && audioFound && metaDataFound && (numDataSource == 3)) break; |
| } |
| |
| for (int i = 0; i < nMediaTypes; i++) { |
| ATSParser::SourceType currentMediaType = mediaType[i]; |
| if (mParser->hasSource(currentMediaType)) { |
| if (event.hasReturnedData()) { |
| syncPointPresent = true; |
| sp<AnotherPacketSource> syncPacketSource = event.getMediaSource(); |
| ASSERT_NE(syncPacketSource, nullptr) |
| << "Cannot get sync source for media type: " << currentMediaType; |
| |
| status_t err = syncPacketSource->start(); |
| ASSERT_EQ(err, (status_t)OK) << "Error returned while starting!"; |
| |
| sp<MetaData> format = syncPacketSource->getFormat(); |
| ASSERT_NE(format, nullptr) << "Unable to get the format of the source packet!"; |
| |
| MediaBufferBase *buf; |
| syncPacketSource->read(&buf, nullptr); |
| ASSERT_NE(buf, nullptr) << "Failed to read sync packet source data"; |
| |
| MetaDataBase &inMeta = buf->meta_data(); |
| bool status = inMeta.findInt32(kKeyIsSyncFrame, &val32); |
| ASSERT_EQ(status, true) << "Sync frame key is not set"; |
| |
| status = inMeta.findInt32(kKeyCryptoMode, &val32); |
| ASSERT_EQ(status, false) << "Invalid packet, found scrambled packets!"; |
| |
| err = syncPacketSource->stop(); |
| ASSERT_EQ(err, (status_t)OK) << "Error returned while stopping!"; |
| } |
| sp<AnotherPacketSource> packetSource = mParser->getSource(currentMediaType); |
| ASSERT_NE(packetSource, nullptr) |
| << "Cannot get source for media type: " << currentMediaType; |
| |
| status_t err = packetSource->start(); |
| ASSERT_EQ(err, (status_t)OK) << "Error returned while starting!"; |
| sp<MetaData> format = packetSource->getFormat(); |
| ASSERT_NE(format, nullptr) << "Unable to get the format of the packet!"; |
| |
| err = packetSource->stop(); |
| ASSERT_EQ(err, (status_t)OK) << "Error returned while stopping!"; |
| } |
| } |
| |
| ASSERT_EQ(videoFound, bool(mMediaType & kVideoPresent)) << "No Video packets found!"; |
| ASSERT_EQ(audioFound, bool(mMediaType & kAudioPresent)) << "No Audio packets found!"; |
| ASSERT_EQ(metaDataFound, bool(mMediaType & kMetaDataPresent)) << "No meta data found!"; |
| |
| if (videoFound || audioFound) { |
| ASSERT_TRUE(syncPointPresent) << "No sync points found for audio/video"; |
| } |
| |
| if (videoFound) totalDataSource += 1; |
| if (audioFound) totalDataSource += 1; |
| if (metaDataFound) totalDataSource += 1; |
| |
| ASSERT_TRUE(totalDataSource == mNumDataSource) |
| << "Expected " << mNumDataSource << " data sources, found " << totalDataSource; |
| if (numDataSource == 3) { |
| ASSERT_EQ(numDataSource, mNumDataSource) |
| << "Expected " << mNumDataSource << " data sources, found " << totalDataSource; |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| infoTest, Mpeg2tsUnitTest, |
| ::testing::Values(make_tuple("crowd_1920x1080_25fps_6700kbps_h264.ts", 0x01, 1), |
| make_tuple("segment000001.ts", 0x03, 2), |
| make_tuple("bbb_44100hz_2ch_128kbps_mp3_5mins.ts", 0x02, 1))); |
| |
| int32_t main(int argc, char **argv) { |
| gEnv = new Mpeg2tsUnitTestEnvironment(); |
| ::testing::AddGlobalTestEnvironment(gEnv); |
| ::testing::InitGoogleTest(&argc, argv); |
| uint8_t status = gEnv->initFromOptions(argc, argv); |
| if (status == 0) { |
| status = RUN_ALL_TESTS(); |
| ALOGV("Mpeg2tsUnit Test Result = %d\n", status); |
| } |
| return status; |
| } |
