xref: /hardware/intel/common/utils/ISV/base/isv_worker.cpp

/*
 * Copyright (C) 2012 Intel Corporation.  All rights reserved.
 *
 * 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.
 *
 */
#include <cutils/properties.h>
#include <system/graphics.h>
#include "isv_worker.h"
#ifndef TARGET_VPP_USE_GEN
#include <hal_public.h>
#else
#include <ufo/graphics.h>
#endif

//#define LOG_NDEBUG 0
#undef LOG_TAG
#define LOG_TAG "isv-omxil"

#define CHECK_VASTATUS(str) \
    do { \
        if (vaStatus != VA_STATUS_SUCCESS) { \
                ALOGE("%s failed\n", str); \
                return STATUS_ERROR;}   \
        }while(0);

enum STRENGTH {
    STRENGTH_LOW = 0,
    STRENGTH_MEDIUM,
    STRENGTH_HIGH
};

#define DENOISE_DEBLOCK_STRENGTH STRENGTH_MEDIUM
#define COLOR_STRENGTH STRENGTH_MEDIUM
#ifdef TARGET_VPP_USE_GEN
#define COLOR_NUM 4
#else
#define COLOR_NUM 2
#endif

#define MAX_FRC_OUTPUT 4 /*for frcx4*/

using namespace android;

ISVWorker::ISVWorker()
    :mNumForwardReferences(0),
    mVAContext(VA_INVALID_ID),
    mWidth(0), mHeight(0),
    mDisplay(NULL), mVADisplay(NULL),
    mVAConfig(VA_INVALID_ID),
    mForwardReferences(NULL),
    mPrevInput(0), mPrevOutput(0),
    mNumFilterBuffers(0),
    mFilterFrc(VA_INVALID_ID), mFilters(0),
    mInputIndex(0), mOutputIndex(0),
    mOutputCount(0) {
    memset(&mFilterBuffers, VA_INVALID_ID, VAProcFilterCount * sizeof(VABufferID));
    memset(&mFilterParam, 0, sizeof(mFilterParam));
}

bool ISVWorker::isSupport() const {
    bool support = false;

    int num_entrypoints = vaMaxNumEntrypoints(mVADisplay);
    VAEntrypoint * entrypoints = (VAEntrypoint *)malloc(num_entrypoints * sizeof(VAEntrypoint));
    if (entrypoints == NULL) {
        ALOGE("failed to malloc entrypoints array\n");
        return false;
    }

    // check if it contains VPP entry point VAEntrypointVideoProc
    VAStatus vaStatus = vaQueryConfigEntrypoints(mVADisplay, VAProfileNone, entrypoints, &num_entrypoints);
    if (vaStatus != VA_STATUS_SUCCESS) {
        ALOGE("vaQueryConfigEntrypoints failed");
        return false;
    }
    for (int i = 0; !support && i < num_entrypoints; i++) {
        support = entrypoints[i] == VAEntrypointVideoProc;
    }
    free(entrypoints);
    entrypoints = NULL;

    return support;
}

uint32_t ISVWorker::getProcBufCount() {
    return getOutputBufCount(mInputIndex);
}

uint32_t ISVWorker::getFillBufCount() {
        return getOutputBufCount(mOutputIndex);
}

uint32_t ISVWorker::getOutputBufCount(uint32_t index) {
    uint32_t bufCount = 1;
    if (((mFilters & FilterFrameRateConversion) != 0)
            && index > 0)
            bufCount = mFilterParam.frcRate - (((mFilterParam.frcRate == FRC_RATE_2_5X) ? (index & 1): 0));
    return bufCount;
}


status_t ISVWorker::init(uint32_t width, uint32_t height) {
    ALOGV("init");

    if (mDisplay != NULL) {
        ALOGE("VA is particially started");
        return STATUS_ERROR;
    }
    mDisplay = new Display;
    *mDisplay = ANDROID_DISPLAY_HANDLE;

    mVADisplay = vaGetDisplay(mDisplay);
    if (mVADisplay == NULL) {
        ALOGE("vaGetDisplay failed");
        return STATUS_ERROR;
    }

    int majorVersion, minorVersion;
    VAStatus vaStatus = vaInitialize(mVADisplay, &majorVersion, &minorVersion);
    CHECK_VASTATUS("vaInitialize");

    // Check if VPP entry point is supported
    if (!isSupport()) {
        ALOGE("VPP is not supported on current platform");
        return STATUS_NOT_SUPPORT;
    }

    // Find out the format for the target
    VAConfigAttrib attrib;
    attrib.type = VAConfigAttribRTFormat;
    vaStatus = vaGetConfigAttributes(mVADisplay, VAProfileNone, VAEntrypointVideoProc, &attrib, 1);
    CHECK_VASTATUS("vaGetConfigAttributes");

    if ((attrib.value & VA_RT_FORMAT_YUV420) == 0) {
        ALOGE("attribute is %x vs wanted %x", attrib.value, VA_RT_FORMAT_YUV420);
        return STATUS_NOT_SUPPORT;
    }

    ALOGV("ready to create config");
    // Create the configuration
    vaStatus = vaCreateConfig(mVADisplay, VAProfileNone, VAEntrypointVideoProc, &attrib, 1, &mVAConfig);
    CHECK_VASTATUS("vaCreateConfig");


    // Create Context
    ALOGV("ready to create context");
    mWidth = width;
    mHeight = height;
    vaStatus = vaCreateContext(mVADisplay, mVAConfig, mWidth, mHeight, 0, NULL, 0, &mVAContext);
    CHECK_VASTATUS("vaCreateContext");

    ALOGV("VA has been successfully started");
    return STATUS_OK;
}

