mirror of
https://github.com/mofeng-git/One-KVM.git
synced 2026-01-28 16:41:52 +08:00
250 lines
8.3 KiB
C++
250 lines
8.3 KiB
C++
//
|
|
// Notice Regarding Standards. AMD does not provide a license or sublicense to
|
|
// any Intellectual Property Rights relating to any standards, including but not
|
|
// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
|
|
// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
|
|
// (collectively, the "Media Technologies"). For clarity, you will pay any
|
|
// royalties due for such third party technologies, which may include the Media
|
|
// Technologies that are owed as a result of AMD providing the Software to you.
|
|
//
|
|
// MIT license
|
|
//
|
|
// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
|
|
//
|
|
// 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.
|
|
//
|
|
|
|
#include "IOCapsImpl.h"
|
|
|
|
namespace amf
|
|
{
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
AMFIOCapsImpl::SurfaceFormat::SurfaceFormat() :
|
|
m_Format(AMF_SURFACE_UNKNOWN),
|
|
m_Native(false)
|
|
{
|
|
}
|
|
|
|
AMFIOCapsImpl::SurfaceFormat::SurfaceFormat(AMF_SURFACE_FORMAT format, amf_bool native) :
|
|
m_Format(format),
|
|
m_Native(native)
|
|
{
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
AMFIOCapsImpl::MemoryType::MemoryType() :
|
|
m_Type(AMF_MEMORY_UNKNOWN),
|
|
m_Native(false)
|
|
{
|
|
}
|
|
|
|
AMFIOCapsImpl::MemoryType::MemoryType(AMF_MEMORY_TYPE type, amf_bool native) :
|
|
m_Type(type),
|
|
m_Native(native)
|
|
{
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
AMFIOCapsImpl::AMFIOCapsImpl() :
|
|
m_MinWidth(-1),
|
|
m_MaxWidth(-1),
|
|
m_MinHeight(-1),
|
|
m_MaxHeight(-1),
|
|
m_VertAlign(-1),
|
|
m_InterlacedSupported(false)
|
|
{
|
|
}
|
|
|
|
AMFIOCapsImpl::AMFIOCapsImpl(amf_int32 minWidth, amf_int32 maxWidth,
|
|
amf_int32 minHeight, amf_int32 maxHeight,
|
|
amf_int32 vertAlign, amf_bool interlacedSupport,
|
|
amf_int32 numOfNativeFormats, const AMF_SURFACE_FORMAT* nativeFormats,
|
|
amf_int32 numOfNonNativeFormats, const AMF_SURFACE_FORMAT* nonNativeFormats,
|
|
amf_int32 numOfNativeMemTypes, const AMF_MEMORY_TYPE* nativeMemTypes,
|
|
amf_int32 numOfNonNativeMemTypes, const AMF_MEMORY_TYPE* nonNativeMemTypes)
|
|
{
|
|
m_MinWidth = minWidth;
|
|
m_MaxWidth = maxWidth;
|
|
m_MinHeight = minHeight;
|
|
m_MaxHeight = maxHeight;
|
|
m_VertAlign = vertAlign;
|
|
m_InterlacedSupported = interlacedSupport;
|
|
PopulateSurfaceFormats(numOfNativeFormats, nativeFormats, true);
|
|
PopulateSurfaceFormats(numOfNonNativeFormats, nonNativeFormats, false);
|
|
PopulateMemoryTypes(numOfNativeMemTypes, nativeMemTypes, true);
|
|
PopulateMemoryTypes(numOfNonNativeMemTypes, nonNativeMemTypes, false);
|
|
}
|
|
|
|
void AMFIOCapsImpl::PopulateSurfaceFormats(amf_int32 numOfFormats, const AMF_SURFACE_FORMAT* formats, amf_bool native)
|
|
{
|
|
if (formats != NULL)
|
|
{
|
|
for (amf_int32 i = 0; i < numOfFormats; i++)
|
|
{
|
|
bool found = false;
|
|
for(amf_size exists_idx = 0; exists_idx < m_SurfaceFormats.size(); exists_idx++)
|
|
{
|
|
if(m_SurfaceFormats[exists_idx].GetFormat() == formats[i])
|
|
{
|
|
found = true;
|
|
}
|
|
}
|
|
if(!found)
|
|
{
|
|
m_SurfaceFormats.push_back(SurfaceFormat(formats[i], native));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AMFIOCapsImpl::PopulateMemoryTypes(amf_int32 numOfTypes, const AMF_MEMORY_TYPE* memTypes, amf_bool native)
|
|
{
|
|
if (memTypes != NULL)
|
|
{
|
|
for (amf_int32 i = 0; i < numOfTypes; i++)
|
|
{
|
|
bool found = false;
|
|
for(amf_size exists_idx = 0; exists_idx < m_MemoryTypes.size(); exists_idx++)
|
|
{
|
|
if(m_MemoryTypes[exists_idx].GetType() == memTypes[i])
|
|
{
|
|
found = true;
|
|
}
|
|
}
|
|
if(!found)
|
|
{
|
|
m_MemoryTypes.push_back(MemoryType(memTypes[i], native));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get supported resolution ranges in pixels/lines:
|
|
void AMF_STD_CALL AMFIOCapsImpl::GetWidthRange(amf_int32* minWidth, amf_int32* maxWidth) const
|
|
{
|
|
if (minWidth != NULL)
|
|
{
|
|
*minWidth = m_MinWidth;
|
|
}
|
|
if (maxWidth != NULL)
|
|
{
|
|
*maxWidth = m_MaxWidth;
|
|
}
|
|
}
|
|
|
|
void AMF_STD_CALL AMFIOCapsImpl::GetHeightRange(amf_int32* minHeight, amf_int32* maxHeight) const
|
|
{
|
|
if (minHeight != NULL)
|
|
{
|
|
*minHeight = m_MinHeight;
|
|
}
|
|
if (maxHeight != NULL)
|
|
{
|
|
*maxHeight = m_MaxHeight;
|
|
}
|
|
}
|
|
|
|
// Get memory alignment in lines:
|
|
// Vertical aligmnent should be multiples of this number
|
|
amf_int32 AMF_STD_CALL AMFIOCapsImpl::GetVertAlign() const
|
|
{
|
|
return m_VertAlign;
|
|
}
|
|
|
|
// Enumerate supported surface pixel formats:
|
|
amf_int32 AMF_STD_CALL AMFIOCapsImpl::GetNumOfFormats() const
|
|
{
|
|
return (amf_int32)m_SurfaceFormats.size();
|
|
}
|
|
|
|
AMF_RESULT AMF_STD_CALL AMFIOCapsImpl::GetFormatAt(amf_int32 index, AMF_SURFACE_FORMAT* format, bool* native) const
|
|
{
|
|
if (index >= 0 && index < static_cast<amf_int32>(m_SurfaceFormats.size()))
|
|
{
|
|
SurfaceFormat curFormat(m_SurfaceFormats.at(index));
|
|
if (format != NULL)
|
|
{
|
|
*format = curFormat.GetFormat();
|
|
}
|
|
if (native != NULL)
|
|
{
|
|
*native = curFormat.IsNative();
|
|
}
|
|
return AMF_OK;
|
|
}
|
|
else
|
|
{
|
|
return AMF_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
// Enumerate supported surface formats:
|
|
amf_int32 AMF_STD_CALL AMFIOCapsImpl::GetNumOfMemoryTypes() const
|
|
{
|
|
return (amf_int32)m_MemoryTypes.size();
|
|
}
|
|
|
|
AMF_RESULT AMF_STD_CALL AMFIOCapsImpl::GetMemoryTypeAt(amf_int32 index, AMF_MEMORY_TYPE* memType, bool* native) const
|
|
{
|
|
if (index >= 0 && index < static_cast<amf_int32>(m_MemoryTypes.size()))
|
|
{
|
|
MemoryType curType(m_MemoryTypes.at(index));
|
|
if (memType != NULL)
|
|
{
|
|
*memType = curType.GetType();
|
|
}
|
|
if (native != NULL)
|
|
{
|
|
*native = curType.IsNative();
|
|
}
|
|
return AMF_OK;
|
|
}
|
|
else
|
|
{
|
|
return AMF_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
// interlaced support:
|
|
amf_bool AMF_STD_CALL AMFIOCapsImpl::IsInterlacedSupported() const
|
|
{
|
|
return m_InterlacedSupported;
|
|
}
|
|
|
|
void AMFIOCapsImpl::SetResolution(amf_int32 minWidth, amf_int32 maxWidth, amf_int32 minHeight, amf_int32 maxHeight)
|
|
{
|
|
m_MinWidth = minWidth;
|
|
m_MaxWidth = maxWidth;
|
|
m_MinHeight = minHeight;
|
|
m_MaxHeight = maxHeight;
|
|
}
|
|
|
|
void AMFIOCapsImpl::SetVertAlign(amf_int32 vertAlign)
|
|
{
|
|
m_VertAlign = vertAlign;
|
|
}
|
|
|
|
void AMFIOCapsImpl::SetInterlacedSupport(amf_bool interlaced)
|
|
{
|
|
m_InterlacedSupported = interlaced;
|
|
}
|
|
|
|
} |