1 /* 2 * Copyright 2021 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 #pragma once 18 19 #include <aidl/android/hardware/tv/tuner/BnFilterCallback.h> 20 #include <aidl/android/hardware/tv/tuner/IDemux.h> 21 #include <aidl/android/hardware/tv/tuner/IFilter.h> 22 #include <aidl/android/hardware/tv/tuner/ITuner.h> 23 #include <gtest/gtest.h> 24 #include <log/log.h> 25 #include <utils/Condition.h> 26 #include <utils/Mutex.h> 27 #include <future> 28 #include <map> 29 #include <unordered_map> 30 31 #include <fmq/AidlMessageQueue.h> 32 33 using ::aidl::android::hardware::common::fmq::MQDescriptor; 34 using ::aidl::android::hardware::common::fmq::SynchronizedReadWrite; 35 using ::android::AidlMessageQueue; 36 using ::android::Condition; 37 using ::android::Mutex; 38 using ::android::hardware::EventFlag; 39 40 using ::testing::AssertionResult; 41 42 using namespace aidl::android::hardware::tv::tuner; 43 using namespace std; 44 45 enum FilterEventType : uint8_t { 46 UNDEFINED, 47 SECTION, 48 MEDIA, 49 PES, 50 RECORD, 51 MMTPRECORD, 52 DOWNLOAD, 53 TEMI, 54 }; 55 56 using FilterMQ = AidlMessageQueue<int8_t, SynchronizedReadWrite>; 57 using MQDesc = MQDescriptor<int8_t, SynchronizedReadWrite>; 58 59 #define WAIT_TIMEOUT 3000000000 60 61 class FilterCallback : public BnFilterCallback { 62 public: 63 /** 64 * A FilterCallbackVerifier is used to test and verify filter callbacks. 65 * The function should return true when a callback has been handled by this 66 * filter verifier. This will cause the associated future to be unblocked. 67 * If the function returns false, we continue to wait for future callbacks 68 * (the future remains blocked). 69 */ 70 using FilterCallbackVerifier = std::function<bool(const std::vector<DemuxFilterEvent>&)>; 71 72 virtual ::ndk::ScopedAStatus onFilterEvent(const vector<DemuxFilterEvent>& events) override; 73 74 std::future<void> verifyFilterCallback(FilterCallbackVerifier&& verifier); 75 onFilterStatus(const DemuxFilterStatus)76 virtual ::ndk::ScopedAStatus onFilterStatus(const DemuxFilterStatus /*status*/) override { 77 return ::ndk::ScopedAStatus::ok(); 78 } 79 setFilterId(int32_t filterId)80 void setFilterId(int32_t filterId) { mFilterId = filterId; } setFilterInterface(std::shared_ptr<IFilter> filter)81 void setFilterInterface(std::shared_ptr<IFilter> filter) { mFilter = filter; } setSharedHandle(native_handle_t * sharedHandle)82 void setSharedHandle(native_handle_t* sharedHandle) { mAvSharedHandle = sharedHandle; } setMemSize(uint64_t size)83 void setMemSize(uint64_t size) { mAvSharedMemSize = size; } 84 85 void testFilterDataOutput(); 86 void testFilterScramblingEvent(); 87 void testFilterIpCidEvent(); 88 void testStartIdAfterReconfigure(); 89 90 void readFilterEventsData(const vector<DemuxFilterEvent>& events); 91 bool dumpAvData(const DemuxFilterMediaEvent& event); 92 93 private: 94 int32_t mFilterId; 95 std::shared_ptr<IFilter> mFilter; 96 97 std::vector<std::pair<FilterCallbackVerifier, std::promise<void>>> mFilterCallbackVerifiers; 98 native_handle_t* mAvSharedHandle = nullptr; 99 uint64_t mAvSharedMemSize = -1; 100 101 android::Mutex mMsgLock; 102 android::Mutex mFilterOutputLock; 103 android::Condition mMsgCondition; 104 105 int mPidFilterOutputCount = 0; 106 int mScramblingStatusEvent = 0; 107 int mIpCidEvent = 0; 108 bool mStartIdReceived = false; 109 }; 110 111 class FilterTests { 112 public: setService(std::shared_ptr<ITuner> tuner)113 void setService(std::shared_ptr<ITuner> tuner) { mService = tuner; } setDemux(std::shared_ptr<IDemux> demux)114 void setDemux(std::shared_ptr<IDemux> demux) { mDemux = demux; } getFilterById(int64_t filterId)115 std::shared_ptr<IFilter> getFilterById(int64_t filterId) { return mFilters[filterId]; } 116 getFilterCallbacks()117 map<int64_t, std::shared_ptr<FilterCallback>> getFilterCallbacks() { return mFilterCallbacks; } 118 119 AssertionResult openFilterInDemux(DemuxFilterType type, int32_t bufferSize); 120 AssertionResult getNewlyOpenedFilterId_64bit(int64_t& filterId); 121 AssertionResult getSharedAvMemoryHandle(int64_t filterId); 122 AssertionResult releaseShareAvHandle(int64_t filterId); 123 AssertionResult configFilter(DemuxFilterSettings setting, int64_t filterId); 124 AssertionResult configAvFilterStreamType(AvStreamType type, int64_t filterId); 125 AssertionResult configIpFilterCid(int32_t ipCid, int64_t filterId); 126 AssertionResult configureMonitorEvent(int64_t filterId, int32_t monitorEventTypes); 127 AssertionResult getFilterMQDescriptor(int64_t filterId, bool getMqDesc); 128 AssertionResult startFilter(int64_t filterId); 129 AssertionResult stopFilter(int64_t filterId); 130 AssertionResult closeFilter(int64_t filterId); 131 AssertionResult startIdTest(int64_t filterId); 132 133 AssertionResult openTimeFilterInDemux(); 134 AssertionResult setTimeStamp(int64_t timeStamp); 135 AssertionResult getTimeStamp(); 136 AssertionResult setFilterDataSource(int64_t sourceFilterId, int64_t sinkFilterId); 137 AssertionResult setFilterDataSourceToDemux(int64_t filterId); 138 AssertionResult clearTimeStamp(); 139 AssertionResult closeTimeFilter(); 140 141 protected: failure()142 static AssertionResult failure() { return ::testing::AssertionFailure(); } 143 success()144 static AssertionResult success() { return ::testing::AssertionSuccess(); } 145 146 std::shared_ptr<ITuner> mService; 147 std::shared_ptr<IFilter> mFilter; 148 std::shared_ptr<IDemux> mDemux; 149 std::shared_ptr<ITimeFilter> mTimeFilter; 150 map<int64_t, std::shared_ptr<IFilter>> mFilters; 151 map<int64_t, std::shared_ptr<FilterCallback>> mFilterCallbacks; 152 153 std::shared_ptr<FilterCallback> mFilterCallback; 154 MQDesc mFilterMQDescriptor; 155 vector<int64_t> mUsedFilterIds; 156 157 native_handle_t* mAvSharedHandle = nullptr; 158 int64_t mFilterId = -1; 159 int64_t mBeginTimeStamp; 160 }; 161