status_t ISVWorker::deinit() {
    {
        Mutex::Autolock autoLock(mPipelineBufferLock);
        while (!mPipelineBuffers.isEmpty()) {
            VABufferID pipelineBuffer = mPipelineBuffers.itemAt(0);
            if (VA_STATUS_SUCCESS != vaDestroyBuffer(mVADisplay, pipelineBuffer))
                ALOGW("%s: failed to destroy va buffer id %d", __func__, pipelineBuffer);
            mPipelineBuffers.removeAt(0);
        }
    }

    if (mNumFilterBuffers != 0) {
        for (uint32_t i = 0; i < mNumFilterBuffers; i++) {
            if(VA_STATUS_SUCCESS != vaDestroyBuffer(mVADisplay, mFilterBuffers[i]))
                ALOGW("%s: failed to destroy va buffer id %d", __func__, mFilterBuffers[i]);
        }
        mNumFilterBuffers = 0;
        memset(&mFilterBuffers, VA_INVALID_ID, VAProcFilterCount * sizeof(VABufferID));
        mFilterFrc = VA_INVALID_ID;
    }

    if (mForwardReferences != NULL) {
        free(mForwardReferences);
        mForwardReferences = NULL;
        mNumForwardReferences = 0;
    }

    if (mVAContext != VA_INVALID_ID) {
         vaDestroyContext(mVADisplay, mVAContext);
         mVAContext = VA_INVALID_ID;
    }

    if (mVAConfig != VA_INVALID_ID) {
        vaDestroyConfig(mVADisplay, mVAConfig);
        mVAConfig = VA_INVALID_ID;
    }

    if (mVADisplay) {
        vaTerminate(mVADisplay);
        mVADisplay = NULL;
    }

    if (mDisplay) {
        delete mDisplay;
        mDisplay = NULL;
    }

    return STATUS_OK;
}

status_t ISVWorker::allocSurface(uint32_t* width, uint32_t* height,
        uint32_t stride, uint32_t format, unsigned long handle, int32_t* surfaceId)
{
    if (mWidth == 0 || mHeight == 0) {
        ALOGE("%s: isv worker has not been initialized.", __func__);
        return STATUS_ERROR;
    }

#ifndef TARGET_VPP_USE_GEN
    *width = mWidth;
    *height = mHeight;
#endif
    // Create VASurfaces
    VASurfaceAttrib attribs[3];
    VASurfaceAttribExternalBuffers vaExtBuf;

    memset(&vaExtBuf, 0, sizeof(VASurfaceAttribExternalBuffers));
    switch(format) {
        case HAL_PIXEL_FORMAT_YV12:
            vaExtBuf.pixel_format = VA_FOURCC_YV12;
            vaExtBuf.num_planes = 3;
            vaExtBuf.pitches[0] = stride;
            vaExtBuf.pitches[1] = stride / 2;
            vaExtBuf.pitches[2] = stride / 2;
            vaExtBuf.pitches[3] = 0;
            vaExtBuf.offsets[0] = 0;
            vaExtBuf.offsets[1] = stride * *height;
            vaExtBuf.offsets[2] = vaExtBuf.offsets[1] + (stride / 2) * (*height / 2);
            vaExtBuf.offsets[3] = 0;
            break;
        case HAL_PIXEL_FORMAT_INTEL_YV12:
            vaExtBuf.pixel_format = VA_FOURCC_YV12;
            vaExtBuf.num_planes = 3;
            vaExtBuf.pitches[0] = stride;
            vaExtBuf.pitches[1] = stride / 2;
            vaExtBuf.pitches[2] = stride / 2;
            vaExtBuf.pitches[3] = 0;
            vaExtBuf.offsets[0] = 0;
            // The height of HAL_PIXEL_FORMAT_INTEL_YV12 gralloc buffer has been aligned with 32 pixels.
            vaExtBuf.offsets[1] = stride * ((*height + 31) & ~31);
            vaExtBuf.offsets[2] = vaExtBuf.offsets[1] + (stride / 2) * (((*height + 31) & ~31) / 2);
            vaExtBuf.offsets[3] = 0;
            break;
#ifdef TARGET_VPP_USE_GEN
        case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
        case HAL_PIXEL_FORMAT_NV12_X_TILED_INTEL:
        //it will be removed in future, it indicate the same format with HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL
        case HAL_PIXEL_FORMAT_YUV420PackedSemiPlanar_Tiled_INTEL:
#else
        case HAL_PIXEL_FORMAT_NV12_VED:
        case HAL_PIXEL_FORMAT_NV12_VEDT:
#endif
            vaExtBuf.pixel_format = VA_FOURCC_NV12;
            vaExtBuf.num_planes = 2;
            vaExtBuf.pitches[0] = stride;
            vaExtBuf.pitches[1] = stride;
            vaExtBuf.pitches[2] = 0;
            vaExtBuf.pitches[3] = 0;
            vaExtBuf.offsets[0] = 0;
            vaExtBuf.offsets[1] = stride * *height;
            vaExtBuf.offsets[2] = 0;
            vaExtBuf.offsets[3] = 0;
            break;
        default:
            ALOGE("%s: can't support this format 0x%08x", __func__, format);
            return STATUS_ERROR;
    }
    vaExtBuf.width = *width;
    vaExtBuf.height = *height;
    vaExtBuf.data_size = stride * *height * 1.5;
    vaExtBuf.num_buffers = 1;
#ifndef TARGET_VPP_USE_GEN
    if (format == HAL_PIXEL_FORMAT_NV12_VEDT) {
        ALOGV("set TILING flag");
        vaExtBuf.flags |= VA_SURFACE_EXTBUF_DESC_ENABLE_TILING;
    }
#endif
    vaExtBuf.flags |= VA_SURFACE_ATTRIB_MEM_TYPE_ANDROID_GRALLOC;
    vaExtBuf.buffers = (long unsigned int*)&handle;

    attribs[0].type = (VASurfaceAttribType)VASurfaceAttribMemoryType;
    attribs[0].flags = VA_SURFACE_ATTRIB_SETTABLE;
    attribs[0].value.type = VAGenericValueTypeInteger;
    attribs[0].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_ANDROID_GRALLOC;

    attribs[1].type = (VASurfaceAttribType)VASurfaceAttribExternalBufferDescriptor;
    attribs[1].flags = VA_SURFACE_ATTRIB_SETTABLE;
    attribs[1].value.type = VAGenericValueTypePointer;
    attribs[1].value.value.p = &vaExtBuf;

    attribs[2].type = (VASurfaceAttribType)VASurfaceAttribUsageHint;
    attribs[2].flags = VA_SURFACE_ATTRIB_SETTABLE;
    attribs[2].value.type = VAGenericValueTypeInteger;
    attribs[2].value.value.i = VA_SURFACE_ATTRIB_USAGE_HINT_VPP_READ;

    ALOGV("%s: Ext buffer: width %d, height %d, data_size %d, pitch %d", __func__,
            vaExtBuf.width, vaExtBuf.height, vaExtBuf.data_size, vaExtBuf.pitches[0]);
    VAStatus vaStatus = vaCreateSurfaces(mVADisplay, VA_RT_FORMAT_YUV420, vaExtBuf.width,
                                 vaExtBuf.height, (VASurfaceID*)surfaceId, 1, attribs, 3);
    CHECK_VASTATUS("vaCreateSurfaces");

    return (vaStatus == VA_STATUS_SUCCESS) ? STATUS_OK : STATUS_ERROR;
}

