amy/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-12 14:41:00 -05:00
Code Issues 1 Projects Releases Packages Wiki Activity Actions
winamp/Src/external_dependencies/intel_ipp_6.1.1.035/em64t/include/ippcc.h
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

3024 lines
169 KiB
C
Raw Blame History

/* /////////////////////////////////////////////////////////////////////////////
//
// INTEL CORPORATION PROPRIETARY INFORMATION
// This software is supplied under the terms of a license agreement or
// nondisclosure agreement with Intel Corporation and may not be copied
// or disclosed except in accordance with the terms of that agreement.
// Copyright(c) 2005-2009 Intel Corporation. All Rights Reserved.
//
//
// Intel(R) 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
#if !defined( _OWN_BLDPCS )
typedef enum {
ippDitherNone,
ippDitherFS,
ippDitherJJN,
ippDitherStucki,
ippDitherBayer
} IppiDitherType;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Functions declarations
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippccGetLibVersion
// Purpose: getting of the library version
// Returns: the structure of information about version
// of ippCC library
// Parameters:
//
// Notes: not necessary to release the returned structure
*/
IPPAPI( const IppLibraryVersion*, ippccGetLibVersion, (void) )
/* /////////////////////////////////////////////////////////////////////////////
// Color Space Conversion Functions
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiCbYCr422ToBGR_709HDTV_8u_C2C3R
// Purpose: Converts a UYVY image to the BGR24 image
// Name: ippiCbYCr422ToBGR_709HDTV_8u_C2C4R
// Purpose: Converts a UYVY image to the BGRA image
// Name: ippiBGRToCbYCr422_709HDTV_8u_C3C2R
// Purpose: Converts a BGR24 image to the UYVY image
// Name: ippiBGRToCbYCr422_709HDTV_8u_AC4C2R
// Purpose: Converts a BGRA image to the UYVY image
// Name: ippiYCbCr420ToBGR_709HDTV_8u_P3C4R
// Purpose: Converts a I420(IYUV) image to the BGRA image
// Name: ippiBGRToYCbCr420_709HDTV_8u_AC4P3R
// Purpose: Converts a BGRA image to the I420(IYUV) image
// Parameters:
// pSrc Pointer to the source image (for pixel-order data).An array of
// pointers to separate source color planes (for plane-order data)
// pDst Pointer to the destination image (for pixel-order data).An array
// of pointers to separate destination color planes (for plane-order data)
// roiSize Size of source and destination ROI in pixels
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsSizeErr roiSize has field with zero or negative value
// ippStsNoErr No errors
// Reference:
// Jack Keith
// Video Demystified: A Handbook for the Digital Engineer, 2nd ed.
// 1996.pp.(42-43)
// YCbCr <> RGB ITU_R BT.709 (HDTV) where R'G'B' has a range of 16-235
// Y has a range of 16 - 235. Cb,Cr have a range of 16 - 240
// Y = 0.2126*R' + 0.7152*G' + 0.0722*B'
// Cb = -0.117*R' - 0.394*G' + 0.511 * B' + 128
// Cr = 0.511*R' - 0.464*G' - 0.047 * B' + 128
// Cb = 0.5389 (B' - Y )
// Cr = 0.6350 (R' - Y )
// Digital representation.
// Quantization level assignment:
// - Video data: 1 through 254
// - Timing reference: 0 and 255
// R' = Y + 1.540*(Cr - 128 )
// G' = Y - 0.459*(Cr - 128 ) - 0.183*( Cb - 128 )
// B' = Y + 1.816*(Cb - 128)
*/
IPPAPI(IppStatus, ippiCbYCr422ToBGR_709HDTV_8u_C2C3R,(const Ipp8u* pSrc,int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiCbYCr422ToBGR_709HDTV_8u_C2C4R,(const Ipp8u* pSrc,int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp8u aval ))
IPPAPI(IppStatus, ippiBGRToCbYCr422_709HDTV_8u_C3C2R,(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiBGRToCbYCr422_709HDTV_8u_AC4C2R,(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToBGR_709HDTV_8u_P3C4R, (const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst , int dstStep , IppiSize roiSize, Ipp8u aval))
IPPAPI(IppStatus, ippiBGRToYCbCr420_709HDTV_8u_AC4P3R,(const Ipp8u* pSrc , int srcStep , Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Parameters:
// pSrc Pointer to the source image (for pixel-order data).An array of
// pointers to separate source color planes (for plane-order data)
// pDst Pointer to the destination image (for pixel-order data).An array
// of pointers to separate destination color planes (for plane-order data)
// roiSize Size of source and destination ROI in pixels
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsSizeErr roiSize has field with zero or negative value
// ippStsNoErr No errors
// Reference:
// Jack Keith
// Video Demystified: A Handbook for the Digital Engineer, 2nd ed.
// 1996.pp.(42-43)
// YCbCr <> RGB ITU_R BT.709 (Computer System Considerations) where R'G'B' has a range of 0-255
// Y = 0.183*R' + 0.614*G' + 0.062*B' + 16
// Cb = -0.101*R' - 0.338*G' + 0.439*B' + 128
// Cr = 0.439*R' - 0.399*G' - 0.040*B' + 128
// R' = 1.164*(Y - 16) + 1.793*(Cr - 128 )
// G' = 1.164*(Y - 16) - 0.534*(Cr - 128 )- 0.213*( Cb - 128 )
// B' = 1.164*(Y - 16) + 2.115*(Cb - 128 )
*/
IPPAPI(IppStatus, ippiBGRToYCbCr420_709CSC_8u_AC4P3R,(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGRToYCrCb420_709CSC_8u_AC4P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGRToYCbCr420_709CSC_8u_C3P3R,(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGRToYCrCb420_709CSC_8u_C3P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCbCr420ToBGR_709CSC_8u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR_709CSC_8u_P3C3R,( const Ipp8u* pSrc[3],int srcStep,Ipp8u* pDst,int dstStep,IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCbCrToBGR_709CSC_8u_P3C4R,( const Ipp8u* pSrc[3],int srcStep,Ipp8u* pDst,int dstStep,IppiSize roiSize, Ipp8u aval))
/* /////////////////////////////////////////////////////////////////////////////
// Names:
// ippiBGRToCbYCr422_8u_AC4C2R, ippiCbYCr422ToBGR_8u_C2C4R,
// ippiYCbCr411ToBGR_8u_P3C3R
// ippiYCbCr411ToBGR_8u_P3C4R
//
// ippiRGBToCbYCr422_8u_C3C2R, ippiCbYCr422ToRGB_8u_C2C3R,
// ippiRGBToCbYCr422Gamma_8u_C3C2R,
// ippiYCbCr422ToRGB_8u_P3C3R
//
// ippiRGBToYCbCr422_8u_C3C2R, ippiYCbCr422ToRGB_8u_C2C3R,
// ippiRGBToYCbCr422_8u_P3C2R, ippiYCbCr422ToRGB_8u_C2P3R,
//
// ippiRGBToYCbCr420_8u_C3P3R, ippiYCbCr420ToRGB_8u_P3C3R,
// ippiYCbCr420ToBGR_8u_P3C3R,
//
// ippiYCbCr422ToRGB565_8u16u_C2C3R, ippiYCbCr422ToBGR565_8u16u_C2C3R,
// ippiYCbCr422ToRGB555_8u16u_C2C3R, ippiYCbCr422ToBGR555_8u16u_C2C3R,
// ippiYCbCr422ToRGB444_8u16u_C2C3R, ippiYCbCr422ToBGR444_8u16u_C2C3R,
//
// ippiYCbCrToRGB565_8u16u_P3C3R, ippiYCbCrToBGR565_8u16u_P3C3R,
// ippiYCbCrToRGB444_8u16u_P3C3R, ippiYCbCrToBGR444_8u16u_P3C3R,
// ippiYCbCrToRGB555_8u16u_P3C3R, ippiYCbCrToBGR555_8u16u_P3C3R,
//
// ippiYCbCr420ToRGB565_8u16u_P3C3R, ippiYCbCr420ToBGR565_8u16u_P3C3R
// ippiYCbCr420ToRGB555_8u16u_P3C3R, ippiYCbCr420ToBGR555_8u16u_P3C3R,
// ippiYCbCr420ToRGB444_8u16u_P3C3R, ippiYCbCr420ToBGR444_8u16u_P3C3R,
//
// ippiYCbCr422ToRGB565_8u16u_P3C3R, ippiYCbCr422ToBGR565_8u16u_P3C3R,
// ippiYCbCr422ToRGB555_8u16u_P3C3R, ippiYCbCr422ToBGR555_8u16u_P3C3R,
// ippiYCbCr422ToRGB444_8u16u_P3C3R, ippiYCbCr422ToBGR444_8u16u_P3C3R,
//
// ippiRGBToYCrCb422_8u_C3C2R, ippiYCrCb422ToRGB_8u_C2C3R,
// ippiRGBToYCrCb422_8u_P3C2R, ippiYCrCb422ToRGB_8u_C2P3R,
//
//
// Purpose: Converts an RGB(BGR) image to the YCbCr (CbYCr, YCrCb) image and vice versa.
// Parameters:
// pSrc Pointer to the source image (for pixel-order data).An array of
// pointers to separate source color planes (for plane-order data)
// pDst Pointer to the destination image (for pixel-order data).An array
of pointers to separate destination color planes (for plane-order data)
// roiSize Size of source and destination ROI in pixels
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsSizeErr roiSize has field with zero or negative value
// ippStsNoErr No errors
// Reference:
// Jack Keith
// Video Demystified: A Handbook for the Digital Engineer, 2nd ed.
// 1996.pp.(42-43)
//
// The YCbCr color space was developed as part of Recommendation ITU-R BT.601
// (formerly CCI 601). Y is defined to have a nominal range of 16 to 235;
// Cb and Cr are defined to have a range of 16 to 240, with 128 equal to zero.
// The function ippiRGBToYCbCr422_8u_P3C2R uses 4:2:2 sampling format. For every
// two horizontal Y samples, there is one Cb and Cr sample.
// Each pixel in the input RGB image is of 24 bit depth. Each pixel in the
// output YCbCr image is of 16 bit depth.
// Sequence of samples in the YCbCr422 image is
// Y0Cb0Y1Cr0,Y2Cb1Y3Cr1,...
// Sequence of samples in the CbYCr422 image is:
// Cb0Y0CrY1,Cb1Y2Cr1Y3,...
// All functions operate on the gamma-corrected RGB (R'G'B') images
// (except ippiRGBToCbYCrGamma_8u_C3C2R, see below) with pixel values
// in the range 0 .. 255, as is commonly found in computer system.
// Conversion is performed according to the following equations:
//
// Y = 0.257*R' + 0.504*G' + 0.098*B' + 16
// Cb = -0.148*R' - 0.291*G' + 0.439*B' + 128
// Cr = 0.439*R' - 0.368*G' - 0.071*B' + 128
//
// R' = 1.164*(Y - 16) + 1.596*(Cr - 128 )
// G' = 1.164*(Y - 16) - 0.813*(Cr - 128 )- 0.392*( Cb - 128 )
// B' = 1.164*(Y - 16) + 2.017*(Cb - 128 )
//
// Note that for the YCbCr-to-RGB equations, the RGB values must be saturated
// at the 0 and 255 levels due to occasional excursions outside the nominal
// YCbCr ranges.
// ippiRGBToCbYCr422Gamma_8u_C3C2R function additionally performs gamma-correction, there is
// sample down filter(1/4,1/2,1/4).
*/
IPPAPI(IppStatus, ippiCbYCr422ToBGR_8u_C2C4R,(const Ipp8u* pSrc, int srcStep,
Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp8u aval))
IPPAPI(IppStatus, ippiBGRToCbYCr422_8u_AC4C2R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr411ToBGR_8u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp8u* pDst,
int dstStep, IppiSize roiSize))
IPPAPI(IppStatus,ippiYCbCr411ToBGR_8u_P3C4R,(const Ipp8u* pSrc[3],int srcStep[3],
Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp8u aval))
IPPAPI(IppStatus, ippiCbYCr422ToRGB_8u_C2C3R,(const Ipp8u* pSrc, int srcStep,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToCbYCr422Gamma_8u_C3C2R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToCbYCr422_8u_C3C2R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB_8u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCbCr422_8u_C3C2R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB_8u_C2C3R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCbCr422_8u_P3C2R,(const Ipp8u* pSrc[3], int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB_8u_C2P3R,(const Ipp8u* pSrc, int srcStep,
Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToBGR_8u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToRGB_8u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCbCr420_8u_C3P3R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst[3],int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB565_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR565_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB555_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR555_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB444_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR444_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR565_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB565_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR444_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB444_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR555_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB555_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToBGR565_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToRGB565_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToBGR555_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToRGB555_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToBGR444_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToRGB444_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR565_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB565_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR555_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB555_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR444_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB444_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCrCb422_8u_C3C2R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCrCb422ToRGB_8u_C2C3R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCrCb422_8u_P3C2R,(const Ipp8u* pSrc[3], int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCrCb422ToRGB_8u_C2P3R,(const Ipp8u* pSrc, int srcStep,
Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCrToBGR(RGB)565(555,444)Dither_8u16u_C3R
// ippiYCbCrToBGR(RGB)565(555,444)Dither_8u16u_P3C3R
// ippiYCbCr422ToBGR(RGB)565(555,444)Dither_8u16u_P3C3R
// ippiYCbCr420ToBGR(RGB)565(555,444)Dither_8u16u_P3C3R
// ippiYUV420ToBGR(RGB)565(555,444)Dither_8u16u_P3C3R
// Purpose:
// Converts a YCbCr(YUV) image to the 16-bit per pixel BGR(RGB) image with dithering.
// Parameters:
// pSrc Pointer to the source image (for pixel-order data).An array of pointers
// to separate source color planes (for plane-order data)
// pDst Pointer to the destination image (for pixel-order data).An array of pointers
// to separate destination color planes (for plane-order data)
// roiSize Size of the source and destination ROI in pixels.
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
// After color conversion bit reduction is performed using Bayer's dithering algorithm
*/
IPPAPI(IppStatus, ippiYCbCrToBGR565Dither_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB565Dither_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR555Dither_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB555Dither_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR444Dither_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB444Dither_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR565Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB565Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR555Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB555Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR444Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB444Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToBGR565Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToRGB565Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToBGR555Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToRGB555Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToBGR444Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToRGB444Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR565Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB565Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR555Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB555Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR444Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB444Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB555Dither_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR555Dither_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB565Dither_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR565Dither_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToRGB444Dither_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR444Dither_8u16u_C2C3R,(const Ipp8u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToBGR444Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToRGB444Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToBGR555Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToRGB555Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToBGR565Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToRGB565Dither_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiBGR565ToYUV420_16u8u_C3P3R/ippiBGR555ToYUV420_16u8u_C3P3R
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 0
// Arguments:
// pSrc Pointer to the source image
// srcStep Step through the source image
// pDst An array of pointers to separate destination color planes.
// dstStep An array of step in bytes through the destination planes
// roiSize region of interest to be processed, in pixels
*/
IPPAPI(IppStatus, ippiBGR565ToYUV420_16u8u_C3P3R,( const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGR555ToYUV420_16u8u_C3P3R,( const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToBGR_8u_C2C4R / ippiYCbCr422ToBGR_8u_C2C3R
// Purpose: Converts a YUY2 image to the BGRA / RGB24 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 1
//
// Arguments:
// pSrc pointer to the source image
// srcStep step for the source image
// pDst pointer to the destination image
// dstStep step for the destination image
// roiSize region of interest to be processed, in pixels
*/
IPPAPI(IppStatus, ippiYCbCr422ToBGR_8u_C2C4R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst,int dstStep, IppiSize roiSize, Ipp8u aval ))
IPPAPI(IppStatus, ippiYCbCr422ToBGR_8u_C2C3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst,int dstStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCrToBGR_8u_P3C4R / ippiYCbCrToBGR_8u_P3C3R
// Purpose: Converts a P444 image to the BGRA / RGB24 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4 or if roiSize.height < 1
// Arguments:
// pSrc array of pointers to the components of the source image
// srcStep array of step values for every component
// pDst pointer to the destination image
// dstStep step for the destination image
// roiSize region of interest to be processed, in pixels
*/
IPPAPI(IppStatus, ippiYCbCrToBGR_8u_P3C4R,( const Ipp8u* pSrc[3],int srcStep,Ipp8u* pDst,int dstStep,IppiSize roiSize, Ipp8u aval ))
IPPAPI(IppStatus, ippiYCbCrToBGR_8u_P3C3R,( const Ipp8u* pSrc[3],int srcStep,Ipp8u* pDst,int dstStep,IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr411ToBGR565_8u16u_P3C3R / ippiYCbCr411ToBGR555_8u16u_P3C3R
// Purpose: Converts a P411 image to the RGB565 / RGB555 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4 or if roiSize.height < 1
// Arguments:
// pSrc array of pointers to the components of the source image
// srcStep array of step values for every component
// pDst pointer to the destination image
// dstStep step for the destination image
// roiSize region of interest to be processed, in pixels
*/
IPPAPI(IppStatus, ippiYCbCr411ToBGR565_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst,int dstStep,IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCbCr411ToBGR555_8u16u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp16u* pDst,int dstStep,IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiBGRToYCbCr411_8u_C3P3R/ippiBGRToYCbCr411_8u_AC4P3R/ippiBGR565ToYCbCr411_16u8u_C3P3R/ippiBGR555ToYCbCr411_16u8u_C3P3R
// Purpose: Converts a RGB24/RGBA/RGB565/RGB565 image to the P411 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4 or if roiSize.height < 1
// Arguments:
// pSrc Pointer to the source image
// srcStep Step through the source image
// pDst An array of pointers to separate destination color planes.
// dstStep An array of step in bytes through the destination planes
// roiSize region of interest to be processed, in pixels
*/
IPPAPI(IppStatus, ippiBGRToYCbCr411_8u_C3P3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGRToYCbCr411_8u_AC4P3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGR565ToYCbCr411_16u8u_C3P3R,(const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGR555ToYCbCr411_16u8u_C3P3R,(const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiBGRToYCbCr422_8u_C3P3R/ippiBGRToYCbCr422_8u_AC4P3R/ippiBGR565ToYCbCr422_16u8u_C3P3R/ippiBGR555ToYCbCr422_16u8u_C3P3R
// Purpose: Converts a RGB24/RGBA/RGB565/RGB565 image to the P422 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 1
// Arguments:
// pSrc Pointer to the source image
// srcStep Step through the source image
// pDst An array of pointers to separate destination color planes.
// dstStep An array of step in bytes through the destination planes
// roiSize region of interest to be processed, in pixels
*/
IPPAPI(IppStatus, ippiBGRToYCbCr422_8u_C3P3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiBGRToYCbCr422_8u_AC4P3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiBGR565ToYCbCr422_16u8u_C3P3R,(const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiBGR555ToYCbCr422_16u8u_C3P3R,(const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiBGRToYCbCr420_8u_C3P3R/ippiBGRToYCbCr420_8u_AC4P3R/ippiBGR565ToYCbCr420_16u8u_C3P3R/ippiBGR555ToYCbCr420_16u8u_C3P3R
// Purpose: Converts a RGB24/RGBA/RGB565/RGB565 image to the IYUV image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 0
// Arguments:
// pSrc Pointer to the source image
// srcStep Step through the source image
// pDst An array of pointers to separate destination color planes.
// dstStep An array of step in bytes through the destination planes
// roiSize region of interest to be processed, in pixels
*/
IPPAPI(IppStatus, ippiBGRToYCbCr420_8u_C3P3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGRToYCbCr420_8u_AC4P3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGR565ToYCbCr420_16u8u_C3P3R,(const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGR555ToYCbCr420_16u8u_C3P3R,(const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiBGRToYCbCr422_8u_C3C2R/ippiBGRToYCbCr422_8u_AC4C2R/ippiBGR555ToYCbCr422_16u8u_C3C2R/ippiBGR565ToYCbCr422_16u8u_C3C2R
// Purpose: Converts a RGB24/RGBA/RGB565/RGB565 image to the YUY2 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 1
// Arguments:
// pSrc Pointer to the source image
// srcStep Step through the source image
// pDst An array of pointers to separate destination color planes.
// dstStep An array of step in bytes through the destination planes
// roiSize region of interest to be processed, in pixels
*/
IPPAPI(IppStatus, ippiBGRToYCbCr422_8u_C3C2R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGRToYCbCr422_8u_AC4C2R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGR555ToYCbCr422_16u8u_C3C2R,( const Ipp16u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGR565ToYCbCr422_16u8u_C3C2R,( const Ipp16u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiBGRToYCrCb420_8u_C3P3R/ippiBGRToYCrCb420_8u_AC4P3R/ippiBGR555ToYCrCb420_16u8u_C3P3R/ippiBGR565ToYCrCb420_16u8u_C3P3R
// Purpose: Converts a RGB24/RGBA/RGB565/RGB565 image to the YV12 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 2
// Arguments:
// pSrc Pointer to the source image
// srcStep Step through the source image
// pDst An array of pointers to separate destination color planes.
// dstStep An array of step in bytes through the destination planes
// roiSize region of interest to be processed, in pixels
*/
IPPAPI(IppStatus, ippiBGRToYCrCb420_8u_C3P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGRToYCrCb420_8u_AC4P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGR555ToYCrCb420_16u8u_C3P3R,( const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGR565ToYCrCb420_16u8u_C3P3R,( const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToYCrCb420_8u_AC4P3R
// Purpose: Converts a RGBA image to the YV12 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsDoubleSize Indicates a warning if roiSize is not a multiple of 2.
// Arguments:
// pSrc Pointer to the source image ROI.
// srcStep Distance in bytes between starts of consecutive lines in the source image.
// pDst An array of pointers to ROI in the separate planes of the destination image.
// dstStep Distance in bytes between starts of consecutive lines in the destination image.
// roiSize Size of the source and destination ROI in pixels.
*/
IPPAPI(IppStatus, ippiRGBToYCrCb420_8u_AC4P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCrCb420ToRGB_8u_P3C4R and ippiYCbCr420ToBGR_8u_P3C4R
// Purpose: Converts a YV12 image to the a RGBA image and converts a IYUV image to the a BGRA
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsDoubleSize Indicates a warning if roiSize is not a multiple of 2.
// Arguments:
// pSrc An array of pointers to ROI in separate planes of the source image.
// srcStep An array of distances in bytes between starts of consecutive lines in the source image planes.
// pDst Pointer to the destination image ROI.
// dstStep Distance in bytes between starts of consecutive lines in the destination image.
// roiSize Size of the source and destination ROI in pixels.
// aval Constant value to create the fourth channel.
*/
IPPAPI(IppStatus, ippiYCbCr420ToBGR_8u_P3C4R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp8u aval))
IPPAPI(IppStatus, ippiYCrCb420ToRGB_8u_P3C4R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp8u aval ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToYCbCr_8u_AC4P3R and ippiRGBToYCbCr_8u_C3P3R
// Purpose: Converts a RGBA and RGB image to the YUV 4:4:4 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// Arguments:
// pSrc Pointer to the source image ROI for pixel-order image. An array of pointers to ROI in each separate source color planes for planar images.
// srcStep Distance in bytes between starts of consecutive lines in the source image.
// pDst Pointer to the destination image ROI. An array of pointers to ROI in the separate destination color planes for planar images.
// dstStep Distance in bytes between starts of consecutive lines in the destination image.
// roiSize Size of the source and destination ROI in pixels.
*/
IPPAPI(IppStatus, ippiRGBToYCbCr_8u_AC4P3R,( const Ipp8u* pSrc , int srcStep, Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCbCr_8u_C3P3R,( const Ipp8u* pSrc , int srcStep, Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCrToRGB_8u_P3C4R
// Purpose: Converts a YUV 4:4:4 image to the a RGBA image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// Arguments:
// pSrc An array of pointers to ROI in each separate source color planes.
// srcStep Distance in bytes between starts of consecutive lines in the source image.
// pDst Pointer to the destination image ROI.
// dstStep Distance in bytes between starts of consecutive lines in the destination image.
// roiSize Size of the source and destination ROI in pixels.
// aval Constant value to create the fourth channel.
*/
IPPAPI(IppStatus, ippiYCbCrToRGB_8u_P3C4R,( const Ipp8u* pSrc[3], int srcStep, Ipp8u* pDst , int dstStep, IppiSize roiSize, Ipp8u aval ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422_8u_P3C2R, ippiYCbCr422_8u_C2P3R
//
// Purpose: Converts 422 planar image to 2-channel pixel-order
// image and vice versa.
//
// 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, ippiYCbCr422_8u_P3C2R, ( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst, int dstStep, IppiSize roiSize))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCrCb420ToBGR_Filter_8u_P3C4R
// Purpose: Converts a YV12 image to the RGB32 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 2
// ippStsDoubleSize sizes of image is not multiples of 2
// Arguments:
// pDst Pointer to the destination image
// dstStep Step through the destination image
// pSrc An array of pointers to separate source color planes.
// srcStep An array of step in bytes through the source planes
// roiSize Region of interest to be processed, in pixels
// aval Constant value to create the fourth channel.
*/
IPPAPI(IppStatus, ippiYCrCb420ToBGR_Filter_8u_P3C4R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst, int dstStep, IppiSize roiSize, Ipp8u aval ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiJoin420_8u_P2C2R, ippiJoin420_Filter_8u_P2C2R
//
// Purpose: Converts 420 two-plane image to 2-channel pixel-order image,
// ippiJoin420_Filter additionally performs deinterlace filtering NV12 to YUY2
//
// Returns:
// ippStsNoErr OK
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field with zero or negative value
//
// Parameters:
// pSrcY Pointer to the source image Y plane.
// srcYStep Step through the source image Y plane.
// pSrcCbCr Pointer to the source image interleaved chrominance plane.
// srcCbCrStep Step through the source image CbCr plane.
// pDst Pointer to the destination image
// dstStep Step through the destination image
// roiSize Size of the ROI, height and width should be multiple of 2.
// layout Slice layout (for deinterlace filter).
// Possible values:
// IPP_UPPER - the first slice.
// IPP_CENTER - the middle slices.
// IPP_LOWER - the last slice.
// IPP_LOWER && IPP_UPPER && IPP_CENTER - image is not sliced.
// Notes:
// Source 4:2:0 two-plane image format ( NV12 ):
// all Y (pSrcY) samples are found first in memory as an array of
// unsigned char with an even number of lines memory alignment),
// followed immediately by an array(pSrcCbCr) of unsigned char
// containing interleaved U and V samples (such that if addressed as a little-endian
// WORD type, U would be in the LSBs and V would be in the MSBs).
//
// Sequence of samples in the destination 4:2:2 pixel-order two-channel image (YUY2):
// Y0U0Y1V0,Y2U1Y3V1,...
//
// The function ippiJoin420_Filter_8u_P2C2R usually operates on the sliced images
// ( the height of slices should be a multiple of 16).
//
*/
IPPAPI(IppStatus, ippiYCbCr420ToYCbCr422_8u_P2C2R,(const Ipp8u* pSrcY, int srcYStep,const Ipp8u* pSrcCbCr,
int srcCbCrStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToYCbCr422_Filter_8u_P2C2R,(const Ipp8u* pSrcY, int srcYStep,const Ipp8u* pSrcCbCr,
int srcCbCrStep, Ipp8u* pDst, int dstStep, IppiSize roiSize,int layout))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiSplit420_8u_P2P3R, ippiSplit420_Filter_8u_P2P3R
//
// Purpose: Converts NV12 two-plane image to YV12 three-plane image.
//
// Returns:
// ippStsNoErr OK
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field with zero or negative value
//
// Parameters:
// pSrcY Pointer to the source image Y plane.
// srcYStepY Step through the source image Y plane.
// pSrcCbCr Pointer to the source image CbCr plane.
// srcCbCrStep Step through the source image CbCr plane.
// pDst[3] Array of pointers to the destination image planes
// dstStep[3] Array of steps through the destination image planes
// roiSize Size of the ROI, should be multiple of 2.
// layout Slice layout (for deinterlace filter).
// Possible values:
// IPP_UPPER - the first slice.
// IPP_CENTER - the middle slices.
// IPP_LOWER - the last slice.
// IPP_LOWER && IPP_UPPER && IPP_CENTER - image is not sliced.
// Notes:
// Source 4:2:0 two-plane image format (NV12):
// all Y (pSrcY) samples are found first in memory as an array of
// unsigned char with an even number of lines memory alignment),
// followed immediately by an array(pSrcCbCr) of unsigned char
// containing interleaved U and V samples (such that if addressed as a little-endian
// WORD type, U would be in the LSBs and V would be in the MSBs).
//
// Destination 4:2:0 three-plane image format(YV12 ):
// the order of the pointers to destination images - Y V U.
//
// The function ippiSplit420_Filter_8u_P2P3R usually operates on the sliced images
// ( the height of slices should be a multiple of 16).
*/
IPPAPI(IppStatus, ippiYCbCr420ToYCrCb420_Filter_8u_P2P3R,(const Ipp8u* pSrcY, int srcYStep,const Ipp8u* pSrcCbCr,
int srcCbCrStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize,int layout))
IPPAPI(IppStatus, ippiYCbCr420ToYCrCb420_8u_P2P3R,(const Ipp8u* pSrcY, int srcYStep,const Ipp8u* pSrcCbCr,
int srcCbCrStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiYUToYU422_8u_C2P2R, ippiUYToYU422_8u_C2P2R
// Purpose: Converts 2-channel YUY2,UYVY images to the 2-plane NV12 image
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field value less than 2
//
// Parameters:
// pDstY Pointer to the destination image Y plane.
// dstYStep The step through the destination image Y plane.
// pDstCbCr Pointer to the destination image CbCr plane.
// dstCbCrStep The step through the destination image CbCr plane.
// pSrc Pointer to the source image
// srcStep Step through the source image
// roiSize Size of the ROI, should be multiple of 2.
// Notes:
// for ippiYUToYU422_8u_C2P2R sequence of bytes in the source image is( YUY2 ):
// Y0U0Y1V0,Y2U1Y3V1,...
// for ippiUYToYU422_8u_C2P2R sequence of bytes in the destination image is( UYVY ):
// U0Y0V0Y1,U1Y2V1Y3,...
// Sequence of bytes in the destination image is( NV12 ):
// Y plane Y0Y1Y2Y3
// UV plane U0V0U1V1
*/
IPPAPI(IppStatus, ippiYCbCr422ToYCbCr420_8u_C2P2R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDstY, int dstYStep,Ipp8u* pDstCbCr,int dstCbCrStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiCbYCr422ToYCbCr420_8u_C2P2R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDstY, int dstYStep,Ipp8u* pDstCbCr,int dstCbCrStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCrCb420_8u_C2P3R, ippiCbYCr422ToYCrCb420_8u_C2P3R
// Purpose: Converts 2-channel YUY2,UYVY images to the 3-plane YV12 image
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field value less than 2
//
// Parameters:
// pSrc Pointer to the source image
// srcStep Step through the source image
// roiSize Size of the ROI, should be multiple of 2.
// pDst An array of pointers to separate destination color planes.
// dstStep An array of step in bytes through the destination planes
// Notes:
// for ippiYUToYV422_8u_C2P3R sequence of bytes in the source image is( YUY2 ):
// Y0U0Y1V0,Y2U1Y3V1,...
// for ippiUYToYV422_8u_C2P3R sequence of bytes in the destination image is( UYVY ):
// U0Y0V0Y1,U1Y2V1Y3,...
// Sequence of planes in the destination image is( YV12 ): Y V U
*/
IPPAPI(IppStatus, ippiYCbCr422ToYCrCb420_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiCbYCr422ToYCrCb420_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiYUToUY422_8u_C2R, ippiUYToYU422_8u_C2R
// Purpose: Converts a 2-channel YUY2 image to the UYVY image and vice versa
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field value less than 2
//
// Parameters:
// pSrc Pointer to the source image
// srcStep Step through the source i mage
// roiSize Size of the ROI, roiSize.width should be multiple of 2
// pDst Pointer to the destination image
// dstStep Step through the destination image
// Notes:
// sequence of bytes in the source image for ippiYUToUY422_8u_C2R and in the destination image for ippiUYToYU422_8u_C2P2R is( YUY2 ):
// Y0U0Y1V0,Y2U1Y3V1,...
// sequence of bytes in the destination image for ippiUYToYU422_8u_C2R and in the source image for ippiUYToYU422_8u_C2P2R is( UYVY ):
// U0Y0V0Y1,U1Y2V1Y3,...
*/
IPPAPI(IppStatus, ippiYCbCr422ToCbYCr422_8u_C2R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiCbYCr422ToYCbCr422_8u_C2R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiYVToUY420_8u_P3C2R, ippiYVToYU420_8u_P3C2R
// Purpose: Converts a 3-plane YV12 image to 2-channel YUY2,UYVY images
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field value less than 2
//
// Parameters:
// pSrc An array of three pointers to source image planes
// srcStep An array of steps through the source image planes
// roiSize Size of the ROI, should be multiple 2.
// pDst Pointer to the destination image
// dstStep Step through the destination image
// Notes:
// Sequence of planes in the source image is( YV12 ): Y V U
// for ippiYVToUY420_8u_P3C2R sequence of bytes in the destination image is( YUY2 ):
// Y0U0Y1V0,Y2U1Y3V1,...
// for ippiUYToYU422_8u_C2P2R sequence of bytes in the destination image is( UYVY ):
// U0Y0V0Y1,U1Y2V1Y3,...
*/
IPPAPI(IppStatus, ippiYCrCb420ToCbYCr422_8u_P3C2R,( const Ipp8u* pSrc[3],int srcStep[3], Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCrCb420ToYCbCr422_8u_P3C2R,( const Ipp8u* pSrc[3],int srcStep[3], Ipp8u* pDst, int dstStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToYCbCr422_8u_C3P3R/ippiYCbCr422ToBGR_8u_P3C3R
// PVCS ID 9600
// Purpose: Converts a RGB24/YUY2 image to the YUY2/RGB24 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsDoubleSize Indicates a warning if roiSize is not a multiple of 2.
// Arguments:
// pSrc Pointer to the source image ROI for pixel-order image. An array of pointers to ROI in each separate source color planes for planar images.
// srcStep Distance in bytes between starts of consecutive lines in the source image.
// pDst Pointer to the destination image ROI. An array of pointers to ROI in the separate destination color and alpha planes for planar images.
// dstStep Distance in bytes between starts of consecutive lines in the destination image.
// roiSize Size of the source and destination ROI in pixels.
*/
IPPAPI(IppStatus, ippiRGBToYCbCr422_8u_C3P3R,(const Ipp8u* pSrc , int srcStep , Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422ToBGR_8u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst , int dstStep , IppiSize roiSize))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiYCrCb420ToYCbCr420_8u_P3P2R
// Purpose: Converts a 3-plane YV12 image to the 2-plane NV12 image
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field value less than 2
//
// Parameters:
// pSrc An array of three pointers to source image planes
// srcStep An array of steps through the source image planes
// roiSize Size of the ROI, should be multiple 2.
// pDstY Pointer to the destination image Y plane.
// dstYStep Step through the destination image Y plane.
// pDstCbCr Pointer to the destination image CbCr plane.
// dstCbCrStep Step through the destination image CbCr plane.
// Notes:
// Sequence of planes in the source image is( YV12 ): Y V U
// Sequence of bytes in the destination image is( NV12 ):
// Y plane Y0Y1Y2Y3
// UV plane U0V0U1V1
*/
IPPAPI(IppStatus, ippiYCrCb420ToYCbCr420_8u_P3P2R,( const Ipp8u* pSrc[3],int srcStep[3], Ipp8u* pDstY, int dstYStep,Ipp8u* pDstCbCr,int dstCbCrStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiYUToUY420_8u_P2C2R
// Purpose: Converts a 2-plane NV12 image to the 2-channel UYVY image
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field value less than 2
//
// Parameters:
// pSrcY Pointer to the source image Y plane.
// srcYStep Step through the source image Y plane.
// pSrcCbCr Pointer to the source image CbCr plane.
// srcCbCrStep Step through the source image CbCr plane.
// pDst Pointer to the destination image
// dstStep Step through the destination image
// roiSize Size of the ROI, should be multiple of 2.
// Notes:
// Sequence of bytes in the source image is( NV12 ):
// Y plane Y0Y1Y2Y3
// UV plane U0V0U1V1
// for ippiUYToYU422_8u_C2P2R sequence of bytes in the destination image is( UYVY ):
// U0Y0V0Y1,U1Y2V1Y3,...
*/
IPPAPI(IppStatus, ippiYCbCr420ToCbYCr422_8u_P2C2R,( const Ipp8u* pSrcY, int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCbCr422_8u_C2P3R
// Purpose: Converts a YUY2 image to the P422 image
// Name: ippiYCrCb422ToYCbCr422_8u_C2P3R
// Purpose: Converts a YVYU image to the P422 image
// Name: ippiCbYCr422ToYCbCr422_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, ippiYCbCr422_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCrCb422ToYCbCr422_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiCbYCr422ToYCbCr422_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCbCr420_8u_C2P3R
// Purpose: Converts a 2-channel YUY2 image to the I420(IYUV) image
// Name: ippiCbYCr422ToYCbCr420_8u_C2P3R
// Purpose: Converts a 2-channel YUY2 image to the I420(IYUV) image
// Name: ippiYCrCb422ToYCbCr420_8u_C2P3R
// Purpose: Converts a 2-channel YVYU 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, ippiYCbCr422ToYCbCr420_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiCbYCr422ToYCbCr420_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCrCb422ToYCbCr420_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCbCr411_8u_C2P3R
// Purpose: Converts a YUY2 image to the P411 image
// Name: ippiCbYCr422ToYCbCr411_8u_C2P3R
// Purpose: Converts a YUY2 image to the P411 image
// Name: ippiYCrCb422ToYCbCr411_8u_C2P3R
// Purpose: Converts a YVYU image to the P411 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4
//
// 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 4.
*/
IPPAPI(IppStatus, ippiYCbCr422ToYCbCr411_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiCbYCr422ToYCbCr411_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCrCb422ToYCbCr411_8u_C2P3R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCbCr420_8u_P3P2R
// Purpose: Converts a P422 image to the NV12 image
// Name: ippiYCbCr420_8u_P3P2R
// Purpose: Converts a IYUV image to the NV12 image
// Name: ippiYCbCr420ToYCbCr411_8u_P3P2R
// Purpose: Converts a IYUV image to the NV11 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
// pDstY pointer to the source Y plane
// dstYStep step for the destination Y plane
// pDstCbCr pointer to the destination CbCr plane
// dstCbCrStep step for the destination CbCr plane
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width and roiSize.height should be multiple 2.
*/
IPPAPI(IppStatus, ippiYCbCr422ToYCbCr420_8u_P3P2R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDstY,
int dstYStep,Ipp8u* pDstCbCr, int dstCbCrStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCbCr420_8u_P3P2R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDstY,
int dstYStep,Ipp8u* pDstCbCr, int dstCbCrStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCbCr420ToYCbCr411_8u_P3P2R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDstY,
int dstYStep,Ipp8u* pDstCbCr, int dstCbCrStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCbCr411_8u_P3P2R
// Purpose: Converts a P422 image to the NV11 image
// Name: ippiYCrCb420ToYCbCr411_8u_P3P2R
// Purpose: Converts a YV12 image to the NV11 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4 || roiSize.height < 2
//
// Arguments:
// pSrc array of pointers to the components of the source image
// srcStep array of step values for every component
// pDstY pointer to the source Y plane
// dstYStep step for the destination Y plane
// pDstCbCr pointer to the destination CbCr plane
// dstCbCrStep step for the destination CbCr plane
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width should be multiple 4.
// roiSize.height should be multiple 2.
*/
IPPAPI(IppStatus, ippiYCbCr422ToYCbCr411_8u_P3P2R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDstY,
int dstYStep,Ipp8u* pDstCbCr, int dstCbCrStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCrCb420ToYCbCr411_8u_P3P2R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDstY,
int dstYStep,Ipp8u* pDstCbCr, int dstCbCrStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCbCr420_8u_P3R
// Purpose: Converts a P422 image to the I420(IYUV)image
// Name: ippiYCbCr420ToYCbCr422_8u_P3R
// Purpose: Converts a IYUV image to the P422 image
// Name: ippiYCrCb420ToYCbCr422_8u_P3R
// Purpose: Converts a YV12 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, ippiYCbCr422ToYCbCr420_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCbCr420ToYCbCr422_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCrCb420ToYCbCr422_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr420ToYCbCr422_Filter_8u_P3R
// Purpose: Converts a IYUV image to the P422 image.
// Name: ippiYCrCb420ToYCbCr422_Filter_8u_P3R
// Purpose: Converts a YV12 image to the P422 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 || roiSize.height < 8
//
// 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 should be multiple 2.
// roiSize.height should be multiple 8.
// We use here Catmull-Rom interpolation.
*/
IPPAPI(IppStatus, ippiYCbCr420ToYCbCr422_Filter_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCrCb420ToYCbCr422_Filter_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr420ToYCbCr422_Filter_8u_P2P3R
// Purpose: Converts a NV12 image to the P422 image.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2 || roiSize.height < 8
//
// 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 8.
// We use here Catmull-Rom interpolation.
*/
IPPAPI(IppStatus, ippiYCbCr420ToYCbCr422_Filter_8u_P2P3R,(const Ipp8u* pSrcY,int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr420ToYCbCr422_8u_P2P3R
// Purpose: Converts a NV12 image to the P422 image.
// Name: ippiYCbCr420_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, ippiYCbCr420ToYCbCr422_8u_P2P3R,(const Ipp8u* pSrcY,int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCbCr420_8u_P2P3R,(const Ipp8u* pSrcY,int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr420ToYCbCr411_8u_P2P3R
// Purpose: Converts a NV12 image to the P411 image.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4 || 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 4.
// roiSize.height should be multiple 2.
*/
IPPAPI(IppStatus, ippiYCbCr420ToYCbCr411_8u_P2P3R,(const Ipp8u* pSrcY,int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr411ToYCbCr422_8u_P3C2R
// Purpose: Converts a P411 image to the YUY2 image.
// Name: ippiYCbCr411ToYCrCb422_8u_P3C2R
// Purpose: Converts a P411 image to the YVYU image.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4
//
// Arguments:
// pSrc array of pointers to the components of the source image
// srcStep array of step values for every component
// pSrc pointer to the destination image
// srcStep step for the destination image
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width should be multiple 4.
*/
IPPAPI(IppStatus, ippiYCbCr411ToYCbCr422_8u_P3C2R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst,
int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCbCr411ToYCrCb422_8u_P3C2R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst,
int dstStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr411ToYCbCr422_8u_P3R
// Purpose: Converts a P411 image to the P422 image
// Name: ippiYCbCr411ToYCrCb422_8u_P3R
// Purpose: Converts a P411 image to the YVYU image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4
//
// 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 should be multiple 4.
*/
IPPAPI(IppStatus, ippiYCbCr411ToYCbCr422_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCbCr411ToYCrCb422_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr411ToYCbCr420_8u_P3R
// Purpose: Converts a P411 image to the I420(IYUV) image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4 || 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 should be multiple 4.
// roiSize.height should be multiple 2.
*/
IPPAPI(IppStatus, ippiYCbCr411ToYCbCr420_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr411ToYCbCr420_8u_P3P2R
// Purpose: Converts a P411 image to the NV12 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4 || roiSize.height < 2
//
// Arguments:
// pSrc array of pointers to the components of the source image
// srcStep array of step values for every component
// pDstY pointer to the source Y plane
// dstYStep step for the destination Y plane
// pDstCbCr pointer to the destination CbCr plane
// dstCbCrStep step for the destination CbCr plane
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width should be multiple 4.
// roiSize.height should be multiple 2.
*/
IPPAPI(IppStatus, ippiYCbCr411ToYCbCr420_8u_P3P2R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDstY,
int dstYStep,Ipp8u* pDstCbCr, int dstCbCrStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr411ToYCbCr411_8u_P3P2R
// Purpose: Converts a P411 image to the NV11 image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4
//
// Arguments:
// pSrc array of pointers to the components of the source image
// srcStep array of step values for every component
// pDstY pointer to the source Y plane
// dstYStep step for the destination Y plane
// pDstCbCr pointer to the destination CbCr plane
// dstCbCrStep step for the destination CbCr plane
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width should be multiple 4.
*/
IPPAPI(IppStatus, ippiYCbCr411_8u_P3P2R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDstY,
int dstYStep,Ipp8u* pDstCbCr, int dstCbCrStep, IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr411ToYCbCr422_8u_P2C2R
// Purpose: Converts a NV11 image to the YUY2 image.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4
//
// 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
// pSrc pointer to the destination image
// srcStep step for the destination image
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width should be multiple 4.
*/
IPPAPI(IppStatus, ippiYCbCr411ToYCbCr422_8u_P2C2R,(const Ipp8u* pSrcY,int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep,
Ipp8u* pDst, int dstStep, IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr411ToYCbCr422_8u_P2P3R
// Purpose: Converts a NV11 image to the P422 image.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4
//
// 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 4.
*/
IPPAPI(IppStatus, ippiYCbCr411ToYCbCr422_8u_P2P3R,(const Ipp8u* pSrcY,int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr411ToYCrCb420_8u_P2P3R
// Purpose: Converts a NV11 image to the YV12 image.
// Name: ippiYCbCr411ToYCbCr420_8u_P2P3R
// Purpose: Converts a NV11 image to the I420(IYUV) image.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4 || 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 4.
// roiSize.height should be multiple 2.
*/
IPPAPI(IppStatus, ippiYCbCr411ToYCrCb420_8u_P2P3R,(const Ipp8u* pSrcY,int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCbCr411ToYCbCr420_8u_P2P3R,(const Ipp8u* pSrcY,int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr411_8u_P2P3R
// Purpose: Converts a NV11 image to the P411 image.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4
//
// 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 4.
*/
IPPAPI(IppStatus, ippiYCbCr411_8u_P2P3R,(const Ipp8u* pSrcY,int srcYStep,const Ipp8u* pSrcCbCr, int srcCbCrStep,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCbCr411_8u_C2P2R
// Purpose: Converts a YUY2 image to the NV11 image YUY2ToNV11
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 4
//
// Arguments:
// pSrc pointer to the source image
// srcStep step for the source image
// pDstY pointer to the source Y plane
// dstYStep step for the destination Y plane
// pDstCbCr pointer to the destination CbCr plane
// dstCbCrStep step for the destination CbCr plane
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width should be multiple 4.
*/
IPPAPI(IppStatus, ippiYCbCr422ToYCbCr411_8u_C2P2R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDstY,
int dstYStep,Ipp8u* pDstCbCr, int dstCbCrStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCbCr411_8u_P3R
// Purpose: Converts a P422 image to the P411 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, ippiYCbCr422ToYCbCr411_8u_P3R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3],
int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCrCb422_8u_P3C2R
// Purpose: Converts a P422 image to the YVYU image
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
// ippStsSizeErr if roiSize.width < 2
//
// Arguments:
// pSrc array of pointers to the components of the source image
// srcStep array of step values for every component
// pSrc pointer to the destination image
// srcStep step for the destination image
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width and should be multiple 2.
*/
IPPAPI(IppStatus, ippiYCbCr422ToYCrCb422_8u_P3C2R,( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst,
int dstStep, IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCbCr422ToYCrCb422_8u_C2R
// Purpose: Converts a YUY2 image to the YVYU 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
// pSrc pointer to the destination image
// srcStep step for the destination image
// roiSize region of interest to be processed, in pixels
// Notes:
// roiSize.width should be multiple 2.
*/
IPPAPI(IppStatus, ippiYCbCr422ToYCrCb422_8u_C2R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst,
int dstStep, IppiSize roiSize ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToYCbCr_8u_C3R, ippiYCbCrToRGB_8u_C3R.
// ippiRGBToYCbCr_8u_AC4R, ippiYCbCrToRGB_8u_AC4R.
// ippiRGBToYCbCr_8u_P3R, ippiYCbCrToRGB_8u_P3R.
// ippiYCbCrToRGB_8u_P3C3R
// ippiYCbCrToBGR444_8u16u_C3R, ippiYCbCrToRGB444_8u16u_C3R,
// ippiYCbCrToBGR555_8u16u_C3R, ippiYCbCrToRGB555_8u16u_C3R,
// ippiYCbCrToBGR565_8u16u_C3R, ippiYCbCrToRGB565_8u16u_C3R,
// Purpose: Convert an RGB(BGR) image to and from YCbCr color model
// Parameters:
// pSrc Pointer to the source image (for pixel-order data).An array of pointers
// to separate source color planes (in case of plane-order data)
// pDst Pointer to the resultant image (for pixel-order data).An array of pointers
// to separate source color planes (in case of plane-order data)
// roiSize Size of the ROI in pixels.
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// Returns:
// ippStsNullPtrErr src == NULL or dst == NULL
// ippStsStepErr, srcStep or dstStep is less than or equal to zero
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
// Reference:
// Jack Keith
// Video Demystified: A Handbook for the Digital Engineer, 2nd ed.
// 1996.pp.(42-43)
//
// The YCbCr color space was developed as part of Recommendation ITU-R BT.601
// (formerly CCI 601). Y is defined to have a nominal range of 16 to 235;
// Cb and Cr are defined to have a range of 16 to 240, with 128 equal to zero.
// If the gamma-corrected RGB(R'G'B') image has a range 0 .. 255, as is commonly
// found in computer system (and in our library), the following equations may be
// used:
//
// Y = 0.257*R' + 0.504*G' + 0.098*B' + 16
// Cb = -0.148*R' - 0.291*G' + 0.439*B' + 128
// Cr = 0.439*R' - 0.368*G' - 0.071*B' + 128
//
// R' = 1.164*(Y - 16) + 1.596*(Cr - 128 )
// G' = 1.164*(Y - 16) - 0.813*(Cr - 128 )- 0.392*( Cb - 128 )
// B' = 1.164*(Y - 16) + 2.017*(Cb - 128 )
//
// Note that for the YCbCr-to-RGB equations, the RGB values must be saturated
// at the 0 and 255 levels due to occasional excursions outside the nominal
// YCbCr ranges.
//
*/
IPPAPI(IppStatus, ippiRGBToYCbCr_8u_C3R,(const Ipp8u* pSrc, int srcStep,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCbCr_8u_AC4R,(const Ipp8u* pSrc, int srcStep,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCbCr_8u_P3R,(const Ipp8u* pSrc[3], int srcStep,
Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB_8u_P3C3R,(const Ipp8u* pSrc[3],int srcStep,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB_8u_C3R,(const Ipp8u* pSrc, int srcStep,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB_8u_AC4R,(const Ipp8u* pSrc, int srcStep,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB_8u_P3R,(const Ipp8u* pSrc[3],int srcStep,
Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR444_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB444_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR555_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB555_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToBGR565_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCrToRGB565_8u16u_C3R,(const Ipp8u* pSrc, int srcStep,
Ipp16u* pDst, int dstStep, IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToYUV_8u_C3R, ippiYUVToRGB_8u_C3R.
// ippiRGBToYUV_8u_AC4R, ippiYUVToRGB_8u_AC4R.
// ippiRGBToYUV_8u_P3R, ippiYUVToRGB_8u_P3R.
// ippiRGBToYUV_8u_C3P3R,ippiYUVToRGB_8u_P3C3R.
// Purpose: Converts an RGB image to the YUV color model and vice versa.
// Parameters:
// pSrc Pointer to the source image (for pixel-order data).An array of pointers
// to separate source color planes (for plane-order data)
// pDst Pointer to the destination image (for pixel-order data).An array of
// pointers to separate destination color planes (for of plane-order data)
// roiSize Size of ROI in pixels.
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsStepErr, srcStep or dstStep is less than or equal to zero
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
// Reference:
// Jack Keith
// Video Demystified: A Handbook for the Digital Engineer, 2nd ed.
// 1996.pp.(40-41)
//
// The YUV color space is the basic color space used by the PAL, NTSC, and
// SECAM composite color video standards.
//
// These functions operate with gamma-corrected images.
// The basic equations for conversion between gamma-corrected RGB(R'G'B')and YUV are:
//
// Y' = 0.299*R' + 0.587*G' + 0.114*B'
// U = -0.147*R' - 0.289*G' + 0.436*B' = 0.492*(B' - Y' )
// V = 0.615*R' - 0.515*G' - 0.100*B' = 0.877*(R' - Y' )
//
// R' = Y' + 1.140 * V
// G' = Y' - 0.394 * U - 0.581 * V
// B' = Y' + 2.032 * U
//
// For digital RGB values in the range [0 .. 255], Y has a range [0..255],
// U a range [-112 .. +112], and V a range [-157..+157].
//
// These equations are usually scaled to simplify the implementation in an actual
// NTSC or PAL digital encoder or decoder.
//
*/
/* Pixel to Pixel */
IPPAPI(IppStatus, ippiRGBToYUV_8u_C3R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUVToRGB_8u_C3R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
/* Pixel to Pixel */
IPPAPI(IppStatus, ippiRGBToYUV_8u_AC4R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUVToRGB_8u_AC4R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
/* Plane to Plane */
IPPAPI(IppStatus, ippiRGBToYUV_8u_P3R,(const Ipp8u* pSrc[3], int srcStep ,
Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUVToRGB_8u_P3R,(const Ipp8u* pSrc[3], int srcStep,
Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
/* Pixel to Plane */
IPPAPI(IppStatus, ippiRGBToYUV_8u_C3P3R,( const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
/* Plane to Pixel */
IPPAPI(IppStatus, ippiYUVToRGB_8u_P3C3R,(const Ipp8u* pSrc[3], int srcStep,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiBGRToYUV420_8u_AC4P3R
// PVCS ID 7635
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsDoubleSize Indicates a warning if roiSize is not a multiple of 2.
// Arguments:
// pSrc Pointer to the source image ROI.
// srcStep Distance in bytes between starts of consecutive lines in the source image.
// pDst An array of pointers to ROI in the separate planes of the destination image.
// dstStep Distance in bytes between starts of consecutive lines in the destination image.
// roiSize Size of the source and destination ROI in pixels.
*/
IPPAPI(IppStatus, ippiBGRToYUV420_8u_AC4P3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize ))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToYUV_8u_AC4P4R
// PVCS ID 8868
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// Arguments:
// pSrc Pointer to the source image ROI for pixel-order image.
// srcStep Distance in bytes between starts of consecutive lines in the source image.
// pDst Pointer to the destination image ROI. An array of pointers to ROI in the separate destination color and alpha planes for planar images.
// dstStep Distance in bytes between starts of consecutive lines in the destination image.
// roiSize Size of the source and destination ROI in pixels.
*/
IPPAPI(IppStatus, ippiRGBToYUV_8u_AC4P4R,( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[4], int dstStep, IppiSize roiSize))
/* ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiRGB565ToYUV420_16u8u_C3P3R/ippiRGB565ToYUV422_16u8u_C3P3R
// PVCS ID 8910
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr one or more pointers are NULL
// ippStsDoubleSize Indicates a warning if roiSize is not a multiple of 2.
// Arguments:
// pSrc Pointer to the source image ROI for pixel-order image.
// srcStep Distance in bytes between starts of consecutive lines in the source image.
// pDst An array of pointers to ROI in the separate destination color and alpha planes for planar images.
// dstStep Distance in bytes between starts of consecutive lines in the destination image.
// roiSize Size of the source and destination ROI in pixels.
*/
IPPAPI(IppStatus, ippiRGB565ToYUV420_16u8u_C3P3R,(const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiRGB565ToYUV422_16u8u_C3P3R,(const Ipp16u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToYUV422_8u_C3P3R, ippiYUV422ToRGB_8u_P3C3R.
// ippiRGBToYUV422_8u_P3R, ippiYUV422ToRGB_8u_P3R.
// ippiRGBToYUV420_8u_C3P3R, ippiYUV420ToRGB_8u_P3C3R.
// ippiRGBToYUV422_8u_C3C2R, ippiYUV422ToRGB_8u_C2C3R.
// ippiYUV420ToBGR565_8u16u_P3C3R,
// ippiYUV420ToBGR555_8u16u_P3C3R,
// ippiYUV420ToBGR444_8u16u_P3C3R,
// ippiYUV420ToRGB565_8u16u_P3C3R,
// ippiYUV420ToRGB555_8u16u_P3C3R,
// ippiYUV420ToRGB444_8u16u_P3C3R.
// Purpose: Converts an RGB (BGR) image to the YUV color model with 4:2:2 or
// 4:2:0 sampling and vice versa.
// Parameters:
// pSrc Pointer to the source image (for pixel-order data).An array of pointers
// to separate source color planes (for plane-order data)
// pDst Pointer to the destination image (for pixel-order data).An array of pointers
// to separate destination color planes (for plane-order data)
// roiSize Size of the ROI in pixels.
// srcStep Step in bytes through the source image to jump on the next line(for pixel-order data).
// An array of step values for the separate source color planes (for plane-order data).
// dstStep Step in bytes through destination image to jump on the next line(for pixel-order data).
// An array of step values for the separate destination color planes (for plane-order data).
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsStepErr srcStep or dstStep is less than or equal to zero
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
// Reference:
// Jack Keith
// Video Demystified: A Handbook for the Digital Engineer, 2nd ed.
// 1996.pp.(40-41)
//
// The YUV color space is the basic color space used by the PAL , NTSC , and
// SECAM composite color video standards.
//
// The functions operate with 4:2:2 and 4:2:0 sampling formats.
// 4:2:2 uses the horizontal-only 2:1 reduction of U and V,
// 4:2:0 uses 2:1 reduction of U and V in both the vertical and
// horizontal directions.
//
// These functions operate with gamma-corrected images.
// The basic equations for conversion between gamma-corrected RGB(R'G'B')and YUV are:
//
// Y' = 0.299*R' + 0.587*G' + 0.114*B'
// U = -0.147*R' - 0.289*G' + 0.436*B' = 0.492*(B' - Y' )
// V = 0.615*R' - 0.515*G' - 0.100*B' = 0.877*(R' - Y' )
//
// R' = Y' + 1.140 * V
// G' = Y' - 0.394 * U - 0.581 * V
// B' = Y' + 2.032 * U
//
// For digital RGB values with the range [0 .. 255], Y has a range [0..255],
// U a range [-112 .. +112], and V a range [-157..+157].
//
// These equations are usually scaled to simplify the implementation in an actual
// NTSC or PAL digital encoder or decoder.
//
*/
IPPAPI(IppStatus, ippiYUV420ToRGB_8u_P3AC4R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV422ToRGB_8u_P3AC4R,(const Ipp8u* pSrc[3],int srcStep[3],Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYUV422_8u_C3P3R,(const Ipp8u* pSrc, int srcStep,
Ipp8u* pDst[3],int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV422ToRGB_8u_P3C3R,(const Ipp8u* pSrc[3],int srcStep[3],
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYUV422_8u_P3R,(const Ipp8u* pSrc[3], int srcStep ,
Ipp8u* pDst[3], int dstStep[3],IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV422ToRGB_8u_P3R,(const Ipp8u* pSrc[3],
int srcStep[3],Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYUV420_8u_C3P3R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToRGB_8u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToBGR_8u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYUV420_8u_P3R,(const Ipp8u* pSrc[3], int srcStep ,
Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToRGB_8u_P3R,(const Ipp8u* pSrc[3],int srcStep[3],
Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYUV422_8u_C3C2R,(const Ipp8u* pSrc, int srcStep ,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV422ToRGB_8u_C2C3R,(const Ipp8u* pSrc,int srcStep,
Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToBGR565_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToBGR555_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToBGR444_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToRGB565_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToRGB555_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYUV420ToRGB444_8u16u_P3C3R,(const Ipp8u* pSrc[3], int srcStep[3], Ipp16u* pDst, int dstStep, IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToYUV422_8u_P3, ippiYUV422ToRGB_8u_P3.
// ippiRGBToYUV422_8u_C3P3, ippiYUV422ToRGB_8u_P3C3.
// ippiRGBToYUV420_8u_C3P3, ippiYUV420ToRGB_8u_P3C3.
// ippiRGBToYUV420_8u_P3, ippiYUV420ToRGB_8u_P3.
// Purpose: Converts an RGB image to YUV color model with 4:2:2 and
// 4:2:0 sampling and vice versa.
// Parameters:
// pSrc Pointer to the source image (for pixel-order data).An array of pointers
// to the separate source color planes (for plane-order data)
// pDst Pointer to the destination image (for pixel-order data).An array of pointers
// to the separate destination color planes (for plane-order data)
// imgSize Size of the source and destination images in pixels
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsStepErr, srcStep or dstStep is less than or equal to zero
// ippStsSizeErr imgSize has a field with zero or negative value
// ippStsNoErr No errors
// Reference:
// Jack Keith
// Video Demystified: A Handbook for the Digital Engineer, 2nd ed.
// 1996.pp.(40-41)
//
// The YUV color space is the basic color space used by the PAL , NTSC , and
// SECAM composite color video standards.
//
// The functions operate with 4:2:2 and 4:2:0 sampling formats.
// 4:2:2 uses the horizontal-only 2:1 reduction of U and V,
// 4:2:0 uses 2:1 reduction of U and V in both the vertical and
// horizontal directions.
//
// These functions operate with gamma-corrected images.
// The basic equations to convert between gamma-corrected RGB(R'G'B')and YUV are:
//
// Y' = 0.299*R' + 0.587*G' + 0.114*B'
// U = -0.147*R' - 0.289*G' + 0.436*B' = 0.492*(B' - Y' )
// V = 0.615*R' - 0.515*G' - 0.100*B' = 0.877*(R' - Y' )
//
// R' = Y' + 1.140 * V
// G' = Y' - 0.394 * U - 0.581 * V
// B' = Y' + 2.032 * U
//
// For digital RGB values with the range [0 .. 255], Y has the range [0..255],
// U the range [-112 .. +112],V the range [-157..+157].
//
// These equations are usually scaled to simplify the implementation in an actual
// NTSC or PAL digital encoder or decoder.
//
*/
/* Plane to Plane */
IPPAPI(IppStatus, ippiRGBToYUV422_8u_P3,(const Ipp8u* pSrc[3], Ipp8u* pDst[3], IppiSize imgSize))
IPPAPI(IppStatus, ippiYUV422ToRGB_8u_P3,(const Ipp8u* pSrc[3], Ipp8u* pDst[3], IppiSize imgSize))
/* Pixel to Plane */
IPPAPI(IppStatus, ippiRGBToYUV422_8u_C3P3,(const Ipp8u* pSrc, Ipp8u* pDst[3], IppiSize imgSize))
/* Plane to Pixel */
IPPAPI(IppStatus, ippiYUV422ToRGB_8u_P3C3,(const Ipp8u* pSrc[3],Ipp8u* pDst, IppiSize imgSize ))
/* Pixel to Plane */
IPPAPI(IppStatus, ippiRGBToYUV420_8u_C3P3,(const Ipp8u* pSrc, Ipp8u* pDst[3], IppiSize imgSize))
/* Plane to Pixel */
IPPAPI(IppStatus, ippiYUV420ToRGB_8u_P3C3,(const Ipp8u* pSrc[3], Ipp8u* pDst, IppiSize imgSize))
/* Plane to Plane */
IPPAPI(IppStatus, ippiRGBToYUV420_8u_P3,(const Ipp8u* pSrc[3], Ipp8u* pDst[3], IppiSize imgSize))
IPPAPI(IppStatus, ippiYUV420ToRGB_8u_P3,(const Ipp8u* pSrc[3], Ipp8u* pDst[3], IppiSize imgSize))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCoCgToBGR_16s8u_P3C3R ippiYCoCgToBGR_16s8u_P3C4R
// Purpose: Converts a YCoCg image to the RGB24/RGB32 image.
// Name: ippiYCoCgToBGR_16s8u_P3C3R ippiBGRToYCoCg_8u16s_C4P3R
// Purpose: Converts a RGB24/RGB32 image to the YCoCg image.
// Name: ippiYCoCgToSBGR_16s_P3C3R ippiSBGRToYCoCg_16s_C3P3R
// Purpose: Converts a YCoCg image to the scRGB48/scRGB64 image.
// Name: ippi_SC_BGRToYCoCg_16s_C3P3R ippi_SC_BGRToYCoCg_16s_C4P3R
// Purpose: Converts a scRGB48/scRGB64 image to the YCoCg image.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
//
// Arguments:
// pYCC array of pointers to the components of the YCoCg image
// yccStep step for every Y,Co,Cg component
// pBGR Pointer to the BGR image (for pixel-order data).
// bgrStep step for the BGR image.
// roiSize region of interest to be processed, in pixels
// Notes:
// Y = (( R + G*2 + B) + 2 ) / 4
// Co = (( R - B) + 1 ) / 2
// Cg = ((-R + G*2 - B) + 2 ) / 4
//
// R = Y + Co - Cg
// G = Y + Cg
// B = Y - Co - Cg
// scRGB allows negative values and values above 1.0
*/
IPPAPI(IppStatus,ippiYCoCgToBGR_16s8u_P3C3R,(const Ipp16s* pYCC[3],int yccStep,Ipp8u* pBGR,int bgrStep,IppiSize roiSize))
IPPAPI(IppStatus,ippiBGRToYCoCg_8u16s_C3P3R,(const Ipp8u* pBGR, int bgrStep, Ipp16s* pYCC [3], int yccStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiYCoCgToBGR_16s8u_P3C4R,(const Ipp16s* pYCC[3],int yccStep,Ipp8u* pBGR,int bgrStep,IppiSize roiSize, Ipp8u aval))
IPPAPI(IppStatus,ippiBGRToYCoCg_8u16s_C4P3R,(const Ipp8u* pBGR, int bgrStep, Ipp16s* pYCC [3], int yccStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiYCoCgToSBGR_16s_P3C3R ,(const Ipp16s* pYCC[3], int yccStep, Ipp16s* pBGR, int bgrStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiSBGRToYCoCg_16s_C3P3R ,(const Ipp16s* pBGR, int bgrStep, Ipp16s* pYCC[3], int yccStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiYCoCgToSBGR_16s_P3C4R ,(const Ipp16s* pYCC[3], int yccStep, Ipp16s* pBGR , int bgrStep, IppiSize roiSize, Ipp16s aval ))
IPPAPI(IppStatus,ippiSBGRToYCoCg_16s_C4P3R ,(const Ipp16s* pBGR , int bgrStep, Ipp16s* pYCC[3], int yccStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiYCoCgToSBGR_32s16s_P3C3R,(const Ipp32s* pYCC[3], int yccStep, Ipp16s* pBGR , int bgrStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiSBGRToYCoCg_16s32s_C3P3R,(const Ipp16s* pBGR , int bgrStep, Ipp32s* pYCC[3], int yccStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiYCoCgToSBGR_32s16s_P3C4R,(const Ipp32s* pYCC[3], int yccStep, Ipp16s* pBGR , int bgrStep, IppiSize roiSize, Ipp16s aval ))
IPPAPI(IppStatus,ippiSBGRToYCoCg_16s32s_C4P3R,(const Ipp16s* pBGR , int bgrStep, Ipp32s* pYCC[3], int yccStep, IppiSize roiSize ))
/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Name: ippiYCoCgToBGR_Rev_16s8u_P3C3R ippiYCoCgToBGR_Rev_16s8u_P3C4R
// Purpose: Converts a YCoCg-R image to the scRGB48/scRGB64 image.
// Name: ippiBGRToYCoCg_Rev_8u16s_C3P3R ippiBGRToYCoCg_Rev_8u16s_C4P3R
// Purpose: Converts a scRGB48/scRGB64 image to the YCoCg-R image.
// Name: ippiYCoCgToSBGR_Rev_16s_P3C3R ippiYCoCgToSBGR_Rev_16s_P3C4R
// Purpose: Converts a YCoCg-R image to the scRGB48/scRGB64 image.
// Name: ippiSBGRToYCoCg_Rev_16s_C3P3R ippiSBGRToYCoCg_Rev_16s_C4P3R
// Purpose: Converts a scRGB48/scRGB64 image to the YCoCg-R image.
// Where: YCoCg-R - Reversible transform.
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One or more pointers are NULL
//
// Arguments:
// pYCC array of pointers to the components of the YCoCg image
// yccStep step for every Y,Co,Cg component
// pBGR Pointer to the BGR image (for pixel-order data).
// bgrStep step for the BGR image.
// roiSize region of interest to be processed, in pixels
// Notes:
// Co = R - B
// t = B + (Co >> 1)
// Cg = G - t
// Y = t + (Cg >> 1)
//
// t = Y - (Cg >> 1)
// G = Cg + t
// B = t - (Co >> 1)
// R = B + Co
// If each of the RGB channels are integer values with
// an N-bit range, then the luma channel Y requires N bits,
// and the chroma channels require N+1 bits.
*/
IPPAPI(IppStatus, ippiYCoCgToBGR_Rev_16s8u_P3C3R,(const Ipp16s* pYCC[3], int yccStep, Ipp8u* pBGR, int bgrStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGRToYCoCg_Rev_8u16s_C3P3R,(const Ipp8u* pBGR, int bgrStep, Ipp16s* pYCC[3], int yccStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCoCgToBGR_Rev_16s8u_P3C4R,(const Ipp16s* pYCC[3], int yccStep, Ipp8u* pBGR, int bgrStep, IppiSize roiSize,Ipp8u aval ))
IPPAPI(IppStatus, ippiBGRToYCoCg_Rev_8u16s_C4P3R,(const Ipp8u* pBGR, int bgrStep, Ipp16s* pYCC[3], int yccStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCoCgToSBGR_Rev_16s_P3C3R ,(const Ipp16s* pYCC[3], int yccStep, Ipp16s* pBGR, int bgrStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiSBGRToYCoCg_Rev_16s_C3P3R ,(const Ipp16s* pBGR, int bgrStep, Ipp16s* pYCC[3], int yccStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCoCgToSBGR_Rev_16s_P3C4R ,(const Ipp16s* pYCC[3], int yccStep, Ipp16s* pBGR, int bgrStep, IppiSize roiSize,Ipp16s aval ))
IPPAPI(IppStatus, ippiSBGRToYCoCg_Rev_16s_C4P3R ,(const Ipp16s* pBGR, int bgrStep, Ipp16s* pYCC[3], int yccStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiSBGRToYCoCg_Rev_16s32s_C3P3R,(const Ipp16s* pBGR, int bgrStep, Ipp32s* pYCC[3], int yccStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiYCoCgToSBGR_Rev_32s16s_P3C4R,(const Ipp32s* pYCC[3], int yccStep, Ipp16s* pBGR, int bgrStep, IppiSize roiSize, Ipp16s aval ))
IPPAPI(IppStatus, ippiYCoCgToSBGR_Rev_32s16s_P3C3R,(const Ipp32s* pYCC[3], int yccStep, Ipp16s* pBGR, int bgrStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiSBGRToYCoCg_Rev_16s32s_C4P3R,(const Ipp16s* pBGR, int bgrStep, Ipp32s* pYCC[3], int yccStep, IppiSize roiSize ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToGray
// Purpose: Converts an RGB image to gray scale (fixed coefficients)
// Parameters:
// pSrc Pointer to the source image , points to point(0,0)
// pDst Pointer to the destination image , points to point(0,0)
// roiSize Size of the ROI in pixels. Since the function performs point
// operations (without a border), the ROI may be the whole image.
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
// Reference:
// Jack Keith
// Video Demystified: A Handbook for the Digital Engineer, 2nd ed.
// 1996.p.(82)
//
// The transform coefficients of equation below correspond to the standard for
// NTSC red, green and blue CRT phosphors (1953) that are standardized in the
// ITU-R Recommendation BT. 601-2 (formerly CCIR Rec. 601-2).
//
// The basic equation to compute non-linear video luma (monochrome) from non-linear
// (gamma-corrected) RGB(R'G'B') is:
//
// Y' = 0.299 * R' + 0.587 * G' + 0.114 * B';
//
//
*/
IPPAPI(IppStatus,ippiRGBToGray_8u_C3C1R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize))
IPPAPI(IppStatus,ippiRGBToGray_16u_C3C1R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize))
IPPAPI(IppStatus,ippiRGBToGray_16s_C3C1R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize))
IPPAPI(IppStatus,ippiRGBToGray_32f_C3C1R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep,IppiSize roiSize))
IPPAPI(IppStatus,ippiRGBToGray_8u_AC4C1R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize))
IPPAPI(IppStatus,ippiRGBToGray_16u_AC4C1R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize))
IPPAPI(IppStatus,ippiRGBToGray_16s_AC4C1R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize))
IPPAPI(IppStatus,ippiRGBToGray_32f_AC4C1R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep,IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiColorToGray
// Purpose: Converts an RGB image to gray scale (custom coefficients)
// Parameters:
// pSrc Pointer to the source image , points to point(0,0)
// pDst Pointer to the destination image , points to point(0,0)
// roiSize Size of the ROI in pixels. Since the function performs point
// operations (without a border), the ROI may be the whole image.
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// coeffs[3] User-defined vector of coefficients.
// The sum of the coefficients should be less than or equal to 1
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
//
// The following equation is used to convert an RGB image to gray scale:
//
// Y = coeffs[0] * R + coeffs[1] * G + coeffs[2] * B;
//
//
*/
IPPAPI(IppStatus,ippiColorToGray_8u_C3C1R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
IPPAPI(IppStatus,ippiColorToGray_16u_C3C1R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
IPPAPI(IppStatus,ippiColorToGray_16s_C3C1R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
IPPAPI(IppStatus,ippiColorToGray_32f_C3C1R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
IPPAPI(IppStatus,ippiColorToGray_8u_AC4C1R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
IPPAPI(IppStatus,ippiColorToGray_16u_AC4C1R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
IPPAPI(IppStatus,ippiColorToGray_16s_AC4C1R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
IPPAPI(IppStatus,ippiColorToGray_32f_AC4C1R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep,IppiSize roiSize,const Ipp32f coeffs[3]))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToHLS, ippiHLSToRGB
// ippiBGRToHLS, ippiHLSToBGR
// Purpose: Converts an RGB(BGR) image to the HLS color model and vice versa
// Parameters:
// pSrc Pointer to the source image , points to point(0,0)
// pDst Pointer to the destination image , points to point(0,0)
// roiSize Size of the ROI in pixels. Since the function performs point
// operations (without a border), the ROI may be the whole image.
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsStepErr srcStep or dstStep is less than or equal to zero
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
// RGB and HLS values for the 32f data type should be in the range [0..1]
// Reference:
// David F.Rogers
// Procedural Elements for Computer Graphics
// 1985.pp.(403-406)
//
// H is the hue red at 0 degrees, which has range [0 .. 360 degrees],
// L is the lightness,
// S is the saturation,
//
// The RGB to HLS conversion algorithm in pseudo code:
// Lightness:
// M1 = max(R,G,B); M2 = max(R,G,B); L = (M1+M2)/2
// Saturation:
// if M1 = M2 then // achromatic case
// S = 0
// H = 0
// else // chromatics case
// if L <= 0.5 then
// S = (M1-M2) / (M1+M2)
// else
// S = (M1-M2) / (2-M1-M2)
// Hue:
// Cr = (M1-R) / (M1-M2)
// Cg = (M1-G) / (M1-M2)
// Cb = (M1-B) / (M1-M2)
// if R = M2 then H = Cb - Cg
// if G = M2 then H = 2 + Cr - Cb
// if B = M2 then H = 4 + Cg - Cr
// H = 60*H
// if H < 0 then H = H + 360
//
// The HSL to RGB conversion algorithm in pseudo code:
// if L <= 0.5 then
// M2 = L *(1 + S)
// else
// M2 = L + S - L * S
// M1 = 2 * L - M2
// if S = 0 then
// R = G = B = L
// else
// h = H + 120
// if h > 360 then
// h = h - 360
// if h < 60 then
// R = ( M1 + ( M2 - M1 ) * h / 60)
// else if h < 180 then
// R = M2
// else if h < 240 then
// R = M1 + ( M2 - M1 ) * ( 240 - h ) / 60
// else
// R = M1
// h = H
// if h < 60 then
// G = ( M1 + ( M2 - M1 ) * h / 60
// else if h < 180 then
// G = M2
// else if h < 240 then
// G = M1 + ( M2 - M1 ) * ( 240 - h ) / 60
// else
// G = M1
// h = H - 120
// if h < 0 then
// h += 360
// if h < 60 then
// B = ( M1 + ( M2 - M1 ) * h / 60
// else if h < 180 then
// B = M2
// else if h < 240 then
// B = M1 + ( M2 - M1 ) * ( 240 - h ) / 60
// else
// B = M1
//
// H,L,S,R,G,B are scaled to the range:
// [0..1] for the 32f depth,
// [0..IPP_MAX_8u] for the 8u depth,
// [0..IPP_MAX_16u] for the 16u depth,
// [IPP_MIN_16S..IPP_MAX_16s] for the 16s depth.
//
*/
IPPAPI(IppStatus, ippiBGRToHLS_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHLS_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToRGB_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHLS_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToRGB_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHLS_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToRGB_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHLS_16s_AC4R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToRGB_16s_AC4R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHLS_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToRGB_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHLS_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToRGB_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHLS_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToRGB_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHLS_32f_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToRGB_32f_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiBGRToHLS_8u_AP4R, (const Ipp8u* pSrc[4], int srcStep, Ipp8u* pDst[4], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiBGRToHLS_8u_AP4C4R, (const Ipp8u* pSrc[4], int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiBGRToHLS_8u_AC4P4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[4], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiBGRToHLS_8u_P3R, (const Ipp8u* pSrc[3], int srcStep, Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiBGRToHLS_8u_P3C3R, (const Ipp8u* pSrc[3], int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiBGRToHLS_8u_C3P3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToBGR_8u_AP4R, (const Ipp8u* pSrc[4], int srcStep, Ipp8u* pDst[4], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToBGR_8u_AP4C4R, (const Ipp8u* pSrc[4], int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToBGR_8u_AC4P4R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[4], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToBGR_8u_P3R, (const Ipp8u* pSrc[3], int srcStep, Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToBGR_8u_P3C3R, (const Ipp8u* pSrc[3], int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHLSToBGR_8u_C3P3R, (const Ipp8u* pSrc, int srcStep, Ipp8u* pDst[3], int dstStep, IppiSize roiSize))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToHSV, ippiHSVToRGB
// Purpose: Converts an RGB image to the HSV color model and vice versa
// Parameters:
// pSrc Pointer to the source image , points to point(0,0)
// pDst Pointer to the destination image , points to point(0,0)
// roiSize Size of the ROI in pixels.
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsStepErr srcStep or dstStep is less than or equal to zero
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
// Reference:
// David F.Rogers
// Procedural Elements for Computer Graphics
// 1985.pp.(401-403)
//
// H is the hue red at 0 degrees, which has range [0 .. 360 degrees],
// S is the saturation,
// V is the value
// The RGB to HSV conversion algorithm in pseudo code:
// Value:
// V = max(R,G,B);
// Saturation:
// temp = min(R,G,B);
// if V = 0 then // achromatic case
// S = 0
// H = 0
// else // chromatics case
// S = (V - temp)/V
// Hue:
// Cr = (V - R) / (V - temp)
// Cg = (V - G) / (V - temp)
// Cb = (V - B) / (V - temp)
// if R = V then H = Cb - Cg
// if G = V then H = 2 + Cr - Cb
// if B = V then H = 4 + Cg - Cr
// H = 60*H
// if H < 0 then H = H + 360
//
// The HSV to RGB conversion algorithm in pseudo code:
// if S = 0 then
// R = G = B = V
// else
// if H = 360 then
// H = 0
// else
// H = H/60
// I = floor(H)
// F = H - I;
// M = V * ( 1 - S);
// N = V * ( 1 - S * F);
// K = V * ( 1 - S * (1 - F));
// if(I == 0)then{ R = V;G = K;B = M;}
// if(I == 1)then{ R = N;G = V;B = M;}
// if(I == 2)then{ R = M;G = V;B = K;}
// if(I == 3)then{ R = M;G = N;B = V;}
// if(I == 4)then{ R = K;G = M;B = V;}
// if(I == 5)then{ R = V;G = M;B = N;}
//
// in the range [0..IPP_MAX_8u ] for the 8u depth,
// in the range [0..IPP_MAX_16u] for the 16u depth,
//
*/
IPPAPI(IppStatus, ippiRGBToHSV_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHSVToRGB_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHSV_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHSVToRGB_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHSV_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHSVToRGB_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToHSV_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiHSVToRGB_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToYCC, ippiYCCToRGB
// Purpose: Converts an RGB image to the YCC color model and vice versa.
// Parameters:
// pSrc Pointer to the source image ROI
// srcStep Step through the source image (bytes)
// pDst Pointer to the destination image ROI
// dstStep Step through the destination image (bytes)
// dstRoiSize size of the ROI
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsStepErr srcStep or dstStep is less than or equal to zero
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
// Reference:
// Jack Keith
// Video Demystified: a Handbook for the Digital Engineer, 2nd ed.
// 1996.pp.(46-47)
//
// The basic equations to convert gamma-corrected R'G'B' image to YCC are:
//
// RGB data is transformed into PhotoYCC data:
// Y = 0.299*R' + 0.587*G' + 0.114*B'
// C1 = -0.299*R' - 0.587*G' + 0.886*B' = B'- Y
// C2 = 0.701*R' - 0.587*G' - 0.114*B' = R'- Y
// Y,C1,C2 are quantized and limited to the range [0..1]
// Y = 1. / 1.402 * Y
// C1 = 111.4 / 255. * C1 + 156. / 255.
// C2 = 135.64 /255. * C2 + 137. / 255.
//
// Conversion of PhotoYCC data to RGB data for CRT computer display:
//
// normal luminance and chrominance data are recovered
// Y = 1.3584 * Y
// C1 = 2.2179 * (C1 - 156./255.)
// C2 = 1.8215 * (C2 - 137./255.)
// PhotoYCC data is transformed into RGB data
// R' = L + C2
// G' = L - 0.194*C1 - 0.509*C2
// B' = L + C1
// Where: Y - luminance; and C1, C2 - two chrominance values.
//
// Equations are given above in assumption that the Y, C1, C2, R, G, and B
// values are in the range [0..1].
// Y, C1, C2, R, G, B - are scaled to the range:
// [0..1] for the 32f depth,
// [0..IPP_MAX_8u] for the 8u depth,
// [0..IPP_MAX_16u] for the 16u depth,
// [IPP_MIN_16s..IPP_MAX_16s] for the 16s depth.
*/
IPPAPI(IppStatus, ippiRGBToYCC_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCCToRGB_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCC_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCCToRGB_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCC_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCCToRGB_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCC_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCCToRGB_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCC_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCCToRGB_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCC_16s_AC4R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCCToRGB_16s_AC4R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCC_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCCToRGB_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToYCC_32f_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCCToRGB_32f_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToXYZ, ippiXYZToRGB
// Purpose: Converts an RGB image to the XYZ color model and vice versa.
// Parameters:
// pSrc Pointer to the source image ROI
// srcStep Step through the source image (bytes)
// pDst Pointer to the destination image ROI
// dstStep Step through the destination image (bytes)
// dstRoiSize size of the ROI
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsStepErr srcStep or dstStep is less than or equal to zero
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
// Reference:
// David F. Rogers
// Procedural Elements for Computer Graphics.
// 1985.
//
// The basic equations to convert between Rec. 709 RGB (with its D65 white point) and CIE XYZ are:
//
// X = 0.412453 * R + 0.35758 * G + 0.180423 * B
// Y = 0.212671 * R + 0.71516 * G + 0.072169 * B
// Z = 0.019334 * R + 0.119193* G + 0.950227 * B
//
// R = 3.240479 * X - 1.53715 * Y - 0.498535 * Z
// G =-0.969256 * X + 1.875991 * Y + 0.041556 * Z
// B = 0.055648 * X - 0.204043 * Y + 1.057311 * Z
// Equations are given above in assumption that the X,Y,Z,R,G, and B
// values are in the range [0..1].
// Y, C1, C2, R, G, B - are scaled to the range:
// [0..1] for the 32f depth,
// [0..IPP_MAX_8u] for the 8u depth,
// [0..IPP_MAX_16u] for the 16u depth,
// [IPP_MIN_16s..IPP_MAX_16s] for the 16s depth.
//
*/
IPPAPI(IppStatus, ippiRGBToXYZ_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiXYZToRGB_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToXYZ_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiXYZToRGB_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToXYZ_16u_C3R,(const Ipp16u* pSrc, int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiXYZToRGB_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToXYZ_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiXYZToRGB_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToXYZ_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiXYZToRGB_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToXYZ_16s_AC4R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiXYZToRGB_16s_AC4R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToXYZ_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiXYZToRGB_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToXYZ_32f_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiXYZToRGB_32f_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiRGBToLUV, ippiLUVToRGB
// Purpose: Converts an RGB image to the LUV color model and vice versa.
// Parameters:
// pSrc Pointer to the source image ROI
// srcStep Step through the source image (bytes)
// pDst Pointer to the destination image ROI
// dstStep Step through the destination image (bytes)
// dstRoiSize size of the ROI
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsStepErr srcStep or dstStep is less than or equal to zero
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoErr No errors
// Reference:
// Computer Graphics: Principles and Practices. James D. Foley... [et al]. 2nd edition.
// Addison-Wesley, 1990.p.(584)
//
// At first an RGB image is converted to the XYZ format image (see the functions
// ippiRGBToXYZ), then to the CIELUV with the white point D65 and CIE chromaticity
// coordinates of white point (xn,yn) = (0.312713, 0.329016), and Yn = 1.0 - the luminance of white point.
//
// L = 116. * (Y/Yn)**1/3. - 16.
// U = 13. * L * ( u - un )
// V = 13. * L * ( v - vn )
// These are quantized and limited to the 8-bit range of 0 to 255.
// L = L * 255. / 100.
// U = ( U + 134. ) * 255. / 354.
// V = ( V + 140. ) * 255. / 256.
// where:
// u' = 4.*X / (X + 15.*Y + 3.*Z)
// v' = 9.*Y / (X + 15.*Y + 3.*Z)
// un = 4.*xn / ( -2.*xn + 12.*yn + 3. )
// vn = 9.*yn / ( -2.*xn + 12.*yn + 3. ).
// xn, yn is the CIE chromaticity coordinates of white point.
// Yn = 255. is the luminance of white point.
//
// The L component values are in the range [0..100], the U component values are
// in the range [-134..220], and the V component values are in the range [-140..122].
//
// The CIELUV to RGB conversion is performed as following. At first
// a LUV image is converted to the XYZ image
// L = L * 100./ 255.
// U = ( U * 354./ 255.) - 134.
// V = ( V * 256./ 255.) - 140.
// u = U / ( 13.* L ) + un
// v = V / ( 13.* L ) + vn
// Y = (( L + 16. ) / 116. )**3.
// Y *= Yn
// X = -9.* Y * u / (( u - 4.)* v - u * v )
// Z = ( 9.*Y - 15*v*Y - v*X ) / 3. * v
// where:
// un = 4.*xn / ( -2.*xn + 12.*yn + 3. )
// vn = 9.*yn / ( -2.*xn + 12.*yn + 3. ).
// xn, yn is the CIE chromaticity coordinates of white point.
// Yn = 255. is the luminance of white point.
//
// Then the XYZ image is converted to the RGB image (see the functions
// ippiXYZToRGB).
//
*/
IPPAPI(IppStatus, ippiRGBToLUV_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiLUVToRGB_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToLUV_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiLUVToRGB_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToLUV_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiLUVToRGB_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToLUV_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiLUVToRGB_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToLUV_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiLUVToRGB_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToLUV_16s_AC4R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiLUVToRGB_16s_AC4R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToLUV_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiLUVToRGB_32f_C3R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiRGBToLUV_32f_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiLUVToRGB_32f_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp32f* pDst, int dstStep, IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ippiBGRToLab_8u_C3R and ippiLabToBGR_8u_C3R
// ippiBGRToLab_8u16u_C3R and ippiLabToBGR_16u8u_C3R
// Purpose: Converts an RGB image to CIE Lab color model and vice-versa
// Parameters:
// pSrc Pointer to the source image ROI
// srcStep Step through the source image (bytes)
// pDst Pointer to the destination image ROI
// dstStep Step through the destination image (bytes)
// roiSize Size of the ROI
// Returns:
// ippStsNullPtrErr if src == NULL or dst == NULL
// ippStsSizeErr if imgSize.width <= 0 || imgSize.height <= 0
// ippStsNoErr otherwise
// Reference:
// Computer graphics: principles and practices. James D. Foley... [et al.]. 2nd ed.
// Addison-Wesley, c1990.p.(584)
//
// At first an RGB image is converted to the XYZ color model (see the function
// ippRGBToXYZ_8u_C3R), then to the CIELab with the white point D65 and CIE chromaticity
// coordinates of white point (xn,yn) = (0.312713, 0.329016)
// L = 116. *((Y/Yn)^(1/3)) - 16 for Y/Yn > 0.008856
// L = 903.3*(Y/Yn) for Y/Yn <= 0.008856
// a = 500. * (f(X/Xn) - f(Y/Yn))
// b = 200. * (f(Y/Yn) - f(Z/Zn))
// where f(t)=t^(1/3) for t > 0.008856
// f(t)=7.787*t+16/116 for t <= 0.008856
// These values are quantized and scaled to the 8-bit range of 0 to 255 for ippiBGRToLab_8u_C3R.
// L = L * 255. / 100.
// a = (a + 128.)
// b = (a + 128.)
// and they are quantized and scaled to the 16-bit range of 0 to 65535 for ippiBGRToLab_8u16u_C3R
// L = L * 65535. / 100.
// a = (a + 128.)* 255
// b = (a + 128.)* 255
// where:
// normalizing multipliers
// Yn = 1.0 * 255
// Xn = 0.950455 * 255
// Zn = 1.088753 * 255
//
// L component values are in the range [0..100], a and b component values are
// in the range [-128..127].
//
// The CIELab to RGB conversion is performed as follows. At first
// a Lab image is converted to the XYZ image
// for ippiLabToBGR_8u_C3R
// L = L * 100./ 255.
// a = (a - 128.)
// b = (a - 128.)
// or for ippiLabToBGR_16u8u_C3R
// L = L * 100./ 65535.
// a = (a / 255 - 128.)
// b = (b / 255 - 128.)
// X = Xn * ( P + a / 500 )^3
// Y = Yn * P^3
// Z = Zn * ( P - b / 200 )^3
// where P = (L + 16) / 116
// Then the XYZ image is converted to the RGB color model (see the function
// ippXYZToRGB_8u_C3R).
//
*/
IPPAPI(IppStatus, ippiBGRToLab_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst,int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiLabToBGR_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst,int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiBGRToLab_8u16u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp16u* pDst,int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiLabToBGR_16u8u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp8u* pDst,int dstStep, IppiSize roiSize))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippReduceBits
// Purpose: Reduces the bit resolution of an image.
// Parameters:
// pSrc Pointer to the source image .
// pDst Pointer to the destination image .
// roiSize Size of ROI in pixels.
// srcStep Step in bytes through the source image to jump on the next line
// dstStep Step in bytes through the destination image to jump on the next line
// noise The number specifying the amount of noise added (as a percentage of a range [0..100])
// levels The number of output levels for halftoning (dithering)[2.. MAX_LEVELS],
// where MAX_LEVELS is 0x01 << depth, and depth is depth of the destination image
// dtype The type of dithering to be used. The following types are supported:
// ippDitherNone no dithering is done
// ippDitherStucki Stucki's dithering algorithm
// ippDitherFS Floid-Steinberg's dithering algorithm
// ippDitherJJN Jarvice-Judice-Ninke's dithering algorithm
// ippDitherBayer Bayer's dithering algorithm
// RGB values for the 32f data type should be in the range [0..1]
// Returns:
// ippStsNullPtrErr pSrc == NULL, or pDst == NULL
// ippStsStepErr srcStep or dstStep is less than or equal to zero
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsNoiseValErr noise has illegal value
// ippStsDitherLevelsErr levels value is out of admissible range
// ippStsNoErr No errors
*/
IPPAPI(IppStatus, ippiReduceBits_8u_C1R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_8u_C3R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_8u_AC4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_8u_C4R,(const Ipp8u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16u_C1R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16u_C4R,(const Ipp16u* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16u8u_C1R,(const Ipp16u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16u8u_C3R,(const Ipp16u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16u8u_AC4R,(const Ipp16u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16u8u_C4R,(const Ipp16u* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16s_C1R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16s_C3R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16s_AC4R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16s_C4R,(const Ipp16s* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16s8u_C1R,(const Ipp16s* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16s8u_C3R,(const Ipp16s* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16s8u_AC4R,(const Ipp16s* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_16s8u_C4R,(const Ipp16s* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f8u_C1R,(const Ipp32f* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f8u_C3R,(const Ipp32f* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f8u_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f8u_C4R,(const Ipp32f* pSrc,int srcStep,Ipp8u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f16u_C1R,(const Ipp32f* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f16u_C3R,(const Ipp32f* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f16u_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f16u_C4R,(const Ipp32f* pSrc,int srcStep,Ipp16u* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f16s_C1R,(const Ipp32f* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f16s_C3R,(const Ipp32f* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f16s_AC4R,(const Ipp32f* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
IPPAPI(IppStatus, ippiReduceBits_32f16s_C4R,(const Ipp32f* pSrc,int srcStep,Ipp16s* pDst, int dstStep,IppiSize roiSize,
int noise, IppiDitherType dtype, int levels))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiColorTwist
//
// Purpose: Applies a color-twist matrix to an image.
// |R| | t11 t12 t13 t14 | |r|
// |G| = | t21 t22 t23 t24 | * |g|
// |B| | t31 t32 t33 t34 | |b|
//
// R = t11*r + t12*g + t13*b + t14
// G = t21*r + t22*g + t23*b + t24
// B = t31*r + t32*g + t33*b + t34
//
// Returns:
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsStepErr One of the step values is zero or negative
// ippStsNoErr OK
//
// Parameters:
// pSrc Pointer to the source image
// srcStep Step through the source image
// pDst Pointer to the destination image
// dstStep Step through the destination image
// pSrcDst Pointer to the source/destination image (in-place flavors)
// srcDstStep Step through the source/destination image (in-place flavors)
// roiSize Size of the ROI
// twist An array of color-twist matrix elements
*/
IPPAPI ( IppStatus, ippiColorTwist32f_8s_C3R, ( const Ipp8s* pSrc, int srcStep, Ipp8s* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8s_C3IR, ( Ipp8s* pSrcDst, int srcDstStep, IppiSize roiSize,
const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8s_AC4R, ( const Ipp8s* pSrc, int srcStep, Ipp8s* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8s_AC4IR, ( Ipp8s* pSrcDst, int srcDstStep, IppiSize roiSize,
const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8s_P3R, ( const Ipp8s* pSrc[3], int srcStep,
Ipp8s* pDst[3], int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8s_IP3R, ( Ipp8s* pSrcDst[3], int srcDstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8u_C3R, ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8u_C3IR, ( Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize,
const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8u_AC4R, ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8u_AC4IR, ( Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize,
const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8u_P3R, ( const Ipp8u* pSrc[3], int srcStep,
Ipp8u* pDst[3], int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_8u_IP3R, ( Ipp8u* pSrcDst[3], int srcDstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16u_C3R, ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16u_C3IR, ( Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize,
const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16u_AC4R, ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16u_AC4IR, ( Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize,
const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16u_P3R, ( const Ipp16u* pSrc[3], int srcStep,
Ipp16u* pDst[3], int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16u_IP3R, ( Ipp16u* pSrcDst[3], int srcDstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16s_C3R, ( const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16s_C3IR, ( Ipp16s* pSrcDst, int srcDstStep, IppiSize roiSize,
const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16s_AC4R, ( const Ipp16s* pSrc, int srcStep, Ipp16s* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16s_AC4IR, ( Ipp16s* pSrcDst, int srcDstStep, IppiSize roiSize,
const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16s_P3R, ( const Ipp16s* pSrc[3], int srcStep,
Ipp16s* pDst[3], int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist32f_16s_IP3R, ( Ipp16s* pSrcDst[3], int srcDstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist_32f_C3R, ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist_32f_C3IR, ( Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize,
const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist_32f_AC4R, ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist_32f_AC4IR, ( Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize,
const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist_32f_P3R, ( const Ipp32f* pSrc[3], int srcStep,
Ipp32f* pDst[3], int dstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
IPPAPI ( IppStatus, ippiColorTwist_32f_IP3R, ( Ipp32f* pSrcDst[3], int srcDstStep,
IppiSize roiSize, const Ipp32f twist[3][4] ))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiColorTwist_32f_C4R
//
// Purpose: Applies a color-twist matrix to an image.
// |R| | t11 t12 t13 t14 | |r|
// |G| = | t21 t22 t23 t24 | * |g|
// |B| | t31 t32 t33 t34 | |b|
// |W| | t41 t42 t43 t44 | |w|
// R = t11*r + t12*g + t13*b + t14*w
// G = t21*r + t22*g + t23*b + t24*w
// B = t31*r + t32*g + t33*b + t34*w
// W = t41*r + t42*g + t43*b + t44*w
//
// Returns:
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsStepErr One of the step values is zero or negative
// ippStsNoErr OK
//
// Parameters:
// pSrc Pointer to the source image
// srcStep Step through the source image
// pDst Pointer to the destination image
// dstStep Step through the destination image
// roiSize Size of the ROI
// twist An array of color-twist matrix elements
*/
IPPAPI ( IppStatus, ippiColorTwist_32f_C4R,( const Ipp32f* pSrc, int srcStep,Ipp32f* pDst, int dstStep,
IppiSize roiSize, const Ipp32f twist[4][4]))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiGammaFwd, ippiGammaInv
//
// Purpose: Performs gamma-correction of an RGB image (ippiGammaFwd);
// converts a gamma-corrected RGB image back to the original (ippiGammaInv).
// 1). Gamma-correction:
// for R,G,B < 0.018
// R' = 4.5 * R
// G' = 4.5 * G
// B' = 4.5 * B
// for R,G,B >= 0.018
// R' = 1.099 * (R**0.45) - 0.099
// G' = 1.099 * (G**0.45) - 0.099
// B' = 1.099 * (B**0.45) - 0.099
//
// 2). Conversion to the original:
// for R',G',B' < 0.0812
// R = R' / 4.5
// G = G' / 4.5
// B = B' / 4.5
// for R',G',B' >= 0.0812
// R = (( R' + 0.099 ) / 1.099 )** 1 / 0.45
// G = (( G' + 0.099 ) / 1.099 )** 1 / 0.45
// B = (( B' + 0.099 ) / 1.099 )** 1 / 0.45
//
// Note: example for range[0,1].
//
// Returns:
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field with zero or negative value
// ippStsStepErr One of the step values is less than or equal to zero
// ippStsGammaRangeErr vMax - vMin <= 0 (for 32f)
// ippStsNoErr OK
//
// Parameters:
// pSrc Pointer to the source image (pixel-order data). An array
// of pointers to separate source color planes (planar data)
// srcStep Step through the source image
// pDst Pointer to the destination image (pixel-order data). An array
// of pointers to separate destination color planes (planar data)
// dstStep Step through the destination image
// pSrcDst Pointer to the source/destination image (in-place flavors)
// srcDstStep Step through the source/destination image (in-place flavors)
// roiSize Size of the ROI
// vMin, vMax Minimum and maximum values of the input 32f data.
*/
IPPAPI(IppStatus,ippiGammaFwd_8u_C3R, ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_8u_C3IR, ( Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_8u_C3R, ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_8u_C3IR, ( Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_8u_AC4R, ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_8u_AC4IR, ( Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_8u_AC4R, ( const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_8u_AC4IR, ( Ipp8u* pSrcDst, int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_8u_P3R, ( const Ipp8u* pSrc[3], int srcStep, Ipp8u* pDst[3], int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_8u_IP3R, ( Ipp8u* pSrcDst[3], int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_8u_P3R, ( const Ipp8u* pSrc[3], int srcStep, Ipp8u* pDst[3], int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_8u_IP3R, ( Ipp8u* pSrcDst[3], int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_16u_C3R, ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_16u_C3IR, ( Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_16u_C3R, ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_16u_C3IR, ( Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_16u_AC4R, ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_16u_AC4IR, ( Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_16u_AC4R, ( const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_16u_AC4IR, ( Ipp16u* pSrcDst, int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_16u_P3R, ( const Ipp16u* pSrc[3], int srcStep, Ipp16u* pDst[3], int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_16u_IP3R, ( Ipp16u* pSrcDst[3], int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_16u_P3R, ( const Ipp16u* pSrc[3], int srcStep, Ipp16u* pDst[3], int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaInv_16u_IP3R, ( Ipp16u* pSrcDst[3], int srcDstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiGammaFwd_32f_C3R, ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaFwd_32f_C3IR, ( Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaInv_32f_C3R, ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaInv_32f_C3IR, ( Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaFwd_32f_AC4R, ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaFwd_32f_AC4IR, ( Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaInv_32f_AC4R, ( const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaInv_32f_AC4IR, ( Ipp32f* pSrcDst, int srcDstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaFwd_32f_P3R, ( const Ipp32f* pSrc[3], int srcStep, Ipp32f* pDst[3], int dstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaFwd_32f_IP3R, ( Ipp32f* pSrcDst[3], int srcDstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaInv_32f_P3R, ( const Ipp32f* pSrc[3], int srcStep, Ipp32f* pDst[3], int dstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
IPPAPI(IppStatus,ippiGammaInv_32f_IP3R, ( Ipp32f* pSrcDst[3], int srcDstStep, IppiSize roiSize, Ipp32f vMin, Ipp32f vMax ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippiToneMapLinear_32f8u_C1R ippiToneMapMean_32f8u_C1R
// Purpose: Convert HDRI into the LDRI. In the other words they map a dst Image into the range [0..255]
//
// Input Arguments:
// pSrc - pointer to the HDRI.
// srcStep - step through the source image
// Output Arguments:
// pDst - pointer to the LDRI.
// dstStep - step through the source image
// Returns:
// ippStsNoErr OK
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field with zero or negative value
// Notes:
// ippiToneMapLinear_32f_C1RI - applies Linear Scale-Factor method to src image.
// ippiToneMapMean_32f_C1RI - applies Mean Value method to src image.
//
*/
IPPAPI(IppStatus,ippiToneMapLinear_32f8u_C1R,(const Ipp32f* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus,ippiToneMapMean_32f8u_C1R, (const Ipp32f* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippiYCbCr420To411_8u_P3R ippiYCbCr420To411_8u_P3R ippiYCbCr1620To420_8u_P3R
// Purpose: Converts an YCbCr420 to YCbCr411 image,
// YCbCr411 to YCbCr420 image,
// YCbCr420 to YCbCr1620 image,
// YCbCr1620 to YCbCr420 image.
//
// Input Arguments:
// pSrc - pointer to the source image.
// srcStep - step through the source image
// roiSize - Size of the ROI
// Output Arguments:
// pDst - pointer to the destination image.
// dstStep - step through the destination image
// Returns:
// ippStsNoErr OK
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize has a field with zero or negative value
//
*/
IPPAPI(IppStatus, ippiYCbCr420To411_8u_P3R, ( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize) )
IPPAPI(IppStatus, ippiYCbCr411To420_8u_P3R, ( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize) )
IPPAPI(IppStatus, ippiYCbCr420To1620_8u_P3R, ( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize) )
IPPAPI(IppStatus, ippiYCbCr1620To420_8u_P3R, ( const Ipp8u* pSrc[3], int srcStep[3], Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize) )
/* /////////////////////////////////////////////////////////////////////////////
//
// Names: ippiRGBToRGB565_8u16u_C3R
// ippiBGRToBGR565_8u16u_C3R
//
// Purpose: Converts RGB(BGR) image to RGB565(BGR565) image and vice versa
//
// Returns:
// ippStsNoErr No errors
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr The roiSize has a field with negative or zero value
// ippStsStepErr One of steps is less than or equal to zero
//
// Parameters:
// pSrc Pointers to the source images
// srcStep Steps through the source image
// pDst Pointer to the destination image
// dstStep Step through the destination image
// roiSize Size of the image ROI
//
*/
IPPAPI(IppStatus, ippiRGBToRGB565_8u16u_C3R,(const Ipp8u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGRToBGR565_8u16u_C3R,(const Ipp8u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiRGB565ToRGB_16u8u_C3R,(const Ipp16u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
IPPAPI(IppStatus, ippiBGR565ToBGR_16u8u_C3R,(const Ipp16u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippiCFAToRGB_8u_C1C3R
// ippiCFAToRGB_16u_C1C3R
//
// Purpose: Bayer transform. Converts color filter array image to RGB image
// Returns:
// ippStsNoErr No errors
// ippStsNullPtrErr One of the pointers is NULL
// ippStsBadArgErr Wrong value of grid
// ippStsSizeErr The srcSize.width<2 or the srcSize.height<2 or
// the roiSize has a field with negative or zero value
// Parameters:
// pSrc Pointers to the source image
// srcRoi ROI in source image(top left corner and size)
// srcSize Size of source image
// srcStep Steps through the source image
// pDst Pointer to the destination image
// dstStep Step through the destination image
// grid Type of baeyers grid
// interpolation Reserved, must be 0
//
*/
#if !defined( _OWN_BLDPCS )
typedef enum {
ippiBayerBGGR,
ippiBayerRGGB,
ippiBayerGBRG,
ippiBayerGRBG
} IppiBayerGrid;
#endif /* _OWN_BLDPCS */
IPPAPI(IppStatus, ippiCFAToRGB_8u_C1C3R,(const Ipp8u* pSrc, IppiRect srcRoi, IppiSize srcSize, int srcStep,
Ipp8u* pDst, int dstStep, IppiBayerGrid grid, int interpolation))
IPPAPI(IppStatus, ippiCFAToRGB_16u_C1C3R,(const Ipp16u* pSrc, IppiRect srcRoi, IppiSize srcSize, int srcStep,
Ipp16u* pDst, int dstStep, IppiBayerGrid grid, int interpolation))
/* ////////////////////////////////////////////////////////////////////////////
// Name: ippiCbYCr422ToYCbCr420_Interlace_8u_C2P3R,
// ippiYCbCr420ToCbYCr422_Interlace_8u_P3C2R
// ippiYCbCr422To420_Interlace_8u_P3R
// ippiYCbCr420To422_Interlace_8u_P3R
// Purpose: Converts 2-channel interlaced UYVY, YUYV C2 and P3 images
// to the P3 YUV420 image and vice versa
//
// Return:
// ippStsNoErr Ok
// ippStsNullPtrErr One of the pointers is NULL
// ippStsSizeErr roiSize.width less than 2 or roiSize.height less than 4
// ippStsDoubleSize roiSize.width is not multiples of 2 or
// roiSize.height is not multiples of 4
//
// Parameters:
// pSrc Pointer(an array of pointers) to the source image
// srcStep Step(an array of steps) through the source image
// roiSize Size of the ROI, should be multiple of 2(width) and 4(height)
// pDst Pointer(an array of pointers) to destination image.
// dstStep Step(an array of steps) through the destination image
// Notes:
// UYVU422 to YUV420 uses following formulas,
// Yd = Ys
// U(V)d0 = (3*U(V)s0 + U(V)s2 + 2) / 4
// U(V)d1 = ( U(V)s1 + 3 * U(V)s3 + 2) / 4,
// where Us0(1), Us2(3) are interleaved adjacent lines
//
// YUV420 to UYVU422 uses following formulas,
// U(V)d0 = (5*U(V)s0 + 3*U(V)s2 + 4) / 8;
// U(V)d1 = (7*U(V)s1 + U(V)s3 + 4) / 8;
// U(V)d2 = ( U(V)s0 + 7*U(V)s2 + 4) / 8;
// U(V)d3 = (3*U(V)s1 + 5*U(V)s3 + 4) / 8;
//
//
//
*/
IPPAPI(IppStatus, ippiCbYCr422ToYCbCr420_Interlace_8u_C2P3R,(const Ipp8u* pSrc,
int srcStep,Ipp8u* pDst[3],int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr422To420_Interlace_8u_P3R,(const Ipp8u* pSrc[3],
int srcStep[3], Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420ToCbYCr422_Interlace_8u_P3C2R,(const Ipp8u* pSrc[3],
int srcStep[3], Ipp8u* pDst, int dstStep, IppiSize roiSize))
IPPAPI(IppStatus, ippiYCbCr420To422_Interlace_8u_P3R,(const Ipp8u* pSrc[3],
int srcStep[3], Ipp8u* pDst[3], int dstStep[3], IppiSize roiSize))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ippiDemosaicAHD_8u_C1C3R
// ippiDemosaicAHD_16u_C1C3R
//
// Purpose: Converts color filter array image to RGB image wih AHD algorithm.
// Reference: K. Hirakawa, T.W. Parks, "Adaptive Homogeneity-Directed Demosaicing Algorithm,"
// IEEE Trans. Image Processing, March 2005,
// Link: h__p://www.accidentalmark.com/research/papers/Hirakawa05MNdemosaicTIP.pdf
//
// Returns:
// ippStsNoErr No errors
// ippStsNullPtrErr One of the pointers is NULL
// ippStsBadArgErr Wrong value of grid
// ippStsSizeErr The srcSize.width<5 or the srcSize.height<5 or
// the roiSize has a field with negative or zero value
// Parameters:
// pSrc Pointers to the source image
// srcRoi ROI in source image(top left corner and size)
// srcSize Size of source image
// srcStep Steps through the source image
// pDst Pointer to the destination image
// dstStep Step through the destination image
// grid Type of baeyers grid
// pTmp Pointer to the temporary image of (srcRoi.width + 6, 30) size
// tmpStep Steps through the temporary image
//
*/
IPPAPI(IppStatus, ippiDemosaicAHD_8u_C1C3R,(const Ipp8u* pSrc, IppiRect srcRoi, IppiSize srcSize, int srcStep,
Ipp8u* pDst, int dstStep, IppiBayerGrid grid, Ipp8u* pTmp, int tmpStep))
IPPAPI(IppStatus, ippiDemosaicAHD_16u_C1C3R,(const Ipp16u* pSrc, IppiRect srcRoi, IppiSize srcSize, int srcStep,
Ipp16u* pDst, int dstStep, IppiBayerGrid grid, Ipp16u* pTmp, int tmpStep))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippiRGBToYCoCg_8u_C3P3R
//
// Purpose:
// RGB to YCoCg color conversion
//
// Parameter:
// pSrc pointer to the input RGB data
// srcStep line offset in input data
// pDst pointer to pointers to the output YCoCg data.
// dstStep line offset in output data
// roiSize ROI size
//
// Returns:
// IppStatus
//
*/
IPPAPI(IppStatus, ippiRGBToYCoCg_8u_C3P3R,(
const Ipp8u* pSrc,
int srcStep,
Ipp8u* pDst[3],
int dstStep,
IppiSize roi))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ippiYCoCgToRGB_8u_P3C3R
//
// Purpose:
// YCoCg to RGB color conversion
//
// Parameter:
// pSrc pointer to pointers to the input YCoCg data.
// srcStep line offset in input data
// pDst pointer to the output RGB data.
// dstStep line offset in output data
// roiSize ROI size
//
// Returns:
// IppStatus
//
*/
IPPAPI(IppStatus, ippiYCoCgToRGB_8u_P3C3R,(
const Ipp8u* pSrc[3],
int srcStep,
Ipp8u* pDst,
int dstStep,
IppiSize roi))
#ifdef __cplusplus
}
#endif
#if defined (_IPP_STDCALL_CDECL)
#undef _IPP_STDCALL_CDECL
#define __stdcall __cdecl
#endif
#endif /* __IPPCC_H__ */
/* ////////////////////////////// End of file /////////////////////////////// */
Reference in a new issue View git blame Copy permalink