media/jni/tuner/DvrClient.cpp - LeafOS-Project/android_frameworks_base - Gitiles

 /*
  * 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.
  */

 //#define LOG_NDEBUG 0
 #define LOG_TAG "DvrClient"

 #include "DvrClient.h"

 #include <aidl/android/hardware/tv/tuner/DemuxQueueNotifyBits.h>
 #include <android-base/logging.h>
 #include <inttypes.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <utils/Log.h>

 #include "ClientHelper.h"

 using ::aidl::android::hardware::tv::tuner::DemuxQueueNotifyBits;

 namespace android {
 /////////////// DvrClient ///////////////////////
 DvrClient::DvrClient(shared_ptr<ITunerDvr> tunerDvr) {
     mTunerDvr = tunerDvr;
     mFd = -1;
     mDvrMQ = nullptr;
     mDvrMQEventFlag = nullptr;
 }

 DvrClient::~DvrClient() {
     mTunerDvr = nullptr;
     mFd = -1;
     mDvrMQ = nullptr;
     mDvrMQEventFlag = nullptr;
 }

 void DvrClient::setFd(int32_t fd) {
     mFd = fd;
 }

 int64_t DvrClient::readFromFile(int64_t size) {
     if (mDvrMQ == nullptr || mDvrMQEventFlag == nullptr) {
         ALOGE("Failed to readFromFile. DVR mq is not configured");
         return -1;
     }
     if (mFd < 0) {
         ALOGE("Failed to readFromFile. File is not configured");
         return -1;
     }

     int64_t available = mDvrMQ->availableToWrite();
     int64_t write = min(size, available);

     AidlMQ::MemTransaction tx;
     int64_t ret = 0;
     if (mDvrMQ->beginWrite(write, &tx)) {
         auto first = tx.getFirstRegion();
         auto data = first.getAddress();
         int64_t length = first.getLength();
         int64_t 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: %" PRIu64 " bytes to write, but %" PRIu64
                   " bytes written",
                   firstToWrite, ret);
         } else if (firstToWrite < write) {
             ALOGV("write second region: %" PRIu64 " bytes written, %" PRIu64 " bytes in total", ret,
                   write);
             auto second = tx.getSecondRegion();
             data = second.getAddress();
             length = second.getLength();
             int64_t secondToWrite = std::min(length, write - firstToWrite);
             ret += read(mFd, data, secondToWrite);
         }
         ALOGV("file to MQ: %" PRIu64 " bytes need to be written, %" PRIu64 " 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;
 }

 int64_t DvrClient::readFromBuffer(int8_t* buffer, int64_t size) {
     if (mDvrMQ == nullptr || mDvrMQEventFlag == nullptr) {
         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;
     }

     int64_t 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;
 }

 int64_t DvrClient::writeToFile(int64_t size) {
     if (mDvrMQ == nullptr || mDvrMQEventFlag == nullptr) {
         ALOGE("Failed to writeToFile. DVR mq is not configured");
         return -1;
     }
     if (mFd < 0) {
         ALOGE("Failed to writeToFile. File is not configured");
         return -1;
     }

     int64_t available = mDvrMQ->availableToRead();
     int64_t toRead = min(size, available);

     int64_t ret = 0;
     AidlMQ::MemTransaction tx;
     if (mDvrMQ->beginRead(toRead, &tx)) {
         auto first = tx.getFirstRegion();
         auto data = first.getAddress();
         int64_t length = first.getLength();
         int64_t 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: %" PRIu64 " bytes read, but %" PRIu64 " bytes written", firstToRead,
                   ret);
         } else if (firstToRead < toRead) {
             ALOGV("read second region: %" PRIu64 " bytes read, %" PRIu64 " bytes in total", ret,
                   toRead);
             auto second = tx.getSecondRegion();
             data = second.getAddress();
             length = second.getLength();
             int32_t secondToRead = toRead - firstToRead;
             ret += write(mFd, data, secondToRead);
         }
         ALOGV("MQ to file: %" PRIu64 " bytes to be read, %" PRIu64 " 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;
 }

 int64_t DvrClient::writeToBuffer(int8_t* buffer, int64_t size) {
     if (mDvrMQ == nullptr || mDvrMQEventFlag == nullptr) {
         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;
     }

     int64_t 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;
 }

 int64_t DvrClient::seekFile(int64_t pos) {
     if (mFd < 0) {
         ALOGE("Failed to seekFile. File is not configured");
         return -1;
     }
     return lseek64(mFd, pos, SEEK_SET);
 }

 Result DvrClient::configure(DvrSettings settings) {
     if (mTunerDvr != nullptr) {
         Status s = mTunerDvr->configure(settings);
         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;
     }

     return Result::INVALID_STATE;
 }

 Result DvrClient::attachFilter(sp<FilterClient> filterClient) {
     if (filterClient == nullptr) {
         return Result::INVALID_ARGUMENT;
     }

     if (mTunerDvr != nullptr) {
         Status s = mTunerDvr->attachFilter(filterClient->getAidlFilter());
         return ClientHelper::getServiceSpecificErrorCode(s);
     }

     return Result::INVALID_STATE;
 }

 Result DvrClient::detachFilter(sp<FilterClient> filterClient) {
     if (filterClient == nullptr) {
         return Result::INVALID_ARGUMENT;
     }

     if (mTunerDvr != nullptr) {
         Status s = mTunerDvr->detachFilter(filterClient->getAidlFilter());
         return ClientHelper::getServiceSpecificErrorCode(s);
     }

     return Result::INVALID_STATE;
 }

 Result DvrClient::start() {
     if (mTunerDvr != nullptr) {
         Status s = mTunerDvr->start();
         return ClientHelper::getServiceSpecificErrorCode(s);
     }

     return Result::INVALID_STATE;
 }

 Result DvrClient::stop() {
     if (mTunerDvr != nullptr) {
         Status s = mTunerDvr->stop();
         return ClientHelper::getServiceSpecificErrorCode(s);
     }

     return Result::INVALID_STATE;
 }

 Result DvrClient::flush() {
     if (mTunerDvr != nullptr) {
         Status s = mTunerDvr->flush();
         return ClientHelper::getServiceSpecificErrorCode(s);
     }

     return Result::INVALID_STATE;
 }

 Result DvrClient::close() {
     if (mDvrMQEventFlag != nullptr) {
         EventFlag::deleteEventFlag(&mDvrMQEventFlag);
         mDvrMQEventFlag = nullptr;
     }
     if (mDvrMQ != nullptr) {
         delete mDvrMQ;
         mDvrMQ = nullptr;
     }

     if (mTunerDvr != nullptr) {
         Status s = mTunerDvr->close();
         mTunerDvr = nullptr;
         return ClientHelper::getServiceSpecificErrorCode(s);
     }

     return Result::INVALID_STATE;
 }
 Result DvrClient::setStatusCheckIntervalHint(int64_t durationInMs) {
     if (mTunerDvr == nullptr) {
       return Result::INVALID_STATE;
     }
     if (durationInMs < 0) {
       return Result::INVALID_ARGUMENT;
     }

     Status s = mTunerDvr->setStatusCheckIntervalHint(durationInMs);
     return ClientHelper::getServiceSpecificErrorCode(s);
 }
 /////////////// TunerDvrCallback ///////////////////////
 TunerDvrCallback::TunerDvrCallback(sp<DvrClientCallback> dvrClientCallback)
         : mDvrClientCallback(dvrClientCallback) {}

 Status TunerDvrCallback::onRecordStatus(RecordStatus status) {
     if (mDvrClientCallback != nullptr) {
         mDvrClientCallback->onRecordStatus(status);
         return Status::ok();
     }
     return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
 }

 Status TunerDvrCallback::onPlaybackStatus(PlaybackStatus status) {
     if (mDvrClientCallback != nullptr) {
         mDvrClientCallback->onPlaybackStatus(status);
         return Status::ok();
     }
     return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
 }

 }  // namespace android
	/*
	* 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.
	*/

	//#define LOG_NDEBUG 0
	#define LOG_TAG "DvrClient"

	#include "DvrClient.h"

	#include <aidl/android/hardware/tv/tuner/DemuxQueueNotifyBits.h>
	#include <android-base/logging.h>
	#include <inttypes.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <utils/Log.h>

	#include "ClientHelper.h"

	using ::aidl::android::hardware::tv::tuner::DemuxQueueNotifyBits;

	namespace android {
	/////////////// DvrClient ///////////////////////
	DvrClient::DvrClient(shared_ptr<ITunerDvr> tunerDvr) {
	mTunerDvr = tunerDvr;
	mFd = -1;
	mDvrMQ = nullptr;
	mDvrMQEventFlag = nullptr;
	}

	DvrClient::~DvrClient() {
	mTunerDvr = nullptr;
	mFd = -1;
	mDvrMQ = nullptr;
	mDvrMQEventFlag = nullptr;
	}

	void DvrClient::setFd(int32_t fd) {
	mFd = fd;
	}

	int64_t DvrClient::readFromFile(int64_t size) {
	if (mDvrMQ == nullptr \|\| mDvrMQEventFlag == nullptr) {
	ALOGE("Failed to readFromFile. DVR mq is not configured");
	return -1;
	}
	if (mFd < 0) {
	ALOGE("Failed to readFromFile. File is not configured");
	return -1;
	}

	int64_t available = mDvrMQ->availableToWrite();
	int64_t write = min(size, available);

	AidlMQ::MemTransaction tx;
	int64_t ret = 0;
	if (mDvrMQ->beginWrite(write, &tx)) {
	auto first = tx.getFirstRegion();
	auto data = first.getAddress();
	int64_t length = first.getLength();
	int64_t 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: %" PRIu64 " bytes to write, but %" PRIu64
	" bytes written",
	firstToWrite, ret);
	} else if (firstToWrite < write) {
	ALOGV("write second region: %" PRIu64 " bytes written, %" PRIu64 " bytes in total", ret,
	write);
	auto second = tx.getSecondRegion();
	data = second.getAddress();
	length = second.getLength();
	int64_t secondToWrite = std::min(length, write - firstToWrite);
	ret += read(mFd, data, secondToWrite);
	}
	ALOGV("file to MQ: %" PRIu64 " bytes need to be written, %" PRIu64 " 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;
	}

	int64_t DvrClient::readFromBuffer(int8_t* buffer, int64_t size) {
	if (mDvrMQ == nullptr \|\| mDvrMQEventFlag == nullptr) {
	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;
	}

	int64_t 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;
	}

	int64_t DvrClient::writeToFile(int64_t size) {
	if (mDvrMQ == nullptr \|\| mDvrMQEventFlag == nullptr) {
	ALOGE("Failed to writeToFile. DVR mq is not configured");
	return -1;
	}
	if (mFd < 0) {
	ALOGE("Failed to writeToFile. File is not configured");
	return -1;
	}

	int64_t available = mDvrMQ->availableToRead();
	int64_t toRead = min(size, available);

	int64_t ret = 0;
	AidlMQ::MemTransaction tx;
	if (mDvrMQ->beginRead(toRead, &tx)) {
	auto first = tx.getFirstRegion();
	auto data = first.getAddress();
	int64_t length = first.getLength();
	int64_t 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: %" PRIu64 " bytes read, but %" PRIu64 " bytes written", firstToRead,
	ret);
	} else if (firstToRead < toRead) {
	ALOGV("read second region: %" PRIu64 " bytes read, %" PRIu64 " bytes in total", ret,
	toRead);
	auto second = tx.getSecondRegion();
	data = second.getAddress();
	length = second.getLength();
	int32_t secondToRead = toRead - firstToRead;
	ret += write(mFd, data, secondToRead);
	}
	ALOGV("MQ to file: %" PRIu64 " bytes to be read, %" PRIu64 " 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;
	}

	int64_t DvrClient::writeToBuffer(int8_t* buffer, int64_t size) {
	if (mDvrMQ == nullptr \|\| mDvrMQEventFlag == nullptr) {
	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;
	}

	int64_t 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;
	}

	int64_t DvrClient::seekFile(int64_t pos) {
	if (mFd < 0) {
	ALOGE("Failed to seekFile. File is not configured");
	return -1;
	}
	return lseek64(mFd, pos, SEEK_SET);
	}

	Result DvrClient::configure(DvrSettings settings) {
	if (mTunerDvr != nullptr) {
	Status s = mTunerDvr->configure(settings);
	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;
	}

	return Result::INVALID_STATE;
	}

	Result DvrClient::attachFilter(sp<FilterClient> filterClient) {
	if (filterClient == nullptr) {
	return Result::INVALID_ARGUMENT;
	}

	if (mTunerDvr != nullptr) {
	Status s = mTunerDvr->attachFilter(filterClient->getAidlFilter());
	return ClientHelper::getServiceSpecificErrorCode(s);
	}

	return Result::INVALID_STATE;
	}

	Result DvrClient::detachFilter(sp<FilterClient> filterClient) {
	if (filterClient == nullptr) {
	return Result::INVALID_ARGUMENT;
	}

	if (mTunerDvr != nullptr) {
	Status s = mTunerDvr->detachFilter(filterClient->getAidlFilter());
	return ClientHelper::getServiceSpecificErrorCode(s);
	}

	return Result::INVALID_STATE;
	}

	Result DvrClient::start() {
	if (mTunerDvr != nullptr) {
	Status s = mTunerDvr->start();
	return ClientHelper::getServiceSpecificErrorCode(s);
	}

	return Result::INVALID_STATE;
	}

	Result DvrClient::stop() {
	if (mTunerDvr != nullptr) {
	Status s = mTunerDvr->stop();
	return ClientHelper::getServiceSpecificErrorCode(s);
	}

	return Result::INVALID_STATE;
	}

	Result DvrClient::flush() {
	if (mTunerDvr != nullptr) {
	Status s = mTunerDvr->flush();
	return ClientHelper::getServiceSpecificErrorCode(s);
	}

	return Result::INVALID_STATE;
	}

	Result DvrClient::close() {
	if (mDvrMQEventFlag != nullptr) {
	EventFlag::deleteEventFlag(&mDvrMQEventFlag);
	mDvrMQEventFlag = nullptr;
	}
	if (mDvrMQ != nullptr) {
	delete mDvrMQ;
	mDvrMQ = nullptr;
	}

	if (mTunerDvr != nullptr) {
	Status s = mTunerDvr->close();
	mTunerDvr = nullptr;
	return ClientHelper::getServiceSpecificErrorCode(s);
	}

	return Result::INVALID_STATE;
	}
	Result DvrClient::setStatusCheckIntervalHint(int64_t durationInMs) {
	if (mTunerDvr == nullptr) {
	return Result::INVALID_STATE;
	}
	if (durationInMs < 0) {
	return Result::INVALID_ARGUMENT;
	}

	Status s = mTunerDvr->setStatusCheckIntervalHint(durationInMs);
	return ClientHelper::getServiceSpecificErrorCode(s);
	}
	/////////////// TunerDvrCallback ///////////////////////
	TunerDvrCallback::TunerDvrCallback(sp<DvrClientCallback> dvrClientCallback)
	: mDvrClientCallback(dvrClientCallback) {}

	Status TunerDvrCallback::onRecordStatus(RecordStatus status) {
	if (mDvrClientCallback != nullptr) {
	mDvrClientCallback->onRecordStatus(status);
	return Status::ok();
	}
	return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
	}

	Status TunerDvrCallback::onPlaybackStatus(PlaybackStatus status) {
	if (mDvrClientCallback != nullptr) {
	mDvrClientCallback->onPlaybackStatus(status);
	return Status::ok();
	}
	return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
	}

	} // namespace android