status_t ISVWorker::freeSurface(int32_t* surfaceId)
{
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    vaDestroySurfaces(mVADisplay, (VASurfaceID*)surfaceId, 1);
    CHECK_VASTATUS("vaDestroySurfaces");

    return (vaStatus == VA_STATUS_SUCCESS) ? STATUS_OK : STATUS_ERROR;
}

status_t ISVWorker::configFilters(uint32_t filters,
                                  const FilterParam* filterParam)
{
    status_t ret = STATUS_OK;

    if (!filterParam) {
        ALOGE("%s: invalid filterParam", __func__);
        return STATUS_ERROR;
    }

    if (filters != 0) {
        mFilterParam.srcWidth = filterParam->srcWidth;
        mFilterParam.srcHeight = filterParam->srcHeight;
        mFilterParam.dstWidth = filterParam->dstWidth;
        mFilterParam.dstHeight = filterParam->dstHeight;
        mFilterParam.frameRate = filterParam->frameRate;
        mFilterParam.frcRate = filterParam->frcRate;
    }

    if (mFilters != filters) {
        mFilters = filters;
        ALOGI("%s: mFilters 0x%x, fps %d, frc rate %d", __func__, mFilters, mFilterParam.frameRate, mFilterParam.frcRate);
        ret = setupFilters();
    }

    return ret;
}

bool ISVWorker::isFpsSupport(int32_t fps, int32_t *fpsSet, int32_t fpsSetCnt) {
    bool ret = false;
    for (int32_t i = 0; i < fpsSetCnt; i++) {
        if (fps == fpsSet[i]) {
            ret = true;
            break;
        }
    }

    return ret;
}

