3025 lines
169 KiB
C
3025 lines
169 KiB
C
/* /////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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 /////////////////////////////// */
|
|
|