/*
* Copyright (c) 2007-2017, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
//!
//! \file      cm_surface_manager_os.cpp 
//! \brief     Contains Class CmSurfaceManager  definitions 
//!
#include "cm_surface_manager.h"

#include "cm_surface_2d_rt.h"

#include "cm_surface_2d_rt.h"
#include "cm_device_rt.h"
#include "cm_mem.h"

namespace CMRT_UMD
{
//*-----------------------------------------------------------------------------
//| Purpose:    Create Surface Manager
//| Arguments :
//|               device         [in]       Pointer to Cm Device
//|               halMaxValues   [in]       Cm Max values
//|               surfaceManager [out]      Reference to pointer to CmSurfaceManager
//|
//| Returns:    Result of the operation.
//*-----------------------------------------------------------------------------
int32_t CmSurfaceManager::Create(
    CmDeviceRT* device,
    CM_HAL_MAX_VALUES halMaxValues,
    CM_HAL_MAX_VALUES_EX halMaxValuesEx,
    CmSurfaceManager* &surfaceManager)
{
    int32_t result = CM_SUCCESS;

    surfaceManager = new (std::nothrow) CmSurfaceManager(device);
    if (surfaceManager)
    {
        result = surfaceManager->Initialize(halMaxValues, halMaxValuesEx);
        if (result != CM_SUCCESS)
        {
            CmSurfaceManager::Destroy(surfaceManager);
        }
    }
    else
    {
        CM_ASSERTMESSAGE("Error: Failed to create CmSurfaceManager due to out of system memory.");
        result = CM_OUT_OF_HOST_MEMORY;
    }
    return result;
}

//*-----------------------------------------------------------------------------
//| Purpose:    Destroy CmSurfaceManager
//| Returns:    Result of the operation.
//*-----------------------------------------------------------------------------
int32_t CmSurfaceManager::Destroy(CmSurfaceManager* &surfaceManager)
{
    if (surfaceManager)
    {
        delete surfaceManager;
        surfaceManager = nullptr;
    }
    return CM_SUCCESS;
}

//*-----------------------------------------------------------------------------
//| Purpose:    Constructor of CmSurfaceManager
//| Returns:    None
//*-----------------------------------------------------------------------------
CmSurfaceManager::CmSurfaceManager(CmDeviceRT* device) :CmSurfaceManagerBase(device) {}

//*-----------------------------------------------------------------------------
//| Purpose:    Destructor of CmSurfaceManager
//| Returns:    None
//*-----------------------------------------------------------------------------
CmSurfaceManager::~CmSurfaceManager() {}

//*-----------------------------------------------------------------------------
//| Purpose:    Create surface 2d with mos info
//| Arguments :
//|               mosResource        [in]       pointer to mos resource
//|               createdByCm        [in]       if this surface created by thin layer
//|               surface          [IN/out]   Reference to CmSurface2D
//|
//| Returns:    Result of the operation.
//*-----------------------------------------------------------------------------
 int32_t CmSurfaceManager::CreateSurface2DFromMosResource(MOS_RESOURCE * mosResource, bool createdByCm, CmSurface2DRT* & surface)
 {
    uint32_t handle         = 0;
    uint32_t index          = ValidSurfaceIndexStart();
    int32_t result         = 0;
    uint32_t width          = 0;
    uint32_t height         = 0;
    uint32_t pitch          = 0;
    CM_SURFACE_FORMAT   format = CM_SURFACE_FORMAT_INVALID;

    surface = nullptr;

    //Get width, height, pitch, format from mosResource
    result = GetSurfaceInfo(mosResource, width, height, pitch, format);
    if( result != CM_SUCCESS )
    {
        CM_ASSERTMESSAGE("Error: Failed to get surface info from mosResource.");
        return result;
    }

    //Sanity check
    result = Surface2DSanityCheck(width, height, format);
    if( result != CM_SUCCESS )
    {
        CM_ASSERTMESSAGE("Error: Sanity check for surface 2D failure.");
        return result;
    }

    // For 2D surface, since the real memory buffer is not allocated in CMRT@UMD, no reuse/manager can be done
    // Real reuse is controlled by the CMRT library.
    if (GetFreeSurfaceIndex(index) != CM_SUCCESS)
    {
        CM_ASSERTMESSAGE("Error: Exceed the maximum surface amount.");
        return CM_EXCEED_SURFACE_AMOUNT;
    }

    if( m_2DSurfaceCount >= m_max2DSurfaceCount )
    {
        CM_ASSERTMESSAGE("Error: Exceed the maximum surface amount.");
        return CM_EXCEED_SURFACE_AMOUNT;
    }

    result = AllocateSurface2D( width, height, format, mosResource, handle);
    if( result != CM_SUCCESS )
    {
        CM_ASSERTMESSAGE("Error: Failed to allocate surface.");
        return result;
    }

    result = CmSurface2DRT::Create( index, handle, width, height, pitch, format, createdByCm, this, surface );
    if( result != CM_SUCCESS )
    {
        FreeSurface2D( handle );
        CM_ASSERTMESSAGE("Error: Failed to create CmSurface2D.");
        return result;
    }

    m_surfaceArray[ index ] = surface;
    UpdateProfileFor2DSurface(index, width, height, format);

    return CM_SUCCESS;
 }

//*-----------------------------------------------------------------------------
//| Purpose:    Check the legality of surface's width,height and format
//| Returns:    Result of the operation.
//*-----------------------------------------------------------------------------
int32_t CmSurfaceManager::Surface2DSanityCheck(uint32_t width, uint32_t height, CM_SURFACE_FORMAT format)
{
    if( ( width < CM_MIN_SURF_WIDTH ) || ( width > CM_MAX_2D_SURF_WIDTH ) )
    {
        CM_ASSERTMESSAGE("Error: Invalid surface width.");
        return CM_INVALID_WIDTH;
    }

    if( ( height < CM_MIN_SURF_HEIGHT ) || ( height > CM_MAX_2D_SURF_HEIGHT ) )
    {
        CM_ASSERTMESSAGE("Error: Invalid surface height.");
        return CM_INVALID_HEIGHT;
    }

    switch( format )
    {
        case CM_SURFACE_FORMAT_X8R8G8B8:
        case CM_SURFACE_FORMAT_A8R8G8B8:
        case CM_SURFACE_FORMAT_A8B8G8R8:
        case CM_SURFACE_FORMAT_R32F:
        case CM_SURFACE_FORMAT_A8:
        case CM_SURFACE_FORMAT_P8:
        case CM_SURFACE_FORMAT_R8G8_SNORM:
        case CM_SURFACE_FORMAT_Y8_UNORM:
        case CM_SURFACE_FORMAT_Y16_UNORM:
        case CM_SURFACE_FORMAT_Y16_SNORM:
        case CM_SURFACE_FORMAT_A16B16G16R16:
        case CM_SURFACE_FORMAT_R10G10B10A2:
        case CM_SURFACE_FORMAT_A16B16G16R16F:
        case CM_SURFACE_FORMAT_V8U8:
        case CM_SURFACE_FORMAT_R16_FLOAT:
        case CM_SURFACE_FORMAT_L8:
        case CM_SURFACE_FORMAT_R32_SINT:
        case CM_SURFACE_FORMAT_R32_UINT:
        case CM_SURFACE_FORMAT_BUFFER_2D:
        case CM_SURFACE_FORMAT_Y216:
        case CM_SURFACE_FORMAT_Y416:
        case CM_SURFACE_FORMAT_AYUV:
        case CM_SURFACE_FORMAT_Y210:
        case CM_SURFACE_FORMAT_Y410:
        case CM_SURFACE_FORMAT_R32G32B32A32F:
        case CM_SURFACE_FORMAT_400P:
            break;

        case CM_SURFACE_FORMAT_R8_UINT:
        case CM_SURFACE_FORMAT_R16_UINT:
        case CM_SURFACE_FORMAT_L16:
            break;

        case CM_SURFACE_FORMAT_UYVY:
        case CM_SURFACE_FORMAT_YUY2:
            if( width & 0x1 )
            {
                CM_ASSERTMESSAGE("Error: Invalid surface width.");
                return CM_INVALID_WIDTH;
            }
            break;

        case CM_SURFACE_FORMAT_NV12:
            if (width & 0x1)
            {
                CM_ASSERTMESSAGE("Error: Invalid surface width.");
                return CM_INVALID_WIDTH;
            }
            break;

        case CM_SURFACE_FORMAT_P010:
        case CM_SURFACE_FORMAT_P016:
        case CM_SURFACE_FORMAT_YV12:
            if( width & 0x1 )
            {
                CM_ASSERTMESSAGE("Error: Invalid surface width.");
                return CM_INVALID_WIDTH;
            }
            if( height & 0x1 )
            {
                CM_ASSERTMESSAGE("Error: Invalid surface height.");
                return CM_INVALID_HEIGHT;
            }
            break;

        case CM_SURFACE_FORMAT_411P:
        case CM_SURFACE_FORMAT_411R:
        case CM_SURFACE_FORMAT_IMC3:
        case CM_SURFACE_FORMAT_422H:
        case CM_SURFACE_FORMAT_422V:
        case CM_SURFACE_FORMAT_444P:
        case CM_SURFACE_FORMAT_RGBP:
        case CM_SURFACE_FORMAT_BGRP:
        case CM_SURFACE_FORMAT_P208:
            if( width & 0x1 )
            {
                CM_ASSERTMESSAGE("Error: Invalid surface width.");
                return CM_INVALID_WIDTH;
            }
            if( height & 0x1 )
            {
                CM_ASSERTMESSAGE("Error: Invalid surface height.");
                return CM_INVALID_HEIGHT;
            }
            break;

        default:
            CM_ASSERTMESSAGE("Error: Unsupported surface format.");
            return CM_SURFACE_FORMAT_NOT_SUPPORTED;
    }

    return CM_SUCCESS;
}

//!
//! \brief    Get mos surface's information (width, height, pitch and format)
//! \details  This function calls mos interface pfnGetResourceInfo to get details of surface.
//! \param    [in] mosResource
//!           pointer to mos resource
//! \param    [in,out] width
//!           reference to surface's width
//! \param    [in,out] height
//!           reference to surface's height
//! \param    [in,out] pitch
//!           reference to surface's lock pitch
//! \param    [in,out] format
//!           reference to surface's format
//! \return   MOS_STATUS
//!
int32_t CmSurfaceManager::GetSurfaceInfo( MOS_RESOURCE * mosResource, uint32_t &width, uint32_t &height, uint32_t &pitch, CM_SURFACE_FORMAT &format)
{
    PCM_CONTEXT_DATA cmData = (PCM_CONTEXT_DATA)m_device->GetAccelData();
    PCM_HAL_STATE state  = cmData->cmHalState;

    MOS_SURFACE          surfaceDetails;
    MOS_ZeroMemory(&surfaceDetails, sizeof(surfaceDetails));
    surfaceDetails.Format = CM_SURFACE_FORMAT_INVALID;
    state->osInterface->pfnGetResourceInfo(state->osInterface, mosResource, &surfaceDetails);

    width    = surfaceDetails.dwWidth;
    height   = surfaceDetails.dwHeight;
    format   = surfaceDetails.Format;
    pitch    = surfaceDetails.dwLockPitch;

    return CM_SUCCESS;
}

int32_t CmSurfaceManager::UpdateSurface2D(MOS_RESOURCE * mosResource, int index, uint32_t handle)
{
    PCM_CONTEXT_DATA cmData = (PCM_CONTEXT_DATA)m_device->GetAccelData();
    PCM_HAL_STATE state = cmData->cmHalState;

    CM_SURFACE_FORMAT format;
    uint32_t width          = 0;
    uint32_t height         = 0;
    uint32_t pitch          = 0;
    int result = GetSurfaceInfo(mosResource, width, height, pitch, format);
    if( result != CM_SUCCESS )
    {
        CM_ASSERTMESSAGE("Error: Failed to get surface info from pMosResource.");
        return result;
    }

    CM_HAL_SURFACE2D_PARAM inParam;
    CmSafeMemSet( &inParam, 0, sizeof( CM_HAL_SURFACE2D_PARAM ) );
    inParam.width                  = width;
    inParam.height                 = height;
    inParam.format                 = format;
    inParam.mosResource            = mosResource;
    inParam.isAllocatedbyCmrtUmd   = false;
    inParam.handle                 = handle;

    state->pfnUpdateSurface2D(state, &inParam);

    CmSurface2DRT *surface = static_cast<CmSurface2DRT *>(m_surfaceArray[index]);

    int ret = surface->UpdateSurfaceProperty(width, height, pitch, format);

    return ret;

}

}  // namespace