status_t ISVWorker::setupFilters() {
    ALOGV("setupFilters");
    VAProcFilterParameterBuffer deblock, denoise, sharpen, stde;
    VAProcFilterParameterBufferDeinterlacing deint;
    VAProcFilterParameterBufferColorBalance color[COLOR_NUM];
    VAProcFilterParameterBufferFrameRateConversion frc;
    VABufferID deblockId, denoiseId, deintId, sharpenId, colorId, frcId, stdeId;
    uint32_t numCaps;
    VAProcFilterCap deblockCaps, denoiseCaps, sharpenCaps, frcCaps, stdeCaps;
    VAProcFilterCapDeinterlacing deinterlacingCaps[VAProcDeinterlacingCount];
    VAProcFilterCapColorBalance colorCaps[COLOR_NUM];
    VAStatus vaStatus;
    uint32_t numSupportedFilters = VAProcFilterCount;
    VAProcFilterType supportedFilters[VAProcFilterCount];

    if (mNumFilterBuffers != 0) {
        for (uint32_t i = 0; i < mNumFilterBuffers; i++) {
            if (VA_STATUS_SUCCESS != vaDestroyBuffer(mVADisplay, mFilterBuffers[i]))
                ALOGW("%s: failed to destroy va buffer %d", __func__, mFilterBuffers[i]);
                //return STATUS_ERROR;
        }
        memset(&mFilterBuffers, VA_INVALID_ID, VAProcFilterCount * sizeof(VABufferID));
        mFilterFrc = VA_INVALID_ID;
        mNumFilterBuffers = 0;
    }

    // query supported filters
    vaStatus = vaQueryVideoProcFilters(mVADisplay, mVAContext, supportedFilters, &numSupportedFilters);
    CHECK_VASTATUS("vaQueryVideoProcFilters");

    // create filter buffer for each filter
    for (uint32_t i = 0; i < numSupportedFilters; i++) {
        switch (supportedFilters[i]) {
            case VAProcFilterDeblocking:
                if ((mFilters & FilterDeblocking) != 0) {
                    // check filter caps
                    numCaps = 1;
                    vaStatus = vaQueryVideoProcFilterCaps(mVADisplay, mVAContext,
                            VAProcFilterDeblocking,
                            &deblockCaps,
                            &numCaps);
                    CHECK_VASTATUS("vaQueryVideoProcFilterCaps for deblocking");
                    // create parameter buffer
                    deblock.type = VAProcFilterDeblocking;
                    deblock.value = deblockCaps.range.min_value + DENOISE_DEBLOCK_STRENGTH * deblockCaps.range.step;
                    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
                        VAProcFilterParameterBufferType, sizeof(deblock), 1,
                        &deblock, &deblockId);
                    CHECK_VASTATUS("vaCreateBuffer for deblocking");
                    mFilterBuffers[mNumFilterBuffers] = deblockId;
                    mNumFilterBuffers++;
                }
                break;
            case VAProcFilterNoiseReduction:
                if((mFilters & FilterNoiseReduction) != 0) {
                    // check filter caps
                    numCaps = 1;
                    vaStatus = vaQueryVideoProcFilterCaps(mVADisplay, mVAContext,
                            VAProcFilterNoiseReduction,
                            &denoiseCaps,
                            &numCaps);
                    CHECK_VASTATUS("vaQueryVideoProcFilterCaps for denoising");
                    // create parameter buffer
                    denoise.type = VAProcFilterNoiseReduction;
#ifdef TARGET_VPP_USE_GEN
                    char propValueString[PROPERTY_VALUE_MAX];

                    // placeholder for vpg driver: can't support denoise factor auto adjust, so leave config to user.
                    property_get("vpp.filter.denoise.factor", propValueString, "64.0");
                    denoise.value = atof(propValueString);
                    denoise.value = (denoise.value < 0.0f) ? 0.0f : denoise.value;
                    denoise.value = (denoise.value > 64.0f) ? 64.0f : denoise.value;
#else
                    denoise.value = denoiseCaps.range.min_value + DENOISE_DEBLOCK_STRENGTH * denoiseCaps.range.step;
#endif
                    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
                        VAProcFilterParameterBufferType, sizeof(denoise), 1,
                        &denoise, &denoiseId);
                    CHECK_VASTATUS("vaCreateBuffer for denoising");
                    mFilterBuffers[mNumFilterBuffers] = denoiseId;
                    mNumFilterBuffers++;
                }
                break;
            case VAProcFilterDeinterlacing:
                if ((mFilters & FilterDeinterlacing) != 0) {
                    numCaps = VAProcDeinterlacingCount;
                    vaStatus = vaQueryVideoProcFilterCaps(mVADisplay, mVAContext,
                            VAProcFilterDeinterlacing,
                            &deinterlacingCaps[0],
                            &numCaps);
                    CHECK_VASTATUS("vaQueryVideoProcFilterCaps for deinterlacing");
                    for (uint32_t i = 0; i < numCaps; i++)
                    {
                        VAProcFilterCapDeinterlacing * const cap = &deinterlacingCaps[i];
                        if (cap->type != VAProcDeinterlacingBob) // desired Deinterlacing Type
                            continue;

                        deint.type = VAProcFilterDeinterlacing;
                        deint.algorithm = VAProcDeinterlacingBob;
                        vaStatus = vaCreateBuffer(mVADisplay,
                                mVAContext,
                                VAProcFilterParameterBufferType,
                                sizeof(deint), 1,
                                &deint, &deintId);
                        CHECK_VASTATUS("vaCreateBuffer for deinterlacing");
                        mFilterBuffers[mNumFilterBuffers] = deintId;
                        mNumFilterBuffers++;
                    }
                }
                break;
            case VAProcFilterSharpening:
                if((mFilters & FilterSharpening) != 0) {
                    // check filter caps
                    numCaps = 1;
                    vaStatus = vaQueryVideoProcFilterCaps(mVADisplay, mVAContext,
                            VAProcFilterSharpening,
                            &sharpenCaps,
                            &numCaps);
                    CHECK_VASTATUS("vaQueryVideoProcFilterCaps for sharpening");
                    // create parameter buffer
                    sharpen.type = VAProcFilterSharpening;
#ifdef TARGET_VPP_USE_GEN
                    char propValueString[PROPERTY_VALUE_MAX];

                    // placeholder for vpg driver: can't support sharpness factor auto adjust, so leave config to user.
                    property_get("vpp.filter.sharpen.factor", propValueString, "8.0");
                    sharpen.value = atof(propValueString);
                    sharpen.value = (sharpen.value < 0.0f) ? 0.0f : sharpen.value;
                    sharpen.value = (sharpen.value > 64.0f) ? 64.0f : sharpen.value;
#else
                    sharpen.value = sharpenCaps.range.default_value;
#endif
                    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
                        VAProcFilterParameterBufferType, sizeof(sharpen), 1,
                        &sharpen, &sharpenId);
                    CHECK_VASTATUS("vaCreateBuffer for sharpening");
                    mFilterBuffers[mNumFilterBuffers] = sharpenId;
                    mNumFilterBuffers++;
                }
                break;
            case VAProcFilterColorBalance:
                if((mFilters & FilterColorBalance) != 0) {
                    uint32_t featureCount = 0;
                    // check filter caps
                    // FIXME: it's not used at all!
                    numCaps = COLOR_NUM;
                    vaStatus = vaQueryVideoProcFilterCaps(mVADisplay, mVAContext,
                            VAProcFilterColorBalance,
                            colorCaps,
                            &numCaps);
                    CHECK_VASTATUS("vaQueryVideoProcFilterCaps for color balance");
                    // create parameter buffer
                    for (uint32_t i = 0; i < numCaps; i++) {
                        if (colorCaps[i].type == VAProcColorBalanceAutoSaturation) {
                            color[i].type = VAProcFilterColorBalance;
                            color[i].attrib = VAProcColorBalanceAutoSaturation;
                            color[i].value = colorCaps[i].range.min_value + COLOR_STRENGTH * colorCaps[i].range.step;
                            featureCount++;
                        }
                        else if (colorCaps[i].type == VAProcColorBalanceAutoBrightness) {
                            color[i].type = VAProcFilterColorBalance;
                            color[i].attrib = VAProcColorBalanceAutoBrightness;
                            color[i].value = colorCaps[i].range.min_value + COLOR_STRENGTH * colorCaps[i].range.step;
                            featureCount++;
                        }
                    }
#ifdef TARGET_VPP_USE_GEN
                    //TODO: VPG need to support check input value by colorCaps.
                    enum {kHue = 0, kSaturation, kBrightness, kContrast};
                    char propValueString[PROPERTY_VALUE_MAX];
                    color[kHue].type = VAProcFilterColorBalance;
                    color[kHue].attrib = VAProcColorBalanceHue;

                    // placeholder for vpg driver: can't support auto color balance, so leave config to user.
                    property_get("vpp.filter.procamp.hue", propValueString, "179.0");
                    color[kHue].value = atof(propValueString);
                    color[kHue].value = (color[kHue].value < -180.0f) ? -180.0f : color[kHue].value;
                    color[kHue].value = (color[kHue].value > 180.0f) ? 180.0f : color[kHue].value;
                    featureCount++;

                    color[kSaturation].type   = VAProcFilterColorBalance;
                    color[kSaturation].attrib = VAProcColorBalanceSaturation;
                    property_get("vpp.filter.procamp.saturation", propValueString, "1.0");
                    color[kSaturation].value = atof(propValueString);
                    color[kSaturation].value = (color[kSaturation].value < 0.0f) ? 0.0f : color[kSaturation].value;
                    color[kSaturation].value = (color[kSaturation].value > 10.0f) ? 10.0f : color[kSaturation].value;
                    featureCount++;

                    color[kBrightness].type   = VAProcFilterColorBalance;
                    color[kBrightness].attrib = VAProcColorBalanceBrightness;
                    property_get("vpp.filter.procamp.brightness", propValueString, "0.0");
                    color[kBrightness].value = atof(propValueString);
                    color[kBrightness].value = (color[kBrightness].value < -100.0f) ? -100.0f : color[kBrightness].value;
                    color[kBrightness].value = (color[kBrightness].value > 100.0f) ? 100.0f : color[kBrightness].value;
                    featureCount++;

                    color[kContrast].type   = VAProcFilterColorBalance;
                    color[kContrast].attrib = VAProcColorBalanceContrast;
                    property_get("vpp.filter.procamp.contrast", propValueString, "1.0");
                    color[kContrast].value = atof(propValueString);
                    color[kContrast].value = (color[kContrast].value < 0.0f) ? 0.0f : color[kContrast].value;
                    color[kContrast].value = (color[kContrast].value > 10.0f) ? 10.0f : color[kContrast].value;
                    featureCount++;
#endif
                    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
                        VAProcFilterParameterBufferType, sizeof(*color), featureCount,
                        color, &colorId);
                    CHECK_VASTATUS("vaCreateBuffer for color balance");
                    mFilterBuffers[mNumFilterBuffers] = colorId;
                    mNumFilterBuffers++;
                }
                break;
            case VAProcFilterFrameRateConversion:
                if((mFilters & FilterFrameRateConversion) != 0) {
                    frc.type = VAProcFilterFrameRateConversion;
                    frc.input_fps = mFilterParam.frameRate;
                    switch (mFilterParam.frcRate){
                        case FRC_RATE_1X:
                            frc.output_fps = frc.input_fps;
                            break;
                        case FRC_RATE_2X:
                            frc.output_fps = frc.input_fps * 2;
                            break;
                        case FRC_RATE_2_5X:
                            frc.output_fps = frc.input_fps * 5/2;
                            break;
                        case FRC_RATE_4X:
                            frc.output_fps = frc.input_fps * 4;
                            break;
                    }
                    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
                        VAProcFilterParameterBufferType, sizeof(frc), 1,
                        &frc, &frcId);
                    CHECK_VASTATUS("vaCreateBuffer for frc");
                    mFilterBuffers[mNumFilterBuffers] = frcId;
                    mNumFilterBuffers++;
                    mFilterFrc = frcId;
                }
                break;
            case VAProcFilterSkinToneEnhancement:
                if((mFilters & FilterSkinToneEnhancement) != 0) {
                    // check filter caps
                    numCaps = 1;
                    vaStatus = vaQueryVideoProcFilterCaps(mVADisplay, mVAContext,
                            VAProcFilterSkinToneEnhancement,
                            &stdeCaps,
                            &numCaps);
                    CHECK_VASTATUS("vaQueryVideoProcFilterCaps for skintone");
                    // create parameter buffer
                    stde.type = VAProcFilterSkinToneEnhancement;
#ifdef TARGET_VPP_USE_GEN
                    char propValueString[PROPERTY_VALUE_MAX];

                    // placeholder for vpg driver: can't support skintone factor auto adjust, so leave config to user.
                    property_get("vpp.filter.skintone.factor", propValueString, "8.0");
                    stde.value = atof(propValueString);
                    stde.value = (stde.value < 0.0f) ? 0.0f : stde.value;
                    stde.value = (stde.value > 8.0f) ? 8.0f : stde.value;
#else
                    stde.value = stdeCaps.range.default_value;
#endif
                    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
                        VAProcFilterParameterBufferType, sizeof(stde), 1,
                        &stde, &stdeId);
                    CHECK_VASTATUS("vaCreateBuffer for skintone");
                    mFilterBuffers[mNumFilterBuffers] = stdeId;
                    mNumFilterBuffers++;
                }
                break;
            default:
                ALOGW("%s: Not supported filter 0x%08x", __func__, supportedFilters[i]);
                break;
        }
    }

    return setupPipelineCaps();
}

