Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e4979f49 authored by Haofan Wang's avatar Haofan Wang Committed by Android (Google) Code Review
Browse files

Merge changes I0ccae57b,I40965f38 into main 

* changes:
  Add sound parameter validation in media quality VTS
  Add picture parameter validation in media quality VTS
parents a7e25685 48ee2b52

tv/mediaquality/aidl/vts/functional/VtsHalMediaQualityTest.cpp

+410 −0
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include <android/binder_manager.h>

#include <binder/IServiceManager.h>

#include <binder/ProcessState.h>

#include <log/log.h>

#include <future>



using aidl::android::hardware::graphics::common::PixelFormat;
@@ -63,6 +64,407 @@ using ndk::SpAIBinder; 
#define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())

#define EXPECT_OK(ret) EXPECT_TRUE(ret.isOk())



void validateParameterRange0To100(int value) {

    EXPECT_GE(value, 0);

    EXPECT_LE(value, 100);

}



void validateParameterRange0To2047(int value) {

    EXPECT_GE(value, 0);

    EXPECT_LE(value, 2047);

}



void validateColorTemperature(int value) {

    EXPECT_GE(value, -100);

    EXPECT_LE(value, 100);

}



void validatePictureParameter(const PictureParameter& param) {

    switch (param.getTag()) {

        case PictureParameter::Tag::brightness: {

            ALOGD("[validatePictureParameter] validate brightness value");

            float value = param.get<PictureParameter::Tag::brightness>();

            EXPECT_TRUE(value >= 0.0f && value <= 1.0f);

            break;

        }

        case PictureParameter::Tag::contrast: {

            ALOGD("[validatePictureParameter] validate contrast value");

            int value = param.get<PictureParameter::Tag::contrast>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::sharpness: {

            ALOGD("[validatePictureParameter] validate sharpness value");

            int value = param.get<PictureParameter::Tag::sharpness>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::saturation: {

            ALOGD("[validatePictureParameter] validate saturation value");

            int value = param.get<PictureParameter::Tag::saturation>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::hue: {

            ALOGD("[validatePictureParameter] validate hue value");

            int value = param.get<PictureParameter::Tag::hue>();

            EXPECT_GE(value, -50);

            EXPECT_LE(value, 50);

            break;

        }

        case PictureParameter::Tag::colorTunerBrightness: {

            ALOGD("[validatePictureParameter] validate colorTunerBrightness value");

            int value = param.get<PictureParameter::Tag::colorTunerBrightness>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerSaturation: {

            ALOGD("[validatePictureParameter] validate colorTunerSaturation value");

            int value = param.get<PictureParameter::Tag::colorTunerSaturation>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerHue: {

            ALOGD("[validatePictureParameter] validate colorTunerHue value");

            int value = param.get<PictureParameter::Tag::colorTunerHue>();

            EXPECT_GE(value, -50);

            EXPECT_LE(value, 50);

            break;

        }

        case PictureParameter::Tag::colorTunerRedOffset: {

            ALOGD("[validatePictureParameter] validate colorTunerRedOffset value");

            int value = param.get<PictureParameter::Tag::colorTunerRedOffset>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerGreenOffset: {

            ALOGD("[validatePictureParameter] validate colorTunerGreenOffset value");

            int value = param.get<PictureParameter::Tag::colorTunerGreenOffset>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerBlueOffset: {

            ALOGD("[validatePictureParameter] validate colorTunerBlueOffset value");

            int value = param.get<PictureParameter::Tag::colorTunerBlueOffset>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerRedGain: {

            ALOGD("[validatePictureParameter] validate colorTunerRedGain value");

            int value = param.get<PictureParameter::Tag::colorTunerRedGain>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerGreenGain: {

            ALOGD("[validatePictureParameter] validate colorTunerGreenGain value");

            int value = param.get<PictureParameter::Tag::colorTunerGreenGain>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerBlueGain: {

            ALOGD("[validatePictureParameter] validate colorTunerBlueGain value");

            int value = param.get<PictureParameter::Tag::colorTunerBlueGain>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::panelInitMaxLuminceNits: {

            ALOGD("[validatePictureParameter] validate panelInitMaxLuminceNits value");

            int value = param.get<PictureParameter::Tag::panelInitMaxLuminceNits>();

            EXPECT_GE(value, 0);

            EXPECT_LE(value, 10000);

            break;

        }

        case PictureParameter::Tag::colorTemperatureRedGain: {

            ALOGD("[validatePictureParameter] validate colorTemperatureRedGain value");

            int value = param.get<PictureParameter::Tag::colorTemperatureRedGain>();

            validateColorTemperature(value);

            break;

        }

        case PictureParameter::Tag::colorTemperatureGreenGain: {

            ALOGD("[validatePictureParameter] validate colorTemperatureGreenGain value");

            int value = param.get<PictureParameter::Tag::colorTemperatureGreenGain>();

            validateColorTemperature(value);

            break;

        }

        case PictureParameter::Tag::colorTemperatureBlueGain: {

            ALOGD("[validatePictureParameter] validate colorTemperatureBlueGain value");

            int value = param.get<PictureParameter::Tag::colorTemperatureBlueGain>();

            validateColorTemperature(value);

            break;

        }

        case PictureParameter::Tag::colorTemperatureRedOffset: {

            ALOGD("[validatePictureParameter] validate ccolorTemperatureRedOffset value");

            int value = param.get<PictureParameter::Tag::colorTemperatureRedOffset>();

            validateColorTemperature(value);

            break;

        }

        case PictureParameter::Tag::colorTemperatureGreenOffset: {

            ALOGD("[validatePictureParameter] validate colorTemperatureGreenOffset value");

            int value = param.get<PictureParameter::Tag::colorTemperatureGreenOffset>();

            validateColorTemperature(value);

            break;

        }

        case PictureParameter::Tag::colorTemperatureBlueOffset: {

            ALOGD("[validatePictureParameter] validate colorTemperatureBlueOffset value");

            int value = param.get<PictureParameter::Tag::colorTemperatureBlueOffset>();

            validateColorTemperature(value);

            break;

        }

        case PictureParameter::Tag::elevenPointRed: {

            ALOGD("[validatePictureParameter] validate elevenPointRed value");

            std::array<int, 11> elevenPointValues =

                    param.get<PictureParameter::Tag::elevenPointRed>();

            for (int value : elevenPointValues) {

                validateParameterRange0To100(value);

            }

            break;

        }

        case PictureParameter::Tag::elevenPointGreen: {

            ALOGD("[validatePictureParameter] validate elevenPointGreen value");

            std::array<int, 11> elevenPointValues =

                    param.get<PictureParameter::Tag::elevenPointGreen>();

            for (int value : elevenPointValues) {

                validateParameterRange0To100(value);

            }

            break;

        }

        case PictureParameter::Tag::elevenPointBlue: {

            ALOGD("[validatePictureParameter] validate elevenPointBlue value");

            std::array<int, 11> elevenPointValues =

                    param.get<PictureParameter::Tag::elevenPointBlue>();

            for (int value : elevenPointValues) {

                validateParameterRange0To100(value);

            }

            break;

        }

        case PictureParameter::Tag::osdRedGain: {

            ALOGD("[validatePictureParameter] validate osdRedGain value");

            int value = param.get<PictureParameter::Tag::osdRedGain>();

            validateParameterRange0To2047(value);

            break;

        }

        case PictureParameter::Tag::osdGreenGain: {

            ALOGD("[validatePictureParameter] validate osdGreenGain value");

            int value = param.get<PictureParameter::Tag::osdGreenGain>();

            validateParameterRange0To2047(value);

            break;

        }

        case PictureParameter::Tag::osdBlueGain: {

            ALOGD("[validatePictureParameter] validate osdBlueGain value");

            int value = param.get<PictureParameter::Tag::osdBlueGain>();

            validateParameterRange0To2047(value);

            break;

        }

        case PictureParameter::Tag::osdRedOffset: {

            ALOGD("[validatePictureParameter] validate osdRedOffset value");

            int value = param.get<PictureParameter::Tag::osdRedOffset>();

            validateParameterRange0To2047(value);

            break;

        }

        case PictureParameter::Tag::osdGreenOffset: {

            ALOGD("[validatePictureParameter] validate osdGreenOffset value");

            int value = param.get<PictureParameter::Tag::osdGreenOffset>();

            validateParameterRange0To2047(value);

            break;

        }

        case PictureParameter::Tag::osdBlueOffset: {

            ALOGD("[validatePictureParameter] validate osdBlueOffset value");

            int value = param.get<PictureParameter::Tag::osdBlueOffset>();

            validateParameterRange0To2047(value);

            break;

        }

        case PictureParameter::Tag::osdHue: {

            ALOGD("[validatePictureParameter] validate osdHue value");

            int value = param.get<PictureParameter::Tag::osdHue>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::osdSaturation: {

            ALOGD("[validatePictureParameter] validate osdSaturation value");

            int value = param.get<PictureParameter::Tag::osdSaturation>();

            EXPECT_GE(value, 0);

            EXPECT_LE(value, 255);

            break;

        }

        case PictureParameter::Tag::osdContrast: {

            ALOGD("[validatePictureParameter] validate osdContrast value");

            int value = param.get<PictureParameter::Tag::osdContrast>();

            validateParameterRange0To2047(value);

            break;

        }

        case PictureParameter::Tag::colorTunerHueRed: {

            ALOGD("[validatePictureParameter] validate colorTunerHueRed value");

            int value = param.get<PictureParameter::Tag::colorTunerHueRed>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerHueGreen: {

            ALOGD("[validatePictureParameter] validate colorTunerHueGreen value");

            int value = param.get<PictureParameter::Tag::colorTunerHueGreen>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerHueBlue: {

            ALOGD("[validatePictureParameter] validate colorTunerHueBlue value");

            int value = param.get<PictureParameter::Tag::colorTunerHueBlue>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerHueCyan: {

            ALOGD("[validatePictureParameter] validate colorTunerHueCyan value");

            int value = param.get<PictureParameter::Tag::colorTunerHueCyan>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerHueMagenta: {

            ALOGD("[validatePictureParameter] validate colorTunerHueMagenta value");

            int value = param.get<PictureParameter::Tag::colorTunerHueMagenta>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerHueYellow: {

            ALOGD("[validatePictureParameter] validate colorTunerHueYellow value");

            int value = param.get<PictureParameter::Tag::colorTunerHueYellow>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerHueFlesh: {

            ALOGD("[validatePictureParameter] validate colorTunerHueFlesh value");

            int value = param.get<PictureParameter::Tag::colorTunerHueFlesh>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerSaturationRed: {

            ALOGD("[validatePictureParameter] validate colorTunerSaturationRed value");

            int value = param.get<PictureParameter::Tag::colorTunerSaturationRed>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerSaturationGreen: {

            ALOGD("[validatePictureParameter] validate colorTunerSaturationGreen value");

            int value = param.get<PictureParameter::Tag::colorTunerSaturationGreen>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerSaturationBlue: {

            ALOGD("[validatePictureParameter] validate colorTunerSaturationBlue value");

            int value = param.get<PictureParameter::Tag::colorTunerSaturationBlue>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerSaturationCyan: {

            ALOGD("[validatePictureParameter] validate colorTunerSaturationCyan value");

            int value = param.get<PictureParameter::Tag::colorTunerSaturationCyan>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerSaturationMagenta: {

            ALOGD("[validatePictureParameter] validate colorTunerSaturationMagenta value");

            int value = param.get<PictureParameter::Tag::colorTunerSaturationMagenta>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerSaturationYellow: {

            ALOGD("[validatePictureParameter] validate colorTunerSaturationYellow value");

            int value = param.get<PictureParameter::Tag::colorTunerSaturationYellow>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerSaturationFlesh: {

            ALOGD("[validatePictureParameter] validate colorTunerSaturationFlesh value");

            int value = param.get<PictureParameter::Tag::colorTunerSaturationFlesh>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerLuminanceRed: {

            ALOGD("[validatePictureParameter] validate colorTunerLuminanceRed value");

            int value = param.get<PictureParameter::Tag::colorTunerLuminanceRed>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerLuminanceGreen: {

            ALOGD("[validatePictureParameter] validate colorTunerLuminanceGreen value");

            int value = param.get<PictureParameter::Tag::colorTunerLuminanceGreen>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerLuminanceBlue: {

            ALOGD("[validatePictureParameter] validate colorTunerLuminanceBlue value");

            int value = param.get<PictureParameter::Tag::colorTunerLuminanceBlue>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerLuminanceCyan: {

            ALOGD("[validatePictureParameter] validate colorTunerLuminanceCyan value");

            int value = param.get<PictureParameter::Tag::colorTunerLuminanceCyan>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerLuminanceMagenta: {

            ALOGD("[validatePictureParameter] validate colorTunerLuminanceMagenta value");

            int value = param.get<PictureParameter::Tag::colorTunerLuminanceMagenta>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerLuminanceYellow: {

            ALOGD("[validatePictureParameter] validate colorTunerLuminanceYellow value");

            int value = param.get<PictureParameter::Tag::colorTunerLuminanceYellow>();

            validateParameterRange0To100(value);

            break;

        }

        case PictureParameter::Tag::colorTunerLuminanceFlesh: {

            ALOGD("[validatePictureParameter] validate colorTunerLuminanceFlesh value");

            int value = param.get<PictureParameter::Tag::colorTunerLuminanceFlesh>();

            validateParameterRange0To100(value);

            break;

        }

        default:

            ALOGD("Those parameters don't need to check.");

            break;

    }

}



void validateSoundParameter(const SoundParameter& param) {

    switch (param.getTag()) {

        case SoundParameter::Tag::balance: {

            ALOGD("[validateSoundParameter] validate balance value");

            int value = param.get<SoundParameter::Tag::balance>();

            EXPECT_GE(value, -50);

            EXPECT_LE(value, 50);

            break;

        }

        case SoundParameter::Tag::bass: {

            ALOGD("[validateSoundParameter] validate bass value");

            int value = param.get<SoundParameter::Tag::bass>();

            validateParameterRange0To100(value);

            break;

        }

        case SoundParameter::Tag::treble: {

            ALOGD("[validateSoundParameter] validate treble value");

            int value = param.get<SoundParameter::Tag::treble>();

            validateParameterRange0To100(value);

            break;

        }

        case SoundParameter::Tag::speakersDelayMs: {

            ALOGD("[validateSoundParameter] validate speakersDelayMs value");

            int value = param.get<SoundParameter::Tag::speakersDelayMs>();

            EXPECT_GE(value, 0);

            EXPECT_LE(value, 250);

            break;

        }

        case SoundParameter::Tag::digitalOutputDelayMs: {

            ALOGD("[validateSoundParameter] validate digitalOutputDelayMs value");

            int value = param.get<SoundParameter::Tag::digitalOutputDelayMs>();

            EXPECT_GE(value, 0);

            EXPECT_LE(value, 250);

            break;

        }

        default:

            ALOGD("Those parameters don't need to check.");

            break;

    }

}



class MediaQualityCallback : public BnMediaQualityCallback {

  public:

    explicit MediaQualityCallback(
@@ -83,7 +485,11 @@ class PictureProfileAdjustmentListener : public BnPictureProfileAdjustmentListen 
            const std::function<void(const PictureProfile& pictureProfile)>&

                    on_hal_picture_profile_adjust)

        : on_hal_picture_profile_adjust_(on_hal_picture_profile_adjust) {}



    ScopedAStatus onPictureProfileAdjusted(const PictureProfile& pictureProfile) override {

        for (const auto& param : pictureProfile.parameters.pictureParameters) {

            validatePictureParameter(param);

        }

        on_hal_picture_profile_adjust_(pictureProfile);

        return ScopedAStatus::ok();

    }
@@ -111,7 +517,11 @@ class SoundProfileAdjustmentListener : public BnSoundProfileAdjustmentListener { 
            const std::function<void(const SoundProfile& soundProfile)>&

                    on_hal_sound_profile_adjust)

        : on_hal_sound_profile_adjust_(on_hal_sound_profile_adjust) {}



    ScopedAStatus onSoundProfileAdjusted(const SoundProfile& soundProfile) override {

        for (const auto& param : soundProfile.parameters.soundParameters) {

            validateSoundParameter(param);

        }

        on_hal_sound_profile_adjust_(soundProfile);

        return ScopedAStatus::ok();

    }