Commit e3c0c465 authored by AlexandrX Konovalov's avatar AlexandrX Konovalov Committed by Oleg Nabiullin

Import IPP sources used by MJPEG SW fallback

parent f7145a6b
......@@ -104,6 +104,7 @@ if (BUILD_SAMPLES)
endif()
if (BUILD_RUNTIME)
add_subdirectory(${CMAKE_HOME_DIRECTORY}/contrib/ipp)
add_subdirectory(${CMAKE_HOME_DIRECTORY}/_studio)
endif()
......
# Copyright (c) 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.
set( MFX_ROOT "${CMAKE_HOME_DIRECTORY}/_studio/shared" )
include_directories (
${CMAKE_CURRENT_SOURCE_DIR}/include
${MFX_ROOT}/include
${MFX_ROOT}/umc/core/umc/include
)
set( SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src" )
# Optimized for processors with Intel SSE4.2
set( defs "-D_Y8 -D_ARCH_EM64T" )
set( sources "" )
file( GLOB_RECURSE srcs "${SRC_DIR}/*.c" "${SRC_DIR}/asm_intel64/*.s" )
list( APPEND sources ${srcs})
enable_language(C ASM)
set( CMAKE_ASM_SOURCE_FILE_EXTENSIONS s )
make_library( ipp none static )
// Copyright (c) 2018 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.
#ifndef __CPUDEF_H__
#define __CPUDEF_H__
#include "ippcore.h"
#if defined( __cplusplus )
extern "C" {
#endif
#undef __CDECL
#if defined( _WIN32 ) || defined ( _WIN64 )
#define __CDECL __cdecl
#else
#define __CDECL
#endif
/* Intel CPU informator */
int __CDECL mfxownGetFeature( Ipp64u MaskOfFeature );
int __CDECL mfxhas_cpuid ( void );
int __CDECL mfxis_GenuineIntel ( void );
int __CDECL mfxmax_cpuid_input( void );
#if defined( __cplusplus )
}
#endif
#endif /* __CPUDEF_H__ */
/* ////////////////////////// End of file "cpudef.h" //////////////////////// */
// Copyright (c) 2018 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.
#ifndef __DEPENDENCEIP_H__
#define __DEPENDENCEIP_H__
#if (_IPP_ARCH == _IPP_ARCH_XSC)
#ifndef _CORE
#ifndef __IPPI_H__
#include "ippi.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif
#endif /* _CORE */
#endif
#endif /* __DEPENDENCEIP_H__ */
// Copyright (c) 2018 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.
#ifndef __DEPENDENCESP_H__
#define __DEPENDENCESP_H__
#if (_IPP_ARCH == _IPP_ARCH_XSC)
#ifndef _CORE
#ifndef __IPPS_H__
#include "ipps.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif
#endif /* _CORE */
#endif
#endif /* __DEPENDENCESP_H__ */
// Copyright (c) 2018 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.
/*
// Intel(R) Integrated Performance Primitives
// Color Conversion Library (ippCC)
//
//
*/
#if !defined( __IPPCC_H__ ) || defined( _OWN_BLDPCS )
#define __IPPCC_H__
#if defined (_WIN32_WCE) && defined (_M_IX86) && defined (__stdcall)
#define _IPP_STDCALL_CDECL
#undef __stdcall
#endif
#ifndef __IPPDEFS_H__
#include "ippdefs.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* ////////////////////////////////////////////////////////////////////////////
// Name: mfxiYCbCr422_8u_P3C2R
// Purpose: Converts 422 planar image to YUY2
// Returns:
// ippStsNoErr OK
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr Width of first plain 422-image less than 2(4)
// or height equal zero
//
// Parameters:
// pSrc[3] Array of pointers to the source image planes
// srcStep[3] Array of steps through the source image planes
// pDst[3] Array of pointers to the destination image planes
// dstStep[3] Array of steps through the destination image planes
// pSrc Pointer to the source pixel-order image
// srcStep Step through the source pixel-order image
// pDst Pointer to the destination pixel-order image
// dstStep Step through the destination pixel-order image
// roiSize Size of the ROI
*/
IPPAPI (IppStatus, mfxiYCbCr422_8u_P3C2R, ( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, mfxiYCbCr420ToYCbCr422_8u_P2C2R,(const Ipp8u* pSrcY, int srcYStep,const Ipp8u* pSrcCbCr,
int srcCbCrStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, mfxiYCrCb420ToYCbCr422_8u_P3C2R,( const Ipp8u* pSrc[3],int srcStep[3], Ipp8u* pDst, int dstStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: mfxiYCbCr422_8u_C2P3R
// Purpose: Converts a YUY2 image to the P422 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2
//
// Arguments:
// pSrc pointer to the source image
// srcStep step for the source image
// pDst array of pointers to the components of the destination image
// dstStep array of steps values for every component
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width should be multiple 2.
*/
IPPAPI(IppStatus, mfxiYCbCr422_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: mfxiYCbCr422ToYCbCr420_8u_C2P3R
// Purpose: Converts a 2-channel YUY2 image to the I420(IYUV) image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 || roiSize.height < 2
//
// Arguments:
// pSrc pointer to the source image
// srcStep step for the source image
// pDst array of pointers to the components of the destination image
// dstStep array of steps values for every component
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width and roiSize.height should be multiple 2.
*/
IPPAPI(IppStatus, mfxiYCbCr422ToYCbCr420_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: mfxiYCbCr420_8u_P2P3R
// Purpose: Converts a NV12 image to the I420(IYUV) image.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 || roiSize.height < 2
//
// Arguments:
// pSrcY pointer to the source Y plane
// srcYStep step for the source Y plane
// pSrcCbCr pointer to the source CbCr plane
// srcCbCrStep step for the source CbCr plane
// pDst array of pointers to the components of the destination image
// dstStep array of steps values for every component
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width should be multiple 2.
// roiSize.height should be multiple 2.
*/
IPPAPI(IppStatus, mfxiYCbCr420_8u_P2P3R,(const Ipp8u* pSrcY,int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: mfxiCbYCr422ToYCbCr422_8u_C2P3R
// Purpose: Converts a UYVY image to the P422 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2
//
// Arguments:
// pSrc pointer to the source image
// srcStep step for the source image
// pDst array of pointers to the components of the destination image
// dstStep array of steps values for every component
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width should be multiple 2.
*/
IPPAPI(IppStatus, mfxiCbYCr422ToYCbCr422_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: mfxiYCbCr422ToYCbCr420_8u_P3R
// Purpose: Converts a P422 image to the I420(IYUV)image
// Name: mfxiYCbCr420ToYCbCr422_8u_P3R
// Purpose: Converts a IYUV image to the P422 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 || roiSize.height < 2
//
// Arguments:
// pSrc array of pointers to the components of the source image
// srcStep array of step values for every component
// pDst array of pointers to the components of the destination image
// dstStep array of steps values for every component
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width and roiSize.height should be multiple 2.
*/
IPPAPI(IppStatus, mfxiYCbCr422ToYCbCr420_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, mfxiYCbCr420ToYCbCr422_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
#ifdef __cplusplus
}
#endif
#if defined (_IPP_STDCALL_CDECL)
#undef _IPP_STDCALL_CDECL
#define __stdcall __cdecl
#endif
#endif /* __IPPCC_H__ */
// Copyright (c) 2018 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.
/*
// Intel(R) Integrated Performance Primitives
// Core (ippCore)
//
//
*/
#if !defined( __IPPCORE_H__ ) || defined( _OWN_BLDPCS )
#define __IPPCORE_H__
#if defined (_WIN32_WCE) && defined (_M_IX86) && defined (__stdcall)
#define _IPP_STDCALL_CDECL
#undef __stdcall
#endif
#ifndef __IPPDEFS_H__
#include "ippdefs.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
ippAffinityCompactFineCore, /* KMP_AFFINITY=granularity=fine,compact,n,offset, where n - level */
ippAffinityCompactFineHT, /* KMP_AFFINITY=granularity=fine,compact,0,offset */
ippAffinityAllEnabled, /* KMP_AFFINITY=respect */
ippAffinityRestore,
ippTstAffinityCompactFineCore, /* test mode for affinity type ippAffinityCompactFineCore */
ippTstAffinityCompactFineHT /* test mode for affinity type ippAffinityCompactFineHT */
} IppAffinityType;
/* /////////////////////////////////////////////////////////////////////////////
// Functions to allocate and free memory
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippMalloc
// Purpose: 64-byte aligned memory allocation
// Parameter:
// len number of bytes
// Returns: pointer to allocated memory
//
// Notes: the memory allocated by ippMalloc has to be free by ippFree
// function only.
*/
IPPAPI( void*, mfxMalloc, (int length) )
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippFree
// Purpose: free memory allocated by the ippMalloc function
// Parameter:
// ptr pointer to the memory allocated by the ippMalloc function
//
// Notes: use the function to free memory allocated by ippMalloc
*/
IPPAPI( void, mfxFree, (void* ptr) )
/* ////////////////////////////////////////////////////////////////////////////
// Name: mfxGetMaxCacheSizeB
//
// Purpose: Detects maximal from the sizes of L2 or L3 in bytes
//
// Return:
// ippStsNullPtrErr The result's pointer is NULL.
// ippStsNotSupportedCpu The cpu is not supported.
// ippStsUnknownCacheSize The cpu is supported, but the size of the cache is unknown.
// ippStsNoErr Ok
//
// Arguments:
// pSizeByte Pointer to the result
//
// Note:
// 1). Intel(R) processors are supported only.
// 2). Intel(R) Itanium(R) processors and platforms with Intel XScale(R) technology are unsupported
// 3). For unsupported processors the result is "0",
// and the return status is "ippStsNotSupportedCpu".
// 4). For supported processors the result is "0",
// and the return status is "ippStsUnknownCacheSize".
// if sizes of the cache is unknown.
//
*/
IPPAPI( IppStatus, mfxGetMaxCacheSizeB, ( int* pSizeByte ) )
#ifdef __cplusplus
}
#endif
#endif /* __IPPCORE_H__ */
This diff is collapsed.
// Copyright (c) 2018 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.
/*
// Intel(R) Integrated Performance Primitives
// Image Processing
//
//
*/
#if !defined( __IPPI_H__ ) || defined( _OWN_BLDPCS )
#define __IPPI_H__
#if defined (_WIN32_WCE) && defined (_M_IX86) && defined (__stdcall)
#define _IPP_STDCALL_CDECL
#undef __stdcall
#endif
#ifndef __IPPDEFS_H__
#include "ippdefs.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* ////////////////////////////////////////////////////////////////////////////
// Name: mfxiCopy
//
// Purpose: copy pixel values from the source image to the destination image
//
//
// Returns:
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr OK
//
// Parameters:
// pSrc Pointer to the source image buffer
// srcStep Step in bytes through the source image buffer
// pDst Pointer to the destination image buffer
// dstStep Step in bytes through the destination image buffer
// roiSize Size of the ROI
// pMask Pointer to the mask image buffer
// maskStep Step in bytes through the mask image buffer
*/
IPPAPI ( IppStatus, mfxiCopy_8u_C1R,
( const Ipp8u* pSrc, int srcStep,
Ipp8u* pDst, int dstStep,IppiSize roiSize ))
IPPAPI ( IppStatus, mfxiCopy_16s_C1R,
( const Ipp16s* pSrc, int srcStep,
Ipp16s* pDst, int dstStep,IppiSize roiSize ))
IPPAPI ( IppStatus, mfxiCopy_8u_C3P3R, ( const Ipp8u* pSrc, int srcStep,
Ipp8u* const pDst[3], int dstStep, IppiSize roiSize ))
IPPAPI ( IppStatus, mfxiCopy_8u_C4P4R, ( const Ipp8u* pSrc, int srcStep,
Ipp8u* const pDst[4], int dstStep, IppiSize roiSize ))
IPPAPI ( IppStatus, mfxiCopy_16s_C3P3R, ( const Ipp16s* pSrc, int srcStep,
Ipp16s* const pDst[3], int dstStep, IppiSize roiSize ))
IPPAPI ( IppStatus, mfxiCopy_16s_C4P4R, ( const Ipp16s* pSrc, int srcStep,
Ipp16s* const pDst[4], int dstStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: mfxiConvert
//
// Purpose: Converts pixel values of an image from one bit depth to another
//
// Returns:
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsStepErr srcStep or dstStep has zero or negative value
// ippStsNoErr OK
//
// Parameters:
// pSrc Pointer to the source image
// srcStep Step through the source image
// pDst Pointer to the destination image
// dstStep Step in bytes through the destination image
// roiSize Size of the ROI
// roundMode Rounding mode, ippRndZero or ippRndNear
*/
IPPAPI ( IppStatus, mfxiConvert_8u16u_C1R,
(const Ipp8u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
IppiSize roiSize ))
IPPAPI ( IppStatus, mfxiConvert_16u8u_C1R,
( const Ipp16u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
IppiSize roiSize ))
/* /////////////////////////////////////////////////////////////////////////////////////////////////
// Logical Operations and Shift Functions
///////////////////////////////////////////////////////////////////////////////////////////////// */
/*
// Names: mfxiAndC
// Purpose: Performs corresponding bitwise logical operation between pixels of two image
// (AndC/OrC/XorC - between pixel of the source image and a constant)
//
// Names: mfxiLShiftC, mfxiRShiftC
// Purpose: Shifts bits in each pixel value to the left and right
// Parameters:
// value 1) The constant value to be ANDed/ORed/XORed with each pixel of the source,
// constant vector for multi-channel images;
// 2) The number of bits to shift, constant vector for multi-channel images.
// pSrc Pointer to the source image
// srcStep Step through the source image
// pSrcDst Pointer to the source/destination image (in-place flavors)
// srcDstStep Step through the source/destination image (in-place flavors)
// pSrc1 Pointer to first source image
// src1Step Step through first source image
// pSrc2 Pointer to second source image
// src2Step Step through second source image
// pDst Pointer to the destination image
// dstStep Step in destination image
// roiSize Size of the ROI
//
// Returns:
// ippStsNullPtrErr One of the pointers is NULL
// ippStsStepErr One of the step values is less than or equal to zero
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsShiftErr Shift's value is less than zero
// ippStsNoErr No errors
*/
IPPAPI(IppStatus, mfxiAndC_16u_C1IR, (Ipp16u value, Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// mfxiZigzagInv8x8_16s_C1
//
// Purpose:
// Converts a natural order to zigzag in an 8x8 block (forward function),
// converts a zigzag order to natural in a 8x8 block (inverse function)
//
// Parameter:
// pSrc Pointer to the source block
// pDst Pointer to the destination block
//
// Returns:
// ippStsNoErr No errors
// ippStsNullPtrErr One of the pointers is NULL
//
*/
IPPAPI(IppStatus, mfxiZigzagInv8x8_16s_C1,(const Ipp16s* pSrc, Ipp16s* pDst))
#ifdef __cplusplus
}
#endif
#if defined (_IPP_STDCALL_CDECL)
#undef _IPP_STDCALL_CDECL
#define __stdcall __cdecl
#endif
#endif /* __IPPI_H__ */
This diff is collapsed.
// Copyright (c) 2018 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.
/*
// Intel(R) Integrated Performance Primitives
// Signal Processing (ippSP)
//
//
*/
#if !defined( __IPPS_H__ ) || defined( _OWN_BLDPCS )