status_t ISVWorker::setupPipelineCaps() {
    ALOGV("setupPipelineCaps");
    //TODO color standards
    VAProcPipelineCaps pipelineCaps;
    VAStatus vaStatus;
    pipelineCaps.input_color_standards = in_color_standards;
    pipelineCaps.num_input_color_standards = VAProcColorStandardCount;
    pipelineCaps.output_color_standards = out_color_standards;
    pipelineCaps.num_output_color_standards = VAProcColorStandardCount;

    vaStatus = vaQueryVideoProcPipelineCaps(mVADisplay, mVAContext,
        mFilterBuffers, mNumFilterBuffers,
        &pipelineCaps);
    CHECK_VASTATUS("vaQueryVideoProcPipelineCaps");

    if (mForwardReferences != NULL) {
        free(mForwardReferences);
        mForwardReferences = NULL;
        mNumForwardReferences = 0;
    }

    mNumForwardReferences = pipelineCaps.num_forward_references;
    if (mNumForwardReferences > 0) {
        mForwardReferences = (VASurfaceID*)malloc(mNumForwardReferences * sizeof(VASurfaceID));
        if (mForwardReferences == NULL)
            return STATUS_ALLOCATION_ERROR;
        memset(mForwardReferences, 0, mNumForwardReferences * sizeof(VASurfaceID));
    }
    return STATUS_OK;
}

