| /* |
| * Copyright 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_TAG "DvrClient" |
| |
| #include <android-base/logging.h> |
| #include <fmq/ConvertMQDescriptors.h> |
| #include <utils/Log.h> |
| |
| #include "ClientHelper.h" |
| #include "DvrClient.h" |
| |
| using ::android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits; |
| using ::android::hardware::tv::tuner::V1_0::Result; |
| |
| namespace android { |
| |
| /////////////// DvrClient /////////////////////// |
| |
| DvrClient::DvrClient(shared_ptr<ITunerDvr> tunerDvr) { |
| mTunerDvr = tunerDvr; |
| mFd = -1; |
| mDvrMQ = NULL; |
| mDvrMQEventFlag = NULL; |
| } |
| |
| DvrClient::~DvrClient() { |
| mTunerDvr = NULL; |
| mDvr = NULL; |
| mFd = -1; |
| mDvrMQ = NULL; |
| mDvrMQEventFlag = NULL; |
| } |
| |
| // TODO: remove after migration to Tuner Service is done. |
| void DvrClient::setHidlDvr(sp<IDvr> dvr) { |
| mDvr = dvr; |
| } |
| |
| void DvrClient::setFd(int fd) { |
| mFd = fd; |
| } |
| |
| long DvrClient::readFromFile(long size) { |
| if (mDvrMQ == NULL || mDvrMQEventFlag == NULL) { |
| ALOGE("Failed to readFromFile. DVR mq is not configured"); |
| return -1; |
| } |
| if (mFd < 0) { |
| ALOGE("Failed to readFromFile. File is not configured"); |
| return -1; |
| } |
| |
| long available = mDvrMQ->availableToWrite(); |
| long write = min(size, available); |
| |
| AidlMQ::MemTransaction tx; |
| long ret = 0; |
| if (mDvrMQ->beginWrite(write, &tx)) { |
| auto first = tx.getFirstRegion(); |
| auto data = first.getAddress(); |
| long length = first.getLength(); |
| long firstToWrite = min(length, write); |
| ret = read(mFd, data, firstToWrite); |
| |
| if (ret < 0) { |
| ALOGE("Failed to read from FD: %s", strerror(errno)); |
| return -1; |
| } |
| if (ret < firstToWrite) { |
| ALOGW("file to MQ, first region: %ld bytes to write, but %ld bytes written", |
| firstToWrite, ret); |
| } else if (firstToWrite < write) { |
| ALOGD("write second region: %ld bytes written, %ld bytes in total", ret, write); |
| auto second = tx.getSecondRegion(); |
| data = second.getAddress(); |
| length = second.getLength(); |
| int secondToWrite = std::min(length, write - firstToWrite); |
| ret += read(mFd, data, secondToWrite); |
| } |
| ALOGD("file to MQ: %ld bytes need to be written, %ld bytes written", write, ret); |
| if (!mDvrMQ->commitWrite(ret)) { |
| ALOGE("Error: failed to commit write!"); |
| return -1; |
| } |
| } else { |
| ALOGE("dvrMq.beginWrite failed"); |
| } |
| |
| if (ret > 0) { |
| mDvrMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_READY)); |
| } |
| return ret; |
| } |
| |
| long DvrClient::readFromBuffer(int8_t* buffer, long size) { |
| if (mDvrMQ == NULL || mDvrMQEventFlag == NULL) { |
| ALOGE("Failed to readFromBuffer. DVR mq is not configured"); |
| return -1; |
| } |
| if (buffer == nullptr) { |
| ALOGE("Failed to readFromBuffer. Buffer can't be null"); |
| return -1; |
| } |
| |
| long available = mDvrMQ->availableToWrite(); |
| size = min(size, available); |
| |
| if (mDvrMQ->write(buffer, size)) { |
| mDvrMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_READY)); |
| } else { |
| ALOGD("Failed to write FMQ"); |
| return -1; |
| } |
| return size; |
| } |
| |
| long DvrClient::writeToFile(long size) { |
| if (mDvrMQ == NULL || mDvrMQEventFlag == NULL) { |
| ALOGE("Failed to writeToFile. DVR mq is not configured"); |
| return -1; |
| } |
| if (mFd < 0) { |
| ALOGE("Failed to writeToFile. File is not configured"); |
| return -1; |
| } |
| |
| long available = mDvrMQ->availableToRead(); |
| long toRead = min(size, available); |
| |
| long ret = 0; |
| AidlMQ::MemTransaction tx; |
| if (mDvrMQ->beginRead(toRead, &tx)) { |
| auto first = tx.getFirstRegion(); |
| auto data = first.getAddress(); |
| long length = first.getLength(); |
| long firstToRead = std::min(length, toRead); |
| ret = write(mFd, data, firstToRead); |
| |
| if (ret < 0) { |
| ALOGE("Failed to write to FD: %s", strerror(errno)); |
| return -1; |
| } |
| if (ret < firstToRead) { |
| ALOGW("MQ to file: %ld bytes read, but %ld bytes written", firstToRead, ret); |
| } else if (firstToRead < toRead) { |
| ALOGD("read second region: %ld bytes read, %ld bytes in total", ret, toRead); |
| auto second = tx.getSecondRegion(); |
| data = second.getAddress(); |
| length = second.getLength(); |
| int secondToRead = toRead - firstToRead; |
| ret += write(mFd, data, secondToRead); |
| } |
| ALOGD("MQ to file: %ld bytes to be read, %ld bytes written", toRead, ret); |
| if (!mDvrMQ->commitRead(ret)) { |
| ALOGE("Error: failed to commit read!"); |
| return 0; |
| } |
| } else { |
| ALOGE("dvrMq.beginRead failed"); |
| } |
| if (ret > 0) { |
| mDvrMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_CONSUMED)); |
| } |
| |
| return ret; |
| } |
| |
| long DvrClient::writeToBuffer(int8_t* buffer, long size) { |
| if (mDvrMQ == NULL || mDvrMQEventFlag == NULL) { |
| ALOGE("Failed to writetoBuffer. DVR mq is not configured"); |
| return -1; |
| } |
| if (buffer == nullptr) { |
| ALOGE("Failed to writetoBuffer. Buffer can't be null"); |
| return -1; |
| } |
| |
| long available = mDvrMQ->availableToRead(); |
| size = min(size, available); |
| |
| if (mDvrMQ->read(buffer, size)) { |
| mDvrMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_CONSUMED)); |
| } else { |
| ALOGD("Failed to write FMQ"); |
| return -1; |
| } |
| return size; |
| } |
| |
| Result DvrClient::configure(DvrSettings settings) { |
| if (mTunerDvr != NULL) { |
| TunerDvrSettings dvrSettings = getAidlDvrSettingsFromHidl(settings); |
| Status s = mTunerDvr->configure(dvrSettings); |
| Result res = ClientHelper::getServiceSpecificErrorCode(s); |
| if (res != Result::SUCCESS) { |
| return res; |
| } |
| |
| AidlMQDesc aidlMqDesc; |
| s = mTunerDvr->getQueueDesc(&aidlMqDesc); |
| res = ClientHelper::getServiceSpecificErrorCode(s); |
| if (res != Result::SUCCESS) { |
| return res; |
| } |
| mDvrMQ = new (nothrow) AidlMQ(aidlMqDesc); |
| EventFlag::createEventFlag(mDvrMQ->getEventFlagWord(), &mDvrMQEventFlag); |
| return res; |
| } |
| |
| if (mDvr != NULL) { |
| Result res = mDvr->configure(settings); |
| if (res == Result::SUCCESS) { |
| MQDescriptorSync<uint8_t> dvrMQDesc; |
| res = getQueueDesc(dvrMQDesc); |
| if (res == Result::SUCCESS) { |
| AidlMQDesc aidlMQDesc; |
| unsafeHidlToAidlMQDescriptor<uint8_t, int8_t, SynchronizedReadWrite>( |
| dvrMQDesc, &aidlMQDesc); |
| mDvrMQ = new (nothrow) AidlMessageQueue(aidlMQDesc); |
| EventFlag::createEventFlag(mDvrMQ->getEventFlagWord(), &mDvrMQEventFlag); |
| } |
| } |
| return res; |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result DvrClient::attachFilter(sp<FilterClient> filterClient) { |
| if (mTunerDvr != NULL) { |
| Status s = mTunerDvr->attachFilter(filterClient->getAidlFilter()); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mDvr != NULL) { |
| sp<IFilter> hidlFilter = filterClient->getHalFilter(); |
| if (hidlFilter == NULL) { |
| return Result::INVALID_ARGUMENT; |
| } |
| return mDvr->attachFilter(hidlFilter); |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result DvrClient::detachFilter(sp<FilterClient> filterClient) { |
| if (mTunerDvr != NULL) { |
| Status s = mTunerDvr->detachFilter(filterClient->getAidlFilter()); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mDvr != NULL) { |
| sp<IFilter> hidlFilter = filterClient->getHalFilter(); |
| if (hidlFilter == NULL) { |
| return Result::INVALID_ARGUMENT; |
| } |
| return mDvr->detachFilter(hidlFilter); |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result DvrClient::start() { |
| if (mTunerDvr != NULL) { |
| Status s = mTunerDvr->start(); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mDvr != NULL) { |
| return mDvr->start(); |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result DvrClient::stop() { |
| if (mTunerDvr != NULL) { |
| Status s = mTunerDvr->stop(); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mDvr != NULL) { |
| return mDvr->stop(); |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result DvrClient::flush() { |
| if (mTunerDvr != NULL) { |
| Status s = mTunerDvr->flush(); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mDvr != NULL) { |
| return mDvr->flush(); |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result DvrClient::close() { |
| if (mDvrMQEventFlag != NULL) { |
| EventFlag::deleteEventFlag(&mDvrMQEventFlag); |
| } |
| mDvrMQ = NULL; |
| |
| if (mTunerDvr != NULL) { |
| Status s = mTunerDvr->close(); |
| mTunerDvr = NULL; |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mDvr != NULL) { |
| Result res = mDvr->close(); |
| mDvr = NULL; |
| return res; |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| /////////////// IDvrCallback /////////////////////// |
| |
| HidlDvrCallback::HidlDvrCallback(sp<DvrClientCallback> dvrClientCallback) |
| : mDvrClientCallback(dvrClientCallback) {} |
| |
| Return<void> HidlDvrCallback::onRecordStatus(const RecordStatus status) { |
| if (mDvrClientCallback != NULL) { |
| mDvrClientCallback->onRecordStatus(status); |
| } |
| return Void(); |
| } |
| |
| Return<void> HidlDvrCallback::onPlaybackStatus(const PlaybackStatus status) { |
| if (mDvrClientCallback != NULL) { |
| mDvrClientCallback->onPlaybackStatus(status); |
| } |
| return Void(); |
| } |
| |
| /////////////// TunerDvrCallback /////////////////////// |
| |
| TunerDvrCallback::TunerDvrCallback(sp<DvrClientCallback> dvrClientCallback) |
| : mDvrClientCallback(dvrClientCallback) {} |
| |
| Status TunerDvrCallback::onRecordStatus(int status) { |
| if (mDvrClientCallback != NULL) { |
| mDvrClientCallback->onRecordStatus(static_cast<RecordStatus>(status)); |
| return Status::ok(); |
| } |
| return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE)); |
| } |
| |
| Status TunerDvrCallback::onPlaybackStatus(int status) { |
| if (mDvrClientCallback != NULL) { |
| mDvrClientCallback->onPlaybackStatus(static_cast<PlaybackStatus>(status)); |
| return Status::ok(); |
| } |
| return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE)); |
| } |
| |
| /////////////// DvrClient Helper Methods /////////////////////// |
| |
| Result DvrClient::getQueueDesc(MQDesc& dvrMQDesc) { |
| if (mDvr != NULL) { |
| Result res = Result::UNKNOWN_ERROR; |
| mDvr->getQueueDesc([&](Result r, const MQDesc& desc) { |
| dvrMQDesc = desc; |
| res = r; |
| }); |
| return res; |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| TunerDvrSettings DvrClient::getAidlDvrSettingsFromHidl(DvrSettings settings) { |
| TunerDvrSettings s; |
| switch (settings.getDiscriminator()) { |
| case DvrSettings::hidl_discriminator::record: { |
| s.statusMask = static_cast<int>(settings.record().statusMask); |
| s.lowThreshold = static_cast<int>(settings.record().lowThreshold); |
| s.highThreshold = static_cast<int>(settings.record().highThreshold); |
| s.dataFormat = static_cast<int>(settings.record().dataFormat); |
| s.packetSize = static_cast<int>(settings.record().packetSize); |
| return s; |
| } |
| case DvrSettings::hidl_discriminator::playback: { |
| s.statusMask = static_cast<int>(settings.playback().statusMask); |
| s.lowThreshold = static_cast<int>(settings.playback().lowThreshold); |
| s.highThreshold = static_cast<int>(settings.playback().highThreshold); |
| s.dataFormat = static_cast<int>(settings.playback().dataFormat); |
| s.packetSize = static_cast<int>(settings.playback().packetSize); |
| return s; |
| } |
| default: |
| break; |
| } |
| return s; |
| } |
| } // namespace android |