Merge "Add test scan message during Frontend.scan in the Frontend default impl" into sc-dev (bc593da2) · Commits · e / os / android_hardware_interfaces

tv/tuner/1.0/vts/functional/FilterTests.cpp

+11 −20

Original line number	Diff line number	Diff line
		@@ -78,24 +78,20 @@ bool FilterCallback::readFilterEventData() {
		DemuxFilterEvent filterEvent = mFilterEvent;
		ALOGW("[vts] reading from filter FMQ or buffer %d", mFilterId);
		// todo separate filter handlers
		for (int i = 0; i < filterEvent.events.size(); i++) {
		switch (mFilterEventType) {
		case FilterEventType::SECTION:
		mDataLength = filterEvent.events[i].section().dataLength;
		for (auto event : filterEvent.events) {
		switch (event.getDiscriminator()) {
		case DemuxFilterEvent::Event::hidl_discriminator::section:
		mDataLength = event.section().dataLength;
		break;
		case FilterEventType::PES:
		mDataLength = filterEvent.events[i].pes().dataLength;
		break;
		case FilterEventType::MEDIA:
		return dumpAvData(filterEvent.events[i].media());
		case FilterEventType::RECORD:
		return readRecordData(filterEvent.events[i].tsRecord());
		case FilterEventType::MMTPRECORD:
		break;
		case FilterEventType::DOWNLOAD:
		case DemuxFilterEvent::Event::hidl_discriminator::pes:
		mDataLength = event.pes().dataLength;
		break;
		case DemuxFilterEvent::Event::hidl_discriminator::media:
		return dumpAvData(event.media());
		case DemuxFilterEvent::Event::hidl_discriminator::tsRecord:
		return readRecordData(event.tsRecord());
		default:
		break;
		continue;
		}
		// EXPECT_TRUE(mDataLength == goldenDataOutputBuffer.size()) << "buffer size does not
		// match";
		@@ -150,11 +146,6 @@ AssertionResult FilterTests::openFilterInDemux(DemuxFilterType type, uint32_t bu
		mFilter = filter;
		status = result;
		});

		if (status == Result::SUCCESS) {
		mFilterCallback->setFilterEventType(getFilterEventType(type));
		}

		return AssertionResult(status == Result::SUCCESS);
		}

tv/tuner/1.0/vts/functional/FilterTests.h

+0 −60

Original line number	Diff line number	Diff line
		@@ -66,17 +66,6 @@ using ::testing::AssertionResult;

		using namespace std;

		enum FilterEventType : uint8_t {
		UNDEFINED,
		SECTION,
		MEDIA,
		PES,
		RECORD,
		MMTPRECORD,
		DOWNLOAD,
		TEMI,
		};

		using FilterMQ = MessageQueue<uint8_t, kSynchronizedReadWrite>;
		using MQDesc = MQDescriptorSync<uint8_t>;

		@@ -104,7 +93,6 @@ class FilterCallback : public IFilterCallback {

		void setFilterId(uint32_t filterId) { mFilterId = filterId; }
		void setFilterInterface(sp<IFilter> filter) { mFilter = filter; }
		void setFilterEventType(FilterEventType type) { mFilterEventType = type; }

		void testFilterDataOutput();

		@@ -130,7 +118,6 @@ class FilterCallback : public IFilterCallback {

		uint32_t mFilterId;
		sp<IFilter> mFilter;
		FilterEventType mFilterEventType;
		std::unique_ptr<FilterMQ> mFilterMQ;
		EventFlag* mFilterMQEventFlag;
		DemuxFilterEvent mFilterEvent;
		@@ -168,53 +155,6 @@ class FilterTests {
		AssertionResult closeFilter(uint32_t filterId);
		AssertionResult closeTimeFilter();

		FilterEventType getFilterEventType(DemuxFilterType type) {
		FilterEventType eventType = FilterEventType::UNDEFINED;
		switch (type.mainType) {
		case DemuxFilterMainType::TS:
		switch (type.subType.tsFilterType()) {
		case DemuxTsFilterType::UNDEFINED:
		break;
		case DemuxTsFilterType::SECTION:
		eventType = FilterEventType::SECTION;
		break;
		case DemuxTsFilterType::PES:
		eventType = FilterEventType::PES;
		break;
		case DemuxTsFilterType::TS:
		break;
		case DemuxTsFilterType::AUDIO:
		case DemuxTsFilterType::VIDEO:
		eventType = FilterEventType::MEDIA;
		break;
		case DemuxTsFilterType::PCR:
		break;
		case DemuxTsFilterType::RECORD:
		eventType = FilterEventType::RECORD;
		break;
		case DemuxTsFilterType::TEMI:
		eventType = FilterEventType::TEMI;
		break;
		}
		break;
		case DemuxFilterMainType::MMTP:
		/mmtpSettings/
		break;
		case DemuxFilterMainType::IP:
		/ipSettings/
		break;
		case DemuxFilterMainType::TLV:
		/tlvSettings/
		break;
		case DemuxFilterMainType::ALP:
		/alpSettings/
		break;
		default:
		break;
		}
		return eventType;
		}

		protected:
		static AssertionResult failure() { return ::testing::AssertionFailure(); }

tv/tuner/1.1/default/Filter.cpp

+23 −7

Original line number	Diff line number	Diff line
		@@ -145,26 +145,36 @@ Return<Result> Filter::start() {
		case DemuxFilterMainType::TS:
		mCallback->onFilterEvent(createMediaEvent());
		mCallback->onFilterEvent(createTsRecordEvent());
		mCallback_1_1->onFilterEvent_1_1(createTsRecordEvent(), createTsRecordEventExt());
		mCallback->onFilterEvent(createTemiEvent());
		// clients could still pass 1.0 callback
		if (mCallback_1_1 != NULL) {
		mCallback_1_1->onFilterEvent_1_1(createTsRecordEvent(), createTsRecordEventExt());
		}
		break;
		case DemuxFilterMainType::MMTP:
		mCallback->onFilterEvent(createDownloadEvent());
		mCallback->onFilterEvent(createMmtpRecordEvent());
		mCallback_1_1->onFilterEvent_1_1(createMmtpRecordEvent(), createMmtpRecordEventExt());
		if (mCallback_1_1 != NULL) {
		mCallback_1_1->onFilterEvent_1_1(createMmtpRecordEvent(),
		createMmtpRecordEventExt());
		}
		break;
		case DemuxFilterMainType::IP:
		mCallback->onFilterEvent(createSectionEvent());
		mCallback->onFilterEvent(createIpPayloadEvent());
		break;
		case DemuxFilterMainType::TLV: {
		if (mCallback_1_1 != NULL) {
		DemuxFilterEvent emptyFilterEvent;
		mCallback_1_1->onFilterEvent_1_1(emptyFilterEvent, createMonitorEvent());
		}
		break;
		}
		case DemuxFilterMainType::ALP: {
		if (mCallback_1_1 != NULL) {
		DemuxFilterEvent emptyFilterEvent;
		mCallback_1_1->onFilterEvent_1_1(emptyFilterEvent, createRestartEvent());
		}
		break;
		}
		default:
		@@ -967,7 +977,6 @@ DemuxFilterEvent Filter::createMediaEvent() {
		.dataLength = 3,
		.offset = 4,
		.isSecureMemory = true,
		.avDataId = 5,
		.mpuSequenceNumber = 6,
		.isPesPrivateData = true,
		});
		@@ -988,9 +997,16 @@ DemuxFilterEvent Filter::createMediaEvent() {

		native_handle_t* nativeHandle = createNativeHandle(av_fd);
		if (nativeHandle == NULL) {
		::close(av_fd);
		ALOGE("[Filter] Failed to create native_handle %d", errno);
		return event;
		}

		// Create a dataId and add a <dataId, av_fd> pair into the dataId2Avfd map
		uint64_t dataId = mLastUsedDataId++ /createdUID/;
		mDataId2Avfd[dataId] = dup(av_fd);
		event.events[0].media().avDataId = dataId;

		hidl_handle handle;
		handle.setTo(nativeHandle, /shouldOwn=/true);
		event.events[0].media().avMemory = std::move(handle);

tv/tuner/1.1/default/Frontend.cpp

+92 −18

Original line number	Diff line number	Diff line
		@@ -88,18 +88,6 @@ Return<Result> Frontend::stopTune() {

		Return<Result> Frontend::scan(const FrontendSettings& settings, FrontendScanType type) {
		ALOGV("%s", __FUNCTION__);

		if (mType == FrontendType::ATSC) {
		FrontendScanMessage msg;
		msg.isLocked(true);
		mCallback->onScanMessage(FrontendScanMessageType::LOCKED, msg);
		mIsLocked = true;
		return Result::SUCCESS;
		}
		if (mType != FrontendType::DVBT) {
		return Result::UNAVAILABLE;
		}

		FrontendScanMessage msg;

		if (mIsLocked) {
		@@ -108,15 +96,96 @@ Return<Result> Frontend::scan(const FrontendSettings& settings, FrontendScanType
		return Result::SUCCESS;
		}

		uint32_t frequency = settings.dvbt().frequency;
		uint32_t frequency;
		switch (settings.getDiscriminator()) {
		case FrontendSettings::hidl_discriminator::analog:
		frequency = settings.analog().frequency;
		break;
		case FrontendSettings::hidl_discriminator::atsc:
		frequency = settings.atsc().frequency;
		break;
		case FrontendSettings::hidl_discriminator::atsc3:
		frequency = settings.atsc3().frequency;
		break;
		case FrontendSettings::hidl_discriminator::dvbs:
		frequency = settings.dvbs().frequency;
		break;
		case FrontendSettings::hidl_discriminator::dvbc:
		frequency = settings.dvbc().frequency;
		break;
		case FrontendSettings::hidl_discriminator::dvbt:
		frequency = settings.dvbt().frequency;
		break;
		case FrontendSettings::hidl_discriminator::isdbs:
		frequency = settings.isdbs().frequency;
		break;
		case FrontendSettings::hidl_discriminator::isdbs3:
		frequency = settings.isdbs3().frequency;
		break;
		case FrontendSettings::hidl_discriminator::isdbt:
		frequency = settings.isdbt().frequency;
		break;
		}

		if (type == FrontendScanType::SCAN_BLIND) {
		frequency += 100;
		}

		msg.frequencies({frequency});
		mCallback->onScanMessage(FrontendScanMessageType::FREQUENCY, msg);
		msg.isLocked(true);
		mCallback->onScanMessage(FrontendScanMessageType::LOCKED, msg);
		mIsLocked = true;

		msg.progressPercent(20);
		mCallback->onScanMessage(FrontendScanMessageType::PROGRESS_PERCENT, msg);

		msg.symbolRates({30});
		mCallback->onScanMessage(FrontendScanMessageType::SYMBOL_RATE, msg);

		if (mType == FrontendType::DVBT) {
		msg.hierarchy(FrontendDvbtHierarchy::HIERARCHY_NON_NATIVE);
		mCallback->onScanMessage(FrontendScanMessageType::HIERARCHY, msg);
		}

		if (mType == FrontendType::ANALOG) {
		msg.analogType(FrontendAnalogType::PAL);
		mCallback->onScanMessage(FrontendScanMessageType::ANALOG_TYPE, msg);
		}

		msg.plpIds({3});
		mCallback->onScanMessage(FrontendScanMessageType::PLP_IDS, msg);

		msg.groupIds({2});
		mCallback->onScanMessage(FrontendScanMessageType::GROUP_IDS, msg);

		msg.inputStreamIds({1});
		mCallback->onScanMessage(FrontendScanMessageType::INPUT_STREAM_IDS, msg);

		FrontendScanMessage::Standard s;
		switch (mType) {
		case FrontendType::DVBT:
		s.tStd(FrontendDvbtStandard::AUTO);
		msg.std(s);
		mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg);
		break;
		case FrontendType::DVBS:
		s.sStd(FrontendDvbsStandard::AUTO);
		msg.std(s);
		mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg);
		break;
		case FrontendType::ANALOG:
		s.sifStd(FrontendAnalogSifStandard::AUTO);
		msg.std(s);
		mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg);
		break;
		default:
		break;
		}

		FrontendScanAtsc3PlpInfo info{
		.plpId = 1,
		.bLlsFlag = false,
		};
		msg.atsc3PlpInfos({info});
		mCallback->onScanMessage(FrontendScanMessageType::ATSC3_PLP_INFO, msg);

		sp<V1_1::IFrontendCallback> frontendCallback_v1_1 =
		V1_1::IFrontendCallback::castFrom(mCallback);
		@@ -129,15 +198,20 @@ Return<Result> Frontend::scan(const FrontendSettings& settings, FrontendScanType
		frontendCallback_v1_1->onScanMessageExt1_1(
		V1_1::FrontendScanMessageTypeExt1_1::HIGH_PRIORITY, msg);
		} else {
		ALOGD("[Filter] Couldn't cast to V1_1 IFrontendCallback");
		ALOGD("[Frontend] Couldn't cast to V1_1 IFrontendCallback");
		}

		msg.isLocked(true);
		mCallback->onScanMessage(FrontendScanMessageType::LOCKED, msg);
		mIsLocked = true;

		return Result::SUCCESS;
		}

		Return<Result> Frontend::scan_1_1(const FrontendSettings& settings, FrontendScanType type,
		const V1_1::FrontendSettingsExt1_1& /settingsExt1_1/) {
		const V1_1::FrontendSettingsExt1_1& settingsExt1_1) {
		ALOGV("%s", __FUNCTION__);
		ALOGD("[Frontend] scan_1_1 end frequency %d", settingsExt1_1.endFrequency);
		return scan(settings, type);
		}