status_t ISVWorker::process(ISVBuffer* inputBuffer, Vector<ISVBuffer*> outputBuffer,
                             uint32_t outputCount, bool isEOS, uint32_t flags) {
    ALOGV("process: outputCount=%d, mInputIndex=%d", outputCount, mInputIndex);
    VASurfaceID input;
    VASurfaceID output[MAX_FRC_OUTPUT];
    VABufferID pipelineId;
    VAProcPipelineParameterBuffer *pipeline;
    VAProcFilterParameterBufferFrameRateConversion *frc;
    VAStatus vaStatus = STATUS_OK;
    uint32_t i = 0;

    if (isEOS) {
        if (mInputIndex == 0) {
            ALOGV("%s: don't need to flush VSP", __func__);
            return STATUS_OK;
        }
        input = VA_INVALID_SURFACE;
        outputCount = 1;
        output[0] = mPrevOutput;
    } else {
        if (!inputBuffer || outputBuffer.size() != outputCount) {
            ALOGE("%s: invalid input/output buffer", __func__);
            return STATUS_ERROR;
        }

        if (outputCount < 1 || outputCount > 4) {
            ALOGE("%s: invalid outputCount", __func__);
            return STATUS_ERROR;
        }

        input = inputBuffer->getSurface();
        for (i = 0; i < outputCount; i++) {
            output[i] = outputBuffer[i]->getSurface();
            if (output[i] == VA_INVALID_SURFACE) {
                ALOGE("invalid output buffer");
                return STATUS_ERROR;
            }
        }
    }

    // reference frames setting
    if (mNumForwardReferences > 0) {
        /* add previous frame into reference array*/
        for (i = 1; i < mNumForwardReferences; i++) {
            mForwardReferences[i - 1] = mForwardReferences[i];
        }

        //make last reference to input
        mForwardReferences[mNumForwardReferences - 1] = mPrevInput;
    }

    mPrevInput = input;

    // create pipeline parameter buffer
    vaStatus = vaCreateBuffer(mVADisplay,
            mVAContext,
            VAProcPipelineParameterBufferType,
            sizeof(VAProcPipelineParameterBuffer),
            1,
            NULL,
            &pipelineId);
    CHECK_VASTATUS("vaCreateBuffer for VAProcPipelineParameterBufferType");

    ALOGV("before vaBeginPicture");
    vaStatus = vaBeginPicture(mVADisplay, mVAContext, output[0]);
    CHECK_VASTATUS("vaBeginPicture");

    // map pipeline paramter buffer
    vaStatus = vaMapBuffer(mVADisplay, pipelineId, (void**)&pipeline);
    CHECK_VASTATUS("vaMapBuffer for pipeline parameter buffer");

    // frc pamameter setting
    if ((mFilters & FilterFrameRateConversion) != 0) {
        vaStatus = vaMapBuffer(mVADisplay, mFilterFrc, (void **)&frc);
        CHECK_VASTATUS("vaMapBuffer for frc parameter buffer");
        if (isEOS)
            frc->num_output_frames = 0;
        else
            frc->num_output_frames = outputCount - 1;
        frc->output_frames = output + 1;
    }

    // pipeline parameter setting
    VARectangle dst_region;
    dst_region.x = 0;
    dst_region.y = 0;
    dst_region.width = mFilterParam.dstWidth;
    dst_region.height = mFilterParam.dstHeight;

    VARectangle src_region;
    src_region.x = 0;
    src_region.y = 0;
    src_region.width = mFilterParam.srcWidth;
    src_region.height = mFilterParam.srcHeight;

    if (isEOS) {
        pipeline->surface = 0;
        pipeline->pipeline_flags = VA_PIPELINE_FLAG_END;
    }
    else {
        pipeline->surface = input;
        pipeline->pipeline_flags = 0;
    }
#ifdef TARGET_VPP_USE_GEN
    pipeline->surface_region = &src_region;
    pipeline->output_region = &dst_region;
    pipeline->surface_color_standard = VAProcColorStandardBT601;
    pipeline->output_color_standard = VAProcColorStandardBT601;
#else
    pipeline->surface_region = NULL;
    pipeline->output_region = NULL;//&output_region;
    pipeline->surface_color_standard = VAProcColorStandardNone;
    pipeline->output_color_standard = VAProcColorStandardNone;
    /* real rotate state will be decided in psb video */
    pipeline->rotation_state = 0;
#endif
    /* FIXME: set more meaningful background color */
    pipeline->output_background_color = 0;
    pipeline->filters = mFilterBuffers;
    pipeline->num_filters = mNumFilterBuffers;
    pipeline->forward_references = mForwardReferences;
    pipeline->num_forward_references = mNumForwardReferences;
    pipeline->backward_references = NULL;
    pipeline->num_backward_references = 0;

    //currently, we only transfer TOP field to frame, no frame rate change.
    if (flags & (OMX_BUFFERFLAG_TFF | OMX_BUFFERFLAG_BFF)) {
        pipeline->filter_flags = VA_TOP_FIELD;
    } else {
        pipeline->filter_flags = VA_FRAME_PICTURE;
    }

    if ((mFilters & FilterFrameRateConversion) != 0) {
        vaStatus = vaUnmapBuffer(mVADisplay, mFilterFrc);
        CHECK_VASTATUS("vaUnmapBuffer for frc parameter buffer");
    }

    vaStatus = vaUnmapBuffer(mVADisplay, pipelineId);
    CHECK_VASTATUS("vaUnmapBuffer for pipeline parameter buffer");

    ALOGV("before vaRenderPicture");
    // Send parameter to driver
    vaStatus = vaRenderPicture(mVADisplay, mVAContext, &pipelineId, 1);
    CHECK_VASTATUS("vaRenderPicture");

    ALOGV("before vaEndPicture");
    vaStatus = vaEndPicture(mVADisplay, mVAContext);
    CHECK_VASTATUS("vaEndPicture");

    if (isEOS) {
        vaStatus = vaSyncSurface(mVADisplay, mPrevOutput);
        CHECK_VASTATUS("vaSyncSurface");
        if (VA_STATUS_SUCCESS != vaDestroyBuffer(mVADisplay, pipelineId)) {
            ALOGE("%s: failed to destroy va buffer %d", __func__, pipelineId);
            return STATUS_ERROR;
        }
        return STATUS_OK;
    }

    mPrevOutput = output[0];
    mInputIndex++;

    Mutex::Autolock autoLock(mPipelineBufferLock);
    mPipelineBuffers.push_back(pipelineId);

    ALOGV("process, exit");
    return STATUS_OK;
}

