Note: the links to the IPP samples provided on this page are licensed under the Intel End User License Agreement, and are for Intel IPP 7.0.7.
-- Follow this link if you need the Intel IPP samples for Intel IPP 6.1 update 6.
-- The 7.0 samples can also be used with the current Parallel Studio, Composer and XE product suites.
-- Intel IPP samples are also distributed via the Intel Registration Center with your product downloads.

To help jumpstart your application development we provide free code samples to illustrate the use of the Intel® Integrated Performance Primitives (Intel® IPP) library in real applications.

The Intel IPP code samples are available for the Windows*, Linux* and Mac OS* operating systems. Instructions on how to build each sample can be found in sample-specific readme files located each sample's main directory. Some samples include more detailed documentation in a doc directory, usually in the form of a PDF file.

The Intel IPP samples are distributed in multiple parts. Not every sample is available for every operating system. Sample files here are only tested against the latest version of the Intel IPP library and may not work or build with older versions of the library.

By downloading any sample package you accept the End User License Agreement

Sample File	Windows	Linux	Mac OS X
Main Samples	download	download	download
UIC Executables	download	download	download
DMIP Samples	download
Cryptography Samples	download	download	download

Main Samples Download: includes samples for Library Linking & Advanced Usage, Audio & Video Coding, Data Compression, Image Processing, Computer Vision, Realistic Rendering, Language Interface, Signal Processing, Speech Coding, String Processing and UIC source.

UIC Executables Download: is provided as a convenience. The Unified Image Codec download contains pre-built executable binaries.

Note: UIC source is located in the "Main Samples" download.

DMIP Samples Download: includes source code, pre-built executables and the Intel IPP DMIP library.

Cryptography Samples Download: for OpenSSL Crypto and Fortran 90 language support using the Intel IPP cryptography domain.

Note: Release 7.0 of the Intel IPP library incorporates a new interfaces directory that is part of the product installation. Code located in the interfaces directory is designated by the INTERFACES tag on this page and is no longer part of the Intel IPP samples, please see your product installation directories.

Each sample description (below) includes a short title followed by a directory reference (such as advanced-usage\linkage\mergedlib) and one to three OS icons indicating which operating systems are supported by the sample. The directory refers to where you will find that sample within the ipp-samples directory, after you have downloaded and extracted the sample file(s) onto your system.

Note: every sample file includes a tools directory that can be safely overwritten when you extract the contents of the samples archive file.

Use of the Intel IPP samples is subject to the terms and conditions of the Intel End User License Agreement (EULA).

Note: many of the code samples illustrate the use of Intel IPP functions in support of international standards, which are promoted by various standards bodies, such as ISO, ITU-T and other organizations. Commercial implementations of these standards may require licenses from various entities, including Intel Corporation. Such industry standard licensing is not included as part of the Intel IPP library, nor is it provided with these example illustrations.

Library Linking and Advanced Usage

MAIN - Custom DLLs and Static Libraries - advanced-usage\linkage\custom[dll|so|lib] -
Use custom DLLs, threaded and non-threaded merged static libraries, and different linking methodologies to produce smaller sized applications.

MAIN - Using Merged Static Libraries - advanced-usage\linkage\mergedlib -
How to link with the Intel IPP merged static libraries.

MAIN - User-Defined Memory Allocation - advanced-usage\linkage\i_malloc -
Customize Intel IPP memory management by replacing the standard malloc(), calloc(), realloc(), and free() functions with your own memory allocation routines.

MAIN - Using IPP in Kernel Mode - advanced-usage\ippsdrv -
Illustrates using static dispatching of the Intel IPP library for kernel mode (ring zero) drivers and applications.

MAIN - Windows CE for IA-32 Architecture - advanced-usage\wincex86 -
How to use the Intel IPP library in applications that will run in the Windows CE environment.

MAIN - CPU Information Utility - advanced-usage\cpuinfo -
An application that provides useful information regarding the instruction set capabilities and other useful parameters associated with your processor.

Audio and Video Coding

The following samples utilize the Unified Media C++ Classes (UMC), a C++ framework designed to simplify the development of advanced codecs, to implement some applications that demonstrate Intel IPP audio and video acceleration features.

MAIN - Simple Media Player - audio-video-codecs\application\simple_player -
A multi-format video player for multiple platforms using the Intel IPP audio and video coding functions and image and signal processing functions. The player supports the H.264, H.263, H.261, AVS, VC1, Motion JPEG, MPEG-4, MPEG-2, and DV video formats and the MP3 and AAC audio formats.

MAIN - Console H.264 Video Decoding - audio-video-codecs\application\umc_h264_dec_con -
A command-line H.264 video decoding application using the Intel IPP signal processing, image processing, video coding functions and UMC framework.

MAIN - Video Encoder - audio-video-codecs\application\umc_video_enc_con -
A command-line video encoding application using the Intel IPP audio and video coding functions, and image and signal processing functions. It supports the H.264, H.263, H.261, MPEG-4, MPEG-2 and DV video formats.

Data Compression

MAIN - General Data Compression Example - data-compression\ipp_compress -
An example of a general-purpose compress and decompress function based on the Intel IPP data compression primitives. The resulting compress and decompress applications include support for Huffman, Run Length Encoding (RLE), Move-To-Front transform (MTF), Burrows-Wheeler Transform (BWT), General Interval Transform (GIT), and Ziv-Lempel-Storer-Szymanski (LZSS) dictionary-based compression algorithms.

Note: the following IPP implementations of popular compression libraries are now distributed as part of the main IPP library product. They are located in the new interfaces directory within the IPP library directories. These high-level IPP components are officially supported elements of the IPP library and are, therefore, no longer part of the samples distribution.

INTERFACES - bzip2-Compatible Library - data-compression\ipp_bzip2 -
An implementation of the bzip2/libbzip2 application and library (http://www.bzip.org/) using the Intel IPP data compression functions library. The Intel IPP version of the bzip2 library implements a lossless, block-sorting data compression algorithm that includes threading optimization improvements.

INTERFACES - gzip-Compatible Library - data-compression\ipp_gzip -
A multi-threaded lossless data compression library that is compatible with the gzip format as defined by version 4.3 of RFC 1952 by use of the Intel IPP data compression domain functions. This sample illustrates significant performance improvements by means of the OpenMP library and other methods of parallel processing on a multi-core processor.

INTERFACES - zlib-Compatible Library - data-compression\ipp_zlib -
A version of the zlib-compatible data compression library using the optimized LZ77 and Huffman coding functions in the Intel IPP library. Based on version 1.2.3 of the zlib library (http://www.zlib.net/).

INTERFACES - lzop-Compatible Library - data-compression\ipp_lzopack -
Using dictionary-based IPP functions based on the Lempel-Ziv-Oberhumer (LZO) algorithm. The compressed data format is similar to Oberhumer's LZOP file format (http://www.lzop.org) although it differs by file header structure.

Image Coding (JPEG, JPEG2000, PNG, etc.)

The "UIC Samples" download contains only pre-built executables; the UIC source code is part of the "Main Samples" download.

MAIN & UIC - Unified Image Codec (UIC) Class - image-codecs\uic -
UIC is a collection of C++ classes designed for use with image processing applications. The UIC framework provides encode and decode support for the following image formats: BMP (Windows Bitmap), DDS (DirectDraw Surface), JPEG, JPEG2000, PNG, and PNM (Netpbm). Source code for two applications, picnic and uic_transcoder_con, are provided to illustrate the use of the UIC classes. Ready to run executables of these two applications are provided in a separate download (see the download table above).

Note: the UIC class documentation can be found in the image-codecs\uic\src\doc directory that is part of the sample distribution.

MAIN & UIC - Picnic and uic_transcoder_con Demo Applications - image-codecs\uic\src\application -
Ready to run executable versions of the Picnic and uic_transcoder_con applications are available in a separate download, to demonstrate use of the UIC classes. The source code for both applications is in the general sample download package. Picnic demonstrates JPEG/JPEG2000 encoding/decoding; RLE encoding/decoding; and image filtering and computer vision algorithms such as face detection, inpainting, and image segmentation. The uic_transcoder_con application is a simple command-line utility that demonstrates how to use the UIC classes to implement encoding and decoding of image files.

Note: to build the picnic application you must download and install the Nokia* Qt* GUI library appropriate for your OS from www.qtsoftware.com.

MAIN - Integration with the Independent JPEG Group (IJG) Library - image-codecs\ijg -
Demonstrates how to use the Intel IPP library to increase the performance of the Independent JPEG Group (IJG) library.

Image Processing, Generation and Editing

MAIN - Tiled Image Processing - image-processing\image-tiling -
Demonstrates using Intel IPP functions to process tiled images.

MAIN - 2D Wavelet Transform - image-processing\2d-wavelet-transform -
Illustrates the use of the two-dimensional wavelet transform functions to implement a Haar transform.

MAIN - C++ Image Processing Classes - image-processing\image-processing-templates -
General examples illustrating the usage of Intel IPP functions in C++ image processing.

MAIN - ippiDemo (Image Processing Demo) - image-processing\image-processing-functions -
This sample exercises nearly all of the ippIP and ippCC domain functions, and a large part of the ippCV domain functions.

MAIN - Simplified Image Processing Demo - image-processing\image-processing-mfc -
This sample is a simplified version of the ippiDemo above, and illustrates the use of the IPP image processing functions.

MAIN - Intel Image Processing Library (IPL) - image-processing\ipl-ipp -
Based upon the Intel® Image Processing Library (IPL), this sample contains a set of low-level image manipulation functions that perform filtering, threshold detection, and transformation (FFT, DCT, geometric), as well as arithmetic and morphological operations on images. The library uses a flexible image format, supporting channels of 1, 8, 16 and 32-bit integer pixels, as well as 32-bit floating point pixels, with an arbitrary number of channels per image. Conversion to and from the Windows* DIB (device independent bitmap) image format is supported, as are conversions between color and gray-scale.

MAIN - 3D Math Functions - image-processing\3dmath -
Illustrates the 3D math functionality designed to support the Microsoft Direct3D interface.

Deferred Mode Image Processing (DMIP)

The DMIP samples are not part of the "Main Samples" download, you must download the separate "DMIP Samples" file.

DMIP - Cache-Optimized Pipelined Image Processing Library - image-processing\dmip -
The DMIP library provides an adaptable multi-threading platform on which to build very high-performance parallel processing applications. It utilizes Intel IPP functions to operate on data partitioned for optimum cache utilization in parallel pipelines of execution threads.

This DMIP sample for Intel IPP is only available for Windows* and includes source code for applications that utilize the pre-built DMIP library to demonstrate the DMIP algorithms. Limitations include: (1) the DMIP harmonization filter was developed for gray scale images and may give incorrect results when used with color images. (2) The size of the automatically chosen DMIP slice may not be optimal for multi-threaded performance and must be set manually. (3) In some cases DMIP threading performance may not scale properly when the number of CPU cores is greater than two.

Computer Vision

MAIN - Face Detection - image-processing\Face_Detection -
How to use the Intel IPP library to implement a Haar classifier face detection algorithm.

Realistic Rendering

MAIN - Ray-Tracing and Realistic Rendering - realistic-rendering\ray-tracing -
This example illustrates how to use the ipprr domain primitives to implement a Whitted-stile ray tracer. This sample cannot be used to create images larger that 2048x2048 pixels and using no more then 32 threads for models up to 2 million triangles.

MAIN - 3D Viewer - realistic-rendering\3d-viewer -
This sample supports the mdla and tbj scene formats with a JPEG texture file. The sample implements the following "next tracers": TracerEyeMat, TracerShdMat, TracerSpecMat, TracerEye and TracerShd.

Language Interface Support

MAIN - Microsoft .NET (C#) - language-interface\csharp -
Demonstrates how to use Intel IPP when developing applications in the Microsoft C# environment. Includes wrapper classes to support Intel IPP string manipulations, image, signal processing, color conversion, cryptography, data compression, JPEG, matrix and vector math.

MAIN - C++ Applications - language-interface\cpp -
Illustrates how to create a C++ application that performs simple testing of the functionality of the infinite impulse response (IIR) filters created with the Intel IPP signal processing domain of functions.

MAIN - Java Applications - language-interface\java -
Using the IPP library from the Java language. This example uses the Intel IPP image processing functions to perform filtrating as well as morphological and geometric operations.

Signal Processing

MAIN - ippsDemo (Signal Processing Demo) - signal-processing\signal-processing-functions -
Demonstrates the Intel IPP signal processing functions via a general purpose GUI application.

MAIN - Signal Processing with the Microsoft Foundation Classes (MFC) - signal-processing\signal-processing-mfc -
Demonstrates the Intel IPP usage for signal processing using an MFC-based GUI Interface.

MAIN - Viterbi Decoder - signal-processing\viterbi -
How to use the Intel IPP functions to create a Viterbi decoder.

Speech Coding

The Unified Speech Component (USC) interface is a C language framework designed for implementation of speech codecs, echo cancellers and other voice processing modules using the Intel IPP library. Most of the following speech coding samples utilize this extendible USC interface.

MAIN - Speech Codec Application - speech-codecs\application\usc_speech_codec -
The speech codec sample supports encoding and decoding compliant with 3GPP TS 26 071, 073, 171, 173, 174, 190-194, 273, 274, 290, ITU-T G.711/I/II, G.722, G.722.1, G.723.1/A, G.726/A, G.728G//I/J/H, G.729/A/B/D/E/I/C/C+, and G.729.1 recommendations, the ETSI GSM 06.90-06.94, 06.10-06.12, 06.31-06.32 recommendations, and Microsoft Real-Time Audio.

MAIN - Noise Reduction (NR) and Voice Activity Detection (VAD) - speech-codecs\application\usc_nr -
The NR sample processes PCM narrow band data (16-bit 8000Hz). The VAD sample processes PCM narrow band (16-bit 8000Hz) or wide band (16-bit 16000Hz) data. A variety of VAD algorithms are supported including G.723, G.729, AMRWB and the IPP VAD algorithm (originally released as an IPP speech-recognition audio-processing sample).

MAIN - Echo Cancellation - speech-codecs\application\usc_ec -
A console application using Intel IPP speech coding functions to perform echo cancellation. This sample illustrates building a "digital terminals" device compliant with ITU-T G.167, G.168-2004, P.330, P.340 specifications.

MAIN - Tone Detector - speech-codecs\application\usc_tones -
How to use the Intel IPP speech coding functions to perform echo cancellation. This sample complies with ITU G.168-200 2 and Q.23 specifications.

MAIN - Microsoft RT Audio Support - speech-codecs\application\umc_speech_rtp_codec -
The UMC RTP speech codec sample supports audio compression and decompression using Intel IPP to and from a variety of RTP formats in compliance with 3GPP TS 26 171, 173, 174, 190-194, 273, 274, 290 specifications, ITU-T G.722, G.722.1, G.722.2, G.723.1/A, G.726/A, G.728/I/G/H/J, G.729/A/B/D/E/I/C/C+, G.711/I/II recommendations, ETSI GSM 06.10-06.12, 06.31-06.32, 06.90-06.94 specifications, and RFC 4867. The encoder compresses audio data from a WAV file, storing the result as a compressed rtpdump file. The decoder performs the reverse operation.

String Processing

MAIN - ippgrep - Regular Expression Matching - string-processing\ippgrep -
An application that uses the IPP string processing functions to perform Perl-compatible regular expression pattern matching.

Cryptography

These cryptography samples are only available in the "Cryptography Samples" download and are not part of the "Main Samples" download. In addition, the Intel IPP cryptography domain binaries (the linkable library components) must be downloaded separately from the main IPP library. See the note below for a link with more information on how to obtain a copy of the Intel IPP cryptography library.

CRYPTOGRAPHY - OpenSSL Crypto Layer Support - cryptography\openssl-ipp -
Demonstrates use of the Intel IPP in support of the OpenSSL Crypto layer.

CRYPTOGRAPHY - Fortran 90 Language Support - language-interface\f90-crypto -
Using the Intel IPP cryptography functions with the Fortran 90 language.

Note: The Intel IPP Cryptography library is a restricted download, in order to comply with US export laws. Please go here for more information on how to obtain the IPP Cryptography library.

 

This software is subject to the U.S. Export Administration Regulations and other U.S. law, and may not be exported or re-exported to certain countries (Burma, Cuba, Iran, Libya, North Korea, Sudan, and Syria) or to persons or entities prohibited from receiving U.S. exports (including Denied Parties, Specially Designated Nationals, and entities on the Bureau of Export Administration Entity List or involved with missile technology or nuclear, chemical or biological weapons).

{
      Ipp32f tmpMinS,tmpMaxS;

      Ipp32f m_PeakAmpdB;

       ippsMinMax_32f(fileData, sizeSamples, &tmpMinS, &tmpMaxS);

      Ipp32f maxAbsSample = IPP_MAX(fabs(tmpMinS),fabs(tmpMaxS));

      if(maxAbsSample > 0) {

            m_PeakAmpdB = 20.f * log10(maxAbsSample / 32768.f);

      } else {

      m_PeakAmpdB = -91.f;

      }

}

In this code, Amp(dB) = 20 lg(S/N), where S- random signal, N - noise. If S=1 then Amp(dB) = 20 lg(1/N) = -91 – this is silence.

1. Build system requirement

Software:
•   Intel Parallel Studio 2011 and Microsoft* Visual Studio 2005 and later
•   (optional)  install static ipp library separately from http://software.intel.com/en-us/articles/intel-ipp-static-libraries/

Hardware:  The latest dual-core/Quad Core machine with Windows xp/Windows Vista/Windows 7

2. Download and Unzip the Resize_Image_PS_VS2005.zip to a directory, let's name <WorkDIR>

3. Go to <WorkDIR> and double click the Resize Image.sln.  The msvc2005 IDE will prompt automatically.

4. From the main toolbar select Project>> Intel Parallel Composer 2011 » Select Build Component.

(or right-click the Project in Solution Explorer) , check Use IPP. click OK

5. Then build the application, from the main toolbar select Build >> Build solution

Please see the build details in  Use Intel IPP in Intel® Parallel Composer

How to run the application 

1. Run the application
From the main toolbar, select Debug >> Start Without Debugging. The application windows start, Click Open File, Select LennaC1.bmp 

2. click menu "Process => Resize image" to Resize the image. 
 Enter the zoom factor in horizontal (x) and vertical (y) directory in Resize dialog box.  Click OK  

3: Click lennC1.bmp and repeat step 2 again, make sure click button USE_IPP. Then get the below image  

IPP Function Adoption: 
Assume the sample is the application we want to improve the performance via IPP function.  
1.  Find the c code resize image function in RESIZE.cpp

unsigned long C_Code_Resize(unsigned char * src, int srcWidth, int srcHeight,   int srcStep, unsigned char* dst, int dstWidth, int dstHeight, int dstStep, double m_zoom_x, double m_zoom_y, int interpolation)

 It is called by function ProcessImage(CSampleDoc *pSrc) in ippiAddC.cpp

2. Check ipp manual ippiman.pdf and find the function ippiResizeSqrPixel have same functionality.  Then replace the C function with IPP function.  
Declare a similiar function in RESIZE.cpp
unsigned long IPP_Resize( void* src, int srcWidth, int srcHeight,int srcStep,  void* dst,  int dstWidth, int dstHeight, int dstStep, double m_nzoom_x, double m_nzoom_y, int interpolation)

 And call it in ProcessImage(CSampleDoc *pSrc) in ippiAddC.cpp instead of call C_Code_Resize().  (In order to compare the performance, we keep the c function call here.)

 if (m_USE_IPP)
{
             ippStaticInit();
       //---- perform IPP Funtion Code to rotate a image  -----//
         run_time = IPP_Resize(pSrc->DataPtr(),pSrc->Width(),pSrc->Height(),pSrc->Step(),(Ipp8u*)pDst->DataPtr(),        pDst->Width(),pDst->Height(),pDst->Step(),m_zoom_x,m_zoom_y,m_Interpolation);
}
else{         //---- perform C Code to rotate a image  -----//
         run_time = C_Code_Resize((unsigned char *)pSrc->DataPtr(),pSrc->Width(),
         pSrc->Height(),pSrc->Step(), (unsigned char *)pDst->DataPtr(), pDst->Width(),pDst->Height(),pDst->Step(),m_zoom_x,m_zoom_y,m_Interpolation);
}     

3. Write the IPP code to replace the C code.  The table show the original C code and the IPP code 

Tthe C code

The IPP code

unsigned long C_Code_Resize(unsigned char * src, int srcWidth, int srcHeight,int srcStep, unsigned char* dst, int dstWidth, int dstHeight, int dstStep, double m_zoom_x, double m_zoom_y, int interpolation) {//---------- Perform 1 order linear ---      //define record time variable      unsigned long start_clock,stop_clock;    start_clock = RUNTIME;      const unsigned char *tmpSrc;     unsigned char *tmpRef;     int width = srcWidth;     int height = srcHeight;     double xInv = 1.0 /  m_zoom_x;     double yInv = 1.0 /  m_zoom_y;     int colInd, rowInd;     int i, j, xSrc0, xSrc1, ySrc0, ySrc1, wdroi, hdroi;     int idxl, idyt, icol, jrow;     double row, col;     double y1, y2, y3, y4, v, v1, v2, tempV,tempV2;      idxl=0;      idyt=0;      wdroi = dstWidth;     hdroi = dstHeight;      tmpSrc = src; for(int kloop=0;kloop<LOOP;kloop++)  {     tmpRef = dst ;     for (j = 0, jrow = idyt; j < hdroi; j++, jrow++) {         row = (jrow + 0.5) * yInv - 0.5;         rowInd = (int)floor(row);         ySrc0 = ts_iGetCoord_vs(rowInd, rowInd,  0, srcHeight, srcHeight);         ySrc1 = ts_iGetCoord_vs(rowInd, rowInd + 1, 0, srcHeight, srcHeight);         for (i = 0, icol = idxl; i < wdroi; i++, icol++) {              col = (icol + 0.5) * xInv - 0.5;             colInd = (int)floor(col);             xSrc0 = ts_iGetCoord_vs(colInd, colInd,   0, srcWidth, srcWidth);             xSrc1 = ts_iGetCoord_vs(colInd, colInd + 1, 0, srcWidth, srcWidth);             y1 = (double)tmpSrc[ySrc0 * srcStep + xSrc0];             y2 = (double)tmpSrc[ySrc0 * srcStep + xSrc1];             y3 = (double)tmpSrc[ySrc1 * srcStep + xSrc0];             y4 = (double)tmpSrc[ySrc1 * srcStep + xSrc1];    ts_iLinearCalcSP_vs(col + 0.5, colInd + 0.5, colInd + 1.5, y1, y2, &v1);            ts_iLinearCalcSP_vs(col + 0.5, colInd + 0.5, colInd + 1.5, y3, y4, &v2); ts_iLinearCalcSP_vs(row + 0.5, rowInd + 0.5, rowInd + 1.5, v1, v2, &v);               //(ts_isaturate_vs(v);             tempV = (int)(v + EXP + 0.5);             tmpRef[i] =(unsigned char)((tempV > 255) ? 255 : (tempV < 0) ? 0 : tempV);         }         tmpRef += dstStep;   }   }      stop_clock = RUNTIME;      int mhz;     ippGetCpuFreqMhz(&mhz);      return (stop_clock - start_clock)/mhz/LOOP; }

unsigned long IPP_Resize(void* src, int srcWidth, int srcHeight,int srcStep,  void* dst,  int dstWidth, int dstHeight, int dstStep,   double m_nzoom_x, double m_nzoom_y, int interpolation)   {       //   define record time variable     unsigned long start_clock,stop_clock;     start_clock= RUNTIME;  // define IPP function parameter      IppiRect srcRoi = {0,0, srcWidth, srcHeight};      IppiRect dstRoi={0,0, dstWidth,dstHeight};        IppiSize srcSize = {srcWidth, srcHeight};     IppiSize dstSize = {dstWidth, dstHeight};        int BufferSize;      ippiResizeGetBufSize(srcRoi, dstRoi, 1, interpolation, &BufferSize);      Ipp8u* pBuffer=ippsMalloc_8u(BufferSize);        for(int i=0;i<LOOP;i++)          //---------- Perform IPP function:ippiResizeSqrPixel_8u_C1R  -------------------------------------------//      ippiResizeSqrPixel_8u_C1R((Ipp8u*)src, srcSize, srcStep, srcRoi, (Ipp8u*)dst, dstStep, dstRoi, m_nzoom_x,m_nzoom_y,0, 0, interpolation, pBuffer);     ippsFree(pBuffer);     stop_clock = RUNTIME;       int mhz;     ippGetCpuFreqMhz(&mhz);      return (stop_clock - start_clock)/mhz/LOOP;

Performance Gain 

On one test machine (core 2 Quad 2.66GHz), as the result image show that the performance gain is 15654/353=44x.

The test is linking serial IPP static library.  As the ippiResize is threaded in dynamic library and threaded IPP static library. If enable the multithread, the performance gain will be more than 50x (depends on the core numbers and image size).

Conclusion
Intel® Parallel Studio 2011 provide developer a first suit of tool for easy developing parallel application on multi-core platform. IPP is part of key component of Intel® Parallel Studio. It provide over thousands highly-optimizated functions that offer the support for for developing high performance digital media application. This article describes a brief way to adopt IPP function instead of source code via Parallel Studio Project and gain over 40x performance speed up outright.  

Optimization Notice

Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice. Notice revision #20110804

• We change IPP library name and add cpu-specific optimized library for later architechure.
• We deprecated some API as show in  Deprecated API list since Intel IPP v6.0.
• Intel Parallel Studio were lauched as Intel first software development product to easier, faster develop parallelism application for developers using Microsoft* Visual C++*. It combines Intel compilers, IPP libraries.  See Which version of Intel IPP, Intel MKL and Intel TBB is installed by the Intel® Compiler Professional Edition? 

This article upgrade the code sample for latest IPP, Compiler and Parallel Studio in Microsoft Visual Studio 2005.

The samples are using

• The latest IPP version: IPP 6.1 upate 4. 
• Intel® Parallel Studio=>Intel® Parallel Composer  Or Intel® C/C++ Compiler Professional Edition for windows.
• Microsoft* Visual Studio 2005 

Click the link Source Code Examples from Intel IPP book* for the original source code example

Click the below link for updating source code example with latest Intel® Parallel Studio.
The upgrade code may focus on ippiResizeSqrPixel.cpp. See some discussion in Forum thread

Image Processing

• Allocating, Initializing, and Copying an image (Fig. 8.3): Copy.cpp
• Rectangle of interest sample wrapper (ROI class - Fig. 8.10): ROI.h ROI.cpp ROITest.cpp
• Mask image sample wrapper (Mask class - Fig. 8.11 and 8.12): Mask.h Mask.cpp MaskTest.cpp

Image Filtering and Manipulation

• Wrapper for resizing an image (Resize class - Fig. 9.24 and 9.25): Resize.h ResizeSqrPixel.cpp ResizeTest.cpp
• Wrapper for rotating an image (Rotate class - Fig. 9.27 and 9.28): Rotate.h Rotate.cpp RotateTest.cpp
• Wrapper for doing an affine transform on an image (Affine class - Fig. 9.30 and 9.31): Affine.h Affine.cpp AffineTest.cpp

Intel® Parallel Composer is part of the larger Intel® Parallel Studio, which is the first software development products to easier, faster develop parallelism application for developers using Microsoft* Visual C++*. It combines compilers, libraries. We upgrade these sample for latest Intel Compiler and Intel Parallel Studio version.

Note* Buy Intel® Integrated Performance Primitives book

The attached PDF file is a presentation which describes more information about UIC functions.

    Secondly, stepBytes: it is the distance in bytes of image row. It depends on your array memory layout and data
    type.  In most of case, it is equal to the image Width*sizeof(datatype)*Channel.  But sometimes, it is not, especially for
    bmp image, which required 4 bytes aligns, may pad zero at the end of row. So it may be
    (Width*sizeof(datatype)*Channel+3)/4. 
   
    Here is a small C++ code for call ippiFilterColumn

 //main.cpp
#include <stdio.h>
#include <stdlib.h>
#include <ipp.h>

int main()

{
     int nRow = 200;
     int nCol = 655;
     int nCount = nRow * nCol;

     Ipp16s *temp = (Ipp16s *)malloc(nCount * sizeof(Ipp16s));
     Ipp16s *temp2 = (Ipp16s *)malloc(nCount * sizeof(Ipp16s));

     Ipp32s fKernel[] = {1, 2, -3};
     int nAnchor = 1;  // please notes, if it is 1 , then it required border at the top of image.
     int nKernelSize = 3;
     int divisor = 2;

     IppiSize dstRoiSize2 = {nCol, nRow - 2};

     // please note, the step is width*sizeof(Ipp16s)    
     IppStatus b = ippiFilterColumn_16s_C1R((Ipp16s*)temp + nCol, nCol*sizeof(Ipp16s), (Ipp16s*)temp2 + nCol, 
     nCol*sizeof(Ipp16s), 
     dstRoiSize2, (Ipp32s*)fKernel, nKernelSize, nAnchor,divisor );

     printf ("%d: %s\n", b, ippGetStatusString(b));
     printf ("the step is %d\n", nCol*sizeof(Ipp16s));
     
     free(temp);
     free(temp2);
     return 0;
    }

3.  Compile and link ipp library
     please refer to How to Build an Intel IPP Application

Main function used to reconstructs damaged parts of the image or to remove a selected object is ippiInpaint_8u. To know more about this function, refer to Intel® IPP Image and Video Processing manual - http://software.intel.com/en-us/articles/intel-integrated-performance-primitives-documentation/

As shown in the above picture, two algorithms of direct inpainting are supported, 1.Telea, 2.Navier-Stokes.

Algorithm	Flag	Description
Telea	IPP_INPAINT_TELEA	image restoration of the unknown pixel by the weighted sum of approximations by known pixels in the neighborhood.
Navier-Stokes	IPP_INPAINT_NS	image restoration based on the Navier-Stokes equations.

To download IPP sample code - http://software.intel.com/en-us/intel-ipp and click "Free Code Samples"

To know more about ‘Picnic' application - http://software.intel.com/en-us/articles/intel-ipp-uic-sample-application-picnic/