| /* |
| * Copyright 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. |
| */ |
| |
| #ifndef _ANDROID_MEDIA_TV_FILTER_CLIENT_H_ |
| #define _ANDROID_MEDIA_TV_FILTER_CLIENT_H_ |
| |
| #include <aidl/android/hardware/tv/tuner/DemuxFilterType.h> |
| #include <aidl/android/media/tv/tuner/BnTunerFilterCallback.h> |
| #include <aidl/android/media/tv/tuner/ITunerFilter.h> |
| #include <fmq/AidlMessageQueue.h> |
| #include <utils/Mutex.h> |
| |
| #include "ClientHelper.h" |
| #include "FilterClientCallback.h" |
| |
| using Status = ::ndk::ScopedAStatus; |
| using ::aidl::android::hardware::common::fmq::MQDescriptor; |
| using ::aidl::android::hardware::common::fmq::SynchronizedReadWrite; |
| using ::aidl::android::hardware::tv::tuner::AvStreamType; |
| using ::aidl::android::hardware::tv::tuner::DemuxFilterEvent; |
| using ::aidl::android::hardware::tv::tuner::DemuxFilterSettings; |
| using ::aidl::android::hardware::tv::tuner::DemuxFilterStatus; |
| using ::aidl::android::hardware::tv::tuner::DemuxFilterType; |
| using ::aidl::android::hardware::tv::tuner::FilterDelayHint; |
| using ::aidl::android::media::tv::tuner::BnTunerFilterCallback; |
| using ::aidl::android::media::tv::tuner::ITunerFilter; |
| using ::android::hardware::EventFlag; |
| using ::android::Mutex; |
| |
| using namespace std; |
| |
| namespace android { |
| |
| using AidlMQ = AidlMessageQueue<int8_t, SynchronizedReadWrite>; |
| using AidlMQDesc = MQDescriptor<int8_t, SynchronizedReadWrite>; |
| |
| struct SharedHandleInfo { |
| native_handle_t* sharedHandle; |
| uint64_t size; |
| }; |
| |
| class TunerFilterCallback : public BnTunerFilterCallback { |
| public: |
| TunerFilterCallback(sp<FilterClientCallback> filterClientCallback); |
| Status onFilterStatus(DemuxFilterStatus status); |
| Status onFilterEvent(const vector<DemuxFilterEvent>& filterEvents); |
| |
| private: |
| sp<FilterClientCallback> mFilterClientCallback; |
| }; |
| |
| struct FilterClient : public RefBase { |
| |
| public: |
| FilterClient(DemuxFilterType type, shared_ptr<ITunerFilter> tunerFilter); |
| ~FilterClient(); |
| |
| /** |
| * Read size of data from filter FMQ into buffer. |
| * |
| * @return the actual reading size. -1 if failed to read. |
| */ |
| int64_t read(int8_t* buffer, int64_t size); |
| |
| /** |
| * Get the a/v shared memory handle information |
| */ |
| SharedHandleInfo getAvSharedHandleInfo(); |
| |
| /** |
| * Configure the filter. |
| */ |
| Result configure(DemuxFilterSettings configure); |
| |
| /** |
| * Configure the monitor event of the Filter. |
| */ |
| Result configureMonitorEvent(int32_t monitorEventType); |
| |
| /** |
| * Configure the context id of the IP Filter. |
| */ |
| Result configureIpFilterContextId(int32_t cid); |
| |
| /** |
| * Configure the stream type of the media Filter. |
| */ |
| Result configureAvStreamType(AvStreamType avStreamType); |
| |
| /** |
| * Start the filter. |
| */ |
| Result start(); |
| |
| /** |
| * Stop the filter. |
| */ |
| Result stop(); |
| |
| /** |
| * Flush the filter. |
| */ |
| Result flush(); |
| |
| /** |
| * Get the 32-bit filter Id. |
| */ |
| Result getId(int32_t& id); |
| |
| /** |
| * Get the 64-bit filter Id. |
| */ |
| Result getId64Bit(int64_t& id); |
| |
| /** |
| * Release the handle reported by the HAL for AV memory. |
| */ |
| Result releaseAvHandle(native_handle_t* handle, uint64_t avDataId); |
| |
| /** |
| * Set the filter's data source. |
| */ |
| Result setDataSource(sp<FilterClient> filterClient); |
| |
| /** |
| * Get the Aidl filter to build up filter linkage. |
| */ |
| shared_ptr<ITunerFilter> getAidlFilter() { return mTunerFilter; } |
| |
| /** |
| * Close a new interface of ITunerFilter. |
| */ |
| Result close(); |
| |
| /** |
| * Accquire a new SharedFiler token. |
| */ |
| string acquireSharedFilterToken(); |
| |
| /** |
| * Release SharedFiler token. |
| */ |
| Result freeSharedFilterToken(const string& filterToken); |
| |
| /** |
| * Set a filter delay hint. |
| */ |
| Result setDelayHint(const FilterDelayHint& hint); |
| |
| private: |
| Result getFilterMq(); |
| int64_t copyData(int8_t* buffer, int64_t size); |
| void checkIsMediaFilter(DemuxFilterType type); |
| void checkIsPassthroughFilter(DemuxFilterSettings configure); |
| void handleAvShareMemory(); |
| void closeAvSharedMemory(); |
| |
| /** |
| * An AIDL Tuner Filter Singleton assigned at the first time when the Tuner Client |
| * opens a filter. Default null when Tuner Service does not exist. |
| */ |
| shared_ptr<ITunerFilter> mTunerFilter; |
| |
| AidlMQ* mFilterMQ = nullptr; |
| EventFlag* mFilterMQEventFlag = nullptr; |
| |
| native_handle_t* mAvSharedHandle; |
| uint64_t mAvSharedMemSize; |
| bool mIsMediaFilter; |
| bool mIsPassthroughFilter; |
| Mutex mLock; |
| }; |
| } // namespace android |
| |
| #endif // _ANDROID_MEDIA_TV_FILTER_CLIENT_H_ |