status_t ISVWorker::fill(Vector<ISVBuffer*> outputBuffer, uint32_t outputCount) {
    ALOGV("fill, outputCount=%d, mOutputIndex=%d",outputCount, mOutputIndex);
    // get output surface
    VASurfaceID output[MAX_FRC_OUTPUT];
    VAStatus vaStatus;
    VASurfaceStatus surStatus;

    if (outputCount < 1)
        return STATUS_ERROR;
    // map GraphicBuffer to VASurface
    for (uint32_t i = 0; i < outputCount; i++) {

        output[i] = outputBuffer[i]->getSurface();
        if (output[i] == VA_INVALID_SURFACE) {
            ALOGE("invalid output buffer");
            return STATUS_ERROR;
        }
        //FIXME: only enable sync mode
#if 0
        vaStatus = vaQuerySurfaceStatus(mVADisplay, output[i],&surStatus);
        CHECK_VASTATUS("vaQuerySurfaceStatus");
        if (surStatus == VASurfaceRendering) {
            ALOGV("Rendering %d", i);
            /* The behavior of driver is: all output of one process task are return in one interruption.
               The whole outputs of one FRC task are all ready or none of them is ready.
               If the behavior changed, it hurts the performance.
            */
            if (0 != i) {
                ALOGW("*****Driver behavior changed. The performance is hurt.");
                ALOGW("Please check driver behavior: all output of one task return in one interruption.");
            }
            vaStatus = STATUS_DATA_RENDERING;
            break;
        }

        if ((surStatus != VASurfaceRendering) && (surStatus != VASurfaceReady)) {
            ALOGE("surface statu Error %d", surStatus);
            vaStatus = STATUS_ERROR;
        }
#endif
        vaStatus = vaSyncSurface(mVADisplay, output[i]);
        CHECK_VASTATUS("vaSyncSurface");
        vaStatus = STATUS_OK;
        mOutputCount++;
        //dumpYUVFrameData(output[i]);
    }

    {
        Mutex::Autolock autoLock(mPipelineBufferLock);
        if (vaStatus == STATUS_OK) {
            VABufferID pipelineBuffer = mPipelineBuffers.itemAt(0);
            if (VA_STATUS_SUCCESS != vaDestroyBuffer(mVADisplay, pipelineBuffer)) {
                ALOGE("%s: failed to destroy va buffer %d", __func__, pipelineBuffer);
                return STATUS_ERROR;
            }
            mPipelineBuffers.removeAt(0);
            mOutputIndex++;
        }
    }

    ALOGV("fill, exit");
    return vaStatus;
}

// Debug only
#define FRAME_OUTPUT_FILE_NV12 "/storage/sdcard0/vpp_output.nv12"
status_t ISVWorker::dumpYUVFrameData(VASurfaceID surfaceID) {
    status_t ret;
    if (surfaceID == VA_INVALID_SURFACE)
        return STATUS_ERROR;

    VAStatus vaStatus;
    VAImage image;
    unsigned char *data_ptr;

    vaStatus = vaDeriveImage(mVADisplay,
            surfaceID,
            &image);
    CHECK_VASTATUS("vaDeriveImage");

    vaStatus = vaMapBuffer(mVADisplay, image.buf, (void **)&data_ptr);
    CHECK_VASTATUS("vaMapBuffer");

    ret = writeNV12(mFilterParam.srcWidth, mFilterParam.srcHeight, data_ptr, image.pitches[0], image.pitches[1]);
    if (ret != STATUS_OK) {
        ALOGV("writeNV12 error");
        return STATUS_ERROR;
    }

    vaStatus = vaUnmapBuffer(mVADisplay, image.buf);
    CHECK_VASTATUS("vaUnMapBuffer");

    vaStatus = vaDestroyImage(mVADisplay,image.image_id);
    CHECK_VASTATUS("vaDestroyImage");

    return STATUS_OK;
}

status_t ISVWorker::reset() {
    status_t ret;
    ALOGV("reset");
    if (mOutputCount > 0) {
        ALOGI("======mVPPInputCount=%d, mVPPRenderCount=%d======",
                mInputIndex, mOutputCount);
    }
    mInputIndex = 0;
    mOutputIndex = 0;
    mOutputCount = 0;

    {
        Mutex::Autolock autoLock(mPipelineBufferLock);
        while (!mPipelineBuffers.isEmpty()) {
            VABufferID pipelineBuffer = mPipelineBuffers.itemAt(0);
            if (VA_STATUS_SUCCESS != vaDestroyBuffer(mVADisplay, pipelineBuffer)) {
                ALOGE("%s: failed to destroy va buffer %d", __func__, pipelineBuffer);
                return STATUS_ERROR;
            }
            mPipelineBuffers.removeAt(0);
        }
    }

    if (mNumFilterBuffers != 0) {
        for (uint32_t i = 0; i < mNumFilterBuffers; i++) {
            if (VA_STATUS_SUCCESS != vaDestroyBuffer(mVADisplay, mFilterBuffers[i]))
                ALOGW("%s: failed to destroy va buffer %d", __func__, mFilterBuffers[i]);
                //return STATUS_ERROR;
        }
        mNumFilterBuffers = 0;
        memset(&mFilterBuffers, VA_INVALID_ID, VAProcFilterCount * sizeof(VABufferID));
        mFilterFrc = VA_INVALID_ID;
    }

    // we need to clear the cache for reference surfaces
    if (mForwardReferences != NULL) {
        free(mForwardReferences);
        mForwardReferences = NULL;
        mNumForwardReferences = 0;
    }

    if (mVAContext != VA_INVALID_ID) {
         vaDestroyContext(mVADisplay, mVAContext);
         mVAContext = VA_INVALID_ID;
    }
    VAStatus vaStatus = vaCreateContext(mVADisplay, mVAConfig, mWidth, mHeight, 0, NULL, 0, &mVAContext);
    CHECK_VASTATUS("vaCreateContext");

    return setupFilters();
}

uint32_t ISVWorker::getVppOutputFps() {
    uint32_t outputFps;
    //mFilterParam.frcRate is 1 if FRC is disabled or input FPS is not changed by VPP.
    if (FRC_RATE_2_5X == mFilterParam.frcRate) {
        outputFps = mFilterParam.frameRate * 5 / 2;
    } else {
        outputFps = mFilterParam.frameRate * mFilterParam.frcRate;
    }

    ALOGV("vpp is on in settings %d %d %d", outputFps,  mFilterParam.frameRate, mFilterParam.frcRate);
    return outputFps;
}


status_t ISVWorker::writeNV12(int width, int height, unsigned char *out_buf, int y_pitch, int uv_pitch) {
    size_t result;
    int frame_size;
    unsigned char *y_start, *uv_start;
    int h;

    FILE *ofile = fopen(FRAME_OUTPUT_FILE_NV12, "ab");
    if(ofile == NULL) {
        ALOGE("Open %s failed!", FRAME_OUTPUT_FILE_NV12);
        return STATUS_ERROR;
    }

    if (out_buf == NULL)
    {
        fclose(ofile);
        return STATUS_ERROR;
    }
    if ((width % 2) || (height % 2))
    {
        fclose(ofile);
        return STATUS_ERROR;
    }
    // Set frame size
    frame_size = height * width * 3/2;

    /* write y */
    y_start = out_buf;
    for (h = 0; h < height; ++h) {
        result = fwrite(y_start, sizeof(unsigned char), width, ofile);
        y_start += y_pitch;
    }

    /* write uv */
    uv_start = out_buf + uv_pitch * height;
    for (h = 0; h < height / 2; ++h) {
        result = fwrite(uv_start, sizeof(unsigned char), width, ofile);
        uv_start += uv_pitch;
    }
    // Close file
    fclose(ofile);
    return STATUS_OK;
}