hi all

i am trying to run a opencv project which is optimized by IPP . in orther to run the poject i have instaled the IPP(30 days trail ) and configured it with viusal stedio 2008 as per instructions mentioned in IPP website - > (Compiling and Linking Intel® IPP with Microsoft* Visual C++* and Intel® C++ Compiler)

however when runing the project i get the error :"the program cant start becouse ippcore-7.1.dll is missing from your computer. try reintalling the program to fix this problem".

i have already reintalled te IPP and cheked many time the intergation procedure but no result

could any body help me in this issue

thanking you ...

Hello!

I use ipp function for decoding JPEG 4:1:1 and have the next problem.

From ijl source code

the ippi function ippiDCT8x8Inv_16s_C1I  has input data range [-256, 255] and depending on the quant matrix the result may be more 128.

but for example ippiYCbCr411ToRGBLS_MCU_16s8u_P3C3R which call after this need input data range [-128..127]

The data from real jpeg picture.

pSrcDst:

-135, 72, 17, 108, 40, -198, -170, 101,
-180, -20, 69, -96, -43, 192, 100, -91,
-115, 44, -81, 40, 66, 0, 115, 0,
69, -112, -37, 0, 0, 0, 0, 0,
30, -37, 0, -93, -113, 0, -171, 0,
-80, 116, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
120, 0, 158, 0, 186, 166, 0, 164

ippiDCT8x8Inv_16s_C1I(pSrcDst);

pSrcDst:

-52, -64, -46, -33, -74, -87, -32, -65,
-56, -64, -65, -62, -55, 24, -112, -51,
151, -58, -41, -67, -30, -131, -31, -13,
-150, 197, -64, -70, -38, -54, -25, -115,
45, 76, -38, -19, 124, -97, 208, 111,
-85, 92, -71, -64, 145, 78, -57, -22,
126, 8, -50, -75, 174, -68, -89, -38,
-43, 119, -61, -73, 169, -41, -56, -70

further

 ippiYCbCr411ToRGBLS_MCU_16s8u_P3C3R or my own kod  for convert 4:1:1 to 4:2:2

This leads to distorted output images (rgb,ycbcr422,...)

Thank you, Vladimir

I have just upgraded my rather old code from IPP 5.3 to 7.1.1. Turned out to be a huge job due to the API changes, but that's OK, it happens. And my code ended up being much smaller and cleaner as many features I had to try and emulate are now in the sample code.

My problem now is that I am getting very high CPU usage, and very slow frame rates, the two being, of course, closely related. First, I am using the "max slice size" option as I am trying to send RFC 3984 compliant packetisation mode zero RTP packets. Second, I am encoding a y4m file to minimise any possible interactions with cameras etc. Finally, I am using contant bit rate set to 2Mbps. My test code (effectively) takes a YUV420P frame from the file, feeds it through the codec, then splits it up into separate RTP/NALU's by searching for the start codes etc, and finishes by throwing away the result. The build is using VS2012, 32 bit.

A CIF sized image maxes out the single thread and yields 10fps. HD720 is about 4fps and HD1080 is about 2fps.

That is seriously non-linear for a start. The HD stuff, I can sort of understand eating CPU for breakfast, but really, CIF should be able to do 30fps, with time to spare. Even in one thread.

I have played with the num_slices and m_iThreads parameters, as well as resolutions and CBR bit rates, and nothing seems to makes a lot of difference.

Can anyone think of something I am doing wrong?

Oh yeah, this is on a realtively old i7, but I got 10 times this performance with my old code, and IPP 5.3, two years ago.

I am correctly linking a static library that uses IPP - call it Lib A.  It runs fine as well but I must have done something incorrect.  When I try to incorporate Lib A into a statically linked Lib B that uses Lib A, VS 2012 insists that I provide the path to the IPP libraries when linking Lib B.  I am trying to build and share a static library that will not require developers to have IPP installed.  I have #include <ipp_u8.h> and I have downloaded the special version of IPP - version 7.1.1.119.  The Lib A size is almost 4 Mb so I am confident that I have included the portions of IPP that I want to use but linking Lib A into Lib B leaves all the IPP functions unresolved without the path to IPP.  Am I not allowed to redistribute a static library that incorporates IPP functionality?  I expect others to put in my static Lib A into their library code as well as executables.  Or must the Lib A only be incorporated into an executable?  I could see that Intel might not want me just wrapping IPP functions into a static library that I could share for developers (distribution of IPP is royalty-free.)  I work for Intel and would like to redistribute a library for developers.

Bob Davies

I am paraphrasing a different thread I have running here, but this is a bit more general a question.

Is it in possible to do real time encoding of 1080p video at 30fps, preferabling using H.264, but any codec would do.

Is it even possible to do 720p?

Has anyone done this?

I saw the v8.0 is available and read the release note, the question is: does it support H.265 ? If it does not then any plan for it?

Best regards,

Hi everyone . I am trying to implement edge drawing algoritm of Cihan Topal, Cüneyt Akinlar . This is the code of  magnitude calculation:

void CalculateMagnitude(CprImage *sobelVertical,CprImage *sobelHorizantal,CprImage *magImage)
{
ippiAdd_32f_C1R( (Ipp32f *)sobelVertical->DataPtr() + offset , sobelVertical->Step() , (Ipp32f *)sobelHorizantal->DataPtr() + offset , sobelHorizantal->Step() , (Ipp32f *)magImage->DataPtr() + offset , magImage->Step() , roi);

ippiThreshold_LTVal_32f_C1R( (Ipp32f *)magImage->DataPtr() + offset , magImage->Step() , (Ipp32f *)magImage->DataPtr() + offset , magImage->Step() , roi , (Ipp32f)m_gradientThreshold , 0);
}

//offset , roi , m_gradientThreshold defined before

When i measure the performance of functions, this function processes same image sometimes at 2ms , sometimes at 30 ms , 120 ms ...

What do you think the problem is?  

Hi 

I have a question

I have a source buffer of interlaced, interleaved YUV with alpha

i.e. UYAVYA - 1920x1080

I need to strip the alpha, extract one field, resize it to half and convert to 420planer

as a single buffer (i.e not 3 separate planes but a single buffer of concatenated Y,U,V

Can anyone recommend the fastest set of methods to do this? 

Cheers

Steve

Hello All, 

I am trying to perform Auto Contrast in my grey images using Intel IPP functions. I am not sure where I am going wrong but the image becomes too dark. Here is the code. 

#define GrayLevels 256

 int  main()

{

      std::string path("C:\\sharath\\Images\\");

      std::string inputImageFile = path + "DiffFing.bmp";

       IppImage<Ipp8u,1> imgsrc;

      ippiLoadBMP(inputImageFile.c_str(),imgsrc);

      IppImage<Ipp8u,1> imgDst;

      IppiSize imgSize;

      Ipp32s imgLevels[GrayLevels+1], imgHist[GrayLevels];

      Ipp32s imgValues[GrayLevels];

       int w = imgsrc.Width();

      int h = imgsrc.Height();

      int nlevels = GrayLevels;

      float ww=0;

      int min=0;

      int max=GrayLevels-1;

      int slope;

      float cut_low = 0.05f;

      float cut_high = 0.95f;

       imgSize.width = w;

      imgSize.height = h;

      ippiHistogramEven(imgsrc, imgSize, imgHist, imgLevels, GrayLevels+1, 0, GrayLevels);

       while(ww<cut_low)

      {

            ww+=imgHist[min++];

      }

      while(ww<cut_high)

      {

            ww+=imgHist[max--];

      }

       slope = (GrayLevels-1)/(max-min);

     for(int i=0;i<GrayLevels;i++)

      {

            if(i<=min)

            {

                  imgValues[i] = 0;

            }

            else if(i>=max)

            {

                  imgValues[i] = GrayLevels-1;

            }

            else

            {

                  imgValues[i] = slope*(i-min);

            }

      }

      imgDst.ResizeNE(imgsrc.Width(),imgsrc.Height());

       ippiLUT(imgsrc, imgDst, imgSize, imgValues, imgLevels, GrayLevels+1);

       std::string out4f = path + "DiffFing_Auto.bmp";

      ippiSaveBMP(out4f.c_str(),imgDst);

       return(EXIT_SUCCESS);

}

 Can somebody help me figure out why my image gets darker instead of enhancing the contrast. 

I have also attached the files for reference. DiffFing_AutoContrast.bmp is the image after autocontrast. 

Thanks, 

Sharath

For more information, documentation, downloads, etc. see: http://software.intel.com/en-us/intel-ipp-preview

Let us know what you think.  The number of functions is starting small but expected to grow rapidly with frequent updates.  Your feedback is welcome and needed to develop these functions toward eventual promotion to an Intel® IPP production release. Looking forward to your input on issues, documentation, feature requests, and usability.

IPP 8 is now available for download.  For more information on the stand-alone product please visit the IPP 8 landing page.  There is also an IPP 8 preview for Android in the Intel Beacon Mountain development environment.  With this release there are also technology previews of GPU-enabled asynchronous C/C++ and OpenCL functions.

More info can be found in the IPP 8 Release Notes.

IPP is also part of  Composer XE 2013, Intel System Studio, and other suites. 

Starting with the release of IPP 8, the product is renewing its focus on primitives (with emerging GPU enablement as demonstrated in IPP's technology preview releases).  Small, simple examples will be the goal instead of large samples.

With the release of IPP 8, all of the large samples previously distributed as an external samples package are now legacy.  This includes 

• All audio and video codecs in UMC.  For video codecs Media SDK (link) is the successor to UMC.  Today and forward, Media SDK is Intel's only hardware enabling product dedicated to media codecs.
• All JPEG codecs in UIC and IJG
• All speech codecs in USC
• All drop-in IPP accelerated compression interfaces

While there is no samples package currently available for IPP 8, one is coming soon to help with your transitions.  We will announce it here as soon as it is available.  

For more info please see http://software.intel.com/en-us/articles/code-samples-for-intel-integrated-performance-primitives-library.

In downloads, there is Related Files, onlinedata   (Release Notes, online data is a bad link,

I am very new to ipp, have the last version, and would like to use it to swap an image like a rgba to a bgra, is there an simple way to do so ?

Intel(r) IPP offers two ways to try out Android* support:

1. Intel(r) IPP Preview for Android* available exclusively from Beacon Mountain

• This is a subset of Intel(r) IPP image processing and computer vision functions that is freely available for download, use, and production release for Android platforms. http://software.intel.com/en-us/vcsource/tools/beaconmountain

2. Intel(r) IPP for Android*

• This is the full Intel(r) IPP product, that is available for 30-day evaluation and/or purchase.  http://software.intel.com/en-us/intel-ipp

Good morning everybody,

we wonder here how to use the ippMoment functions in IPP 7.1

The following code sample gives us compiler warnings about deprecated code.Where is the mistake?

Many thanks for your help!

best regards,

Dennis

---- sample code ---

#include <ippi.h>
#include <iostream>
using namespace std;
int main( int /*argc*/, char* /*argv*/[] )
{
  IppiMomentState_64f*  ctxFloat=0;
  // Allocate memory for IppiMomentState_64f
  // ippiMomentInitAlloc_64f declared deprecated in
  // http://software.intel.com/sites/products/documentation/doclib/ipp_sa/71/ipp_manual/IPPI/ippi_ch11/functn_MomentInitAlloc.htm
  //
  // how to allocate memory in the right way?
  ippiMomentInitAlloc_64f(&ctxFloat, ippAlgHintNone);
  // do some operations with not depreacted ippiMoments64f ... functions
  // ippiMoments64f_16u_C1R (..., ctxFloat)
  // ippiGetNormalizedCentralMoment_64f(ctxFloat, ...)
  // see another example:
  // http://software.intel.com/sites/products/documentation/hpc/ipp/ippi/ippi_ch11/functn_GetHuMoments.html
  // free memory
  // ippiMomentFree_64f called deprecated in 
  // http://software.intel.com/sites/products/documentation/doclib/ipp_sa/71/ipp_manual/IPPI/ippi_ch11/functn_MomentFree.htm
  //
  // how to free memory in the right way?
  ippiMomentFree_64f(ctxFloat);
  ctxFloat = 0;
  return 0;
}

--- compiler output

g++ -m32 -Wall -Wextra  -ggdb3 -MD -O0 -fstrict-aliasing  -I/opt/intel/composer_xe_2013.3.163/ipp/include  -c test_ipp.cpp -o test_ipp.o
test_ipp.cpp: In function 'int main(int, char**)':
test_ipp.cpp:14:3: warning: 'IppStatus ippiMomentInitAlloc_64f(IppiMomentState_64f**, IppHintAlgorithm)' is deprecated (declared at /opt/intel/composer_xe_2013.3.163/ipp/include/ippi.h:7583) [-Wdeprecated-declarations]
test_ipp.cpp:14:52: warning: 'IppStatus ippiMomentInitAlloc_64f(IppiMomentState_64f**, IppHintAlgorithm)' is deprecated (declared at /opt/intel/composer_xe_2013.3.163/ipp/include/ippi.h:7583) [-Wdeprecated-declarations]
test_ipp.cpp:30:3: warning: 'IppStatus ippiMomentFree_64f(IppiMomentState_64f*)' is deprecated (declared at /opt/intel/composer_xe_2013.3.163/ipp/include/ippi.h:7603) [-Wdeprecated-declarations]
test_ipp.cpp:30:30: warning: 'IppStatus ippiMomentFree_64f(IppiMomentState_64f*)' is deprecated (declared at /opt/intel/composer_xe_2013.3.163/ipp/include/ippi.h:7603) [-Wdeprecated-declarations]
g++ -m32 -Wall -Wextra  -ggdb3 -MD -O0 -fstrict-aliasing  -I/opt/intel/composer_xe_2013.3.163/ipp/include   test_ipp.o -L/opt/intel/composer_xe_2013.3.163/ipp/lib/ia32 -lippac_l -lippdc_l -lippcc_l -lippcv_l -lippj_l -lippdi_l -lippch_l -lippm_l -lippr_l -lippsc_l -lippvm_l -lippvc_l -lippi_l -lipps_l -lippcore_l -o test_ipp

I am a newcomer to the Intel IPP world. I am working in Visual C++. The code I'm working on performs certain manipulations on C++ arrays. After performing all these manipulations which use many IPP functions like FFT, Convert and so on, I'd like to write the array as an image to file. So far, I've succeeded in using ippiEncodeLoadCodeBlock_JPEG2K_32s_C1R and ippiEncodeStoreBits_JPEG2K_1u to encode the array to jpeg. The example in the IPP documentation illustrates that the encoded array can be written to file thus

fwrite(pDst, sizeof(Ipp8u), sizeof(pDst), FILE* file);

However, though the imagefile is created on disk and it has a non-zero size(some 60KB), I'm not able to view the image.

Can somebody please tell me what is wrong and how to correct it? 

Hi.

I'm using IPP 7.0 for lossy JPEG compression. Its processing speed is absolutely fabulouse. ;)

What about CCSDS Rice lossless compression?  I've read IPP 8.0 release note and found nothing related with it.

But for the double-check, I'd like to ask that IPP provides CCSDS rice compression.

If you know any commercial software which provides rice compression in fast speed, that information will be helpful, as well.

Thanks in advance,

Hyunsu 

 I am working with ipp ver 7.0 build 205.7, from Jul 11 2010.

 The command ippiHLSToBGR_8u_P3C3R seems to have problems with the first parameter. It doesn't accept this parameter:

 unsigned char *m_pHls3Buffer[3];

 And returns the error message:

 error C2664: 'ippiHLSToBGR_8u_P3C3R' : cannot convert parameter 1 from 'unsigned char *[3]' to 'const Ipp8u *[]'

 However, its twin brother, ippiBGRToHLS_8u_C3P3R doesn't have any problems with the very same parameter (third parameter) few lines before.

 All other tries for casting and feeding other types of parameters fails. It even success to inform me that “cannot convert parameter 1 from Ipp8u *[]' to 'const Ipp8u *[]'”.

 Thanks for your advice.

I am trying to replace a sample rate conversion implementation limited to converting between 8000Hz and 16000Hz 16 bit linear PCM with some thing more flexible.  Using IPP 7.1, the ResamplePolyphaseFixed API's and the example code (http://software.intel.com/sites/products/documentation/doclib/ipp_sa/71/ipp_manual/IPPS/ipps_ch6/functn_ResamplePolyphase.htm) I have something which works but the audio quality is not great.  Using DTMF tones to test basic quality, the input is 8000Hz / 16bit linear PCM being processed in 10msec chunks.  Tested output is 11025Hz and 16000Hz / 16bit linear PCM with fair quality.

I have tried tweaking the hardcoded parameters used in the example code but this has not yielded any noticable improvement.  My (abreviated) version of the example code . . . 

static const IppHintAlgorithm g_IppHintAlgorithm = ippAlgHintAccurate;

static void Create(int a_iSampleRateInp, int a_iSampleRateOut, Context* a_pResamplePCMContext)
{
  int l_iSize = 0;
  int l_iBufferLength = 0;
  Context* p = a_pResamplePCMContext; //For code brevity
  int l_iLength = 0;
  float l_fWindow = 0.0;
  double l_dFactor = 0.0;

  p->m_pState = NULL;
  p->m_iBufferLength = 0;
  p->m_pBuffer = NULL;
  p->m_iFilterLength = 0;
  p->m_iNumberOfFilters = 0;
  p->m_dTime = 0.0;
  p->m_iLastRead = 0;
  p->m_iSampleRateInp = 0;
  p->m_iSampleRateOut = 0;

  p->m_iBufferLengthBase = 4096; //From intel example code
  p->m_iHistory = 128; //From intel example code
  p->m_fFilterRollOff = 0.95f; //From intel example code
  p->m_fKaiserWindowAlpha = 9.0f; //From intel example code
  p->m_fNormFactor = 0.98f; //From intel example code

  ippsResamplePolyphaseFixedGetSize_16s(a_iSampleRateInp, a_iSampleRateOut, 2*(p->m_iHistory-1), &l_iSize, &p->m_iFilterLength, &p->m_iNumberOfFilters, g_IppHintAlgorithm);
  p->m_pState = (IppsResamlingPolyphaseFixed_16s*)ippsMalloc_8u(l_iSize);
  if (NULL == a_pResamplePCMContext->m_pState) return;
  ippsResamplePolyphaseFixedInit_16s(a_iSampleRateInp, a_iSampleRateOut, 2*(p->m_iHistory-1), p->m_fFilterRollOff, p->m_fKaiserWindowAlpha,   p->m_pState, g_IppHintAlgorithm);
  l_iBufferLength = (int)((p->m_iBufferLengthBase-p->m_iHistory)*a_iSampleRateOut/(float)a_iSampleRateInp+2);
  p->m_pBuffer = ippsMalloc_16s(l_iBufferLength);
  if (NULL == p->m_pBuffer) return;
  p->m_iBufferLength = l_iBufferLength;
  //Initialy, the residual length is the history length and we must 0 this portion out.
  p->m_dTime = (double)p->m_iHistory;
  p->m_iLastRead = p->m_iHistory;
  ippsZero_16s(p->m_pBuffer, p->m_iBufferLength);
  p->m_iSampleRateInp = a_iSampleRateInp;
  p->m_iSampleRateOut = a_iSampleRateOut;
}

static void Resample(Context_16s* a_pResamplePCMContext, short* a_p16BitInp, short* a_p16BitOut, unsigned int a_iLengthInp, unsigned int* a_piLengthOut)
{
  IppStatus l_IppStatus = ippStsNoErr;
  Context* p = a_pResamplePCMContext; //For code brevity
  double l_dTime;

  l_dTime = p->m_dTime;
  //Copy the new input samples to proper position in residual buffer
  ippsCopy_16s(a_p16BitInp, p->m_pBuffer+p->m_iLastRead, a_iLengthInp);
  p->m_iLastRead += a_iLengthInp;
  l_IppStatus = ippsResamplePolyphaseFixed_16s(p->m_pBuffer, a_iLengthInp, a_p16BitOut, p->m_fNormFactor, &p->m_dTime, (int*)a_piLengthOut, p->m_pState);
  if (ippStsNoErr != l_IppStatus)
  {
    return;
  }
  //Copy any residual input samples to head of residual / history buffer
  ippsMove_16s(a_p16BitInp+(int)p->m_dTime-p->m_iHistory, p->m_pBuffer, p->m_iLastRead+p->m_iHistory-(int)p->m_dTime);
  p->m_iLastRead -= ((int)p->m_dTime-p->m_iHistory);
  p->m_dTime -= (p->m_dTime-p->m_iHistory);
}