neon

Can someone tell me a fast function to find the gaussian blur of an image using a 5x5 mask. I need it for iOS app dev. I am working directly on the memory of the image defined as unsigned char *image_sqr_Baseaaddr = (unsigned char *) malloc(noOfPixels); for (row = 2; row < H-2; row++) { for (col = 2; col < W-2; col++) { newPixel = 0; for (rowOffset=-2; rowOffset<=2; rowOffset++) { for (colOffset=-2; colOffset<=2; colOffset++) { rowTotal = row + rowOffset; colTotal = col + colOffset; iOffset = (unsigned long)(rowTotal*W + colTotal); newPixel += (*(imgData + iOffset)) * gaussianMask[2 +

I am using the NEON memory copy with preload implementation from the ARM website with the Windows Embedded Compact 7 ARM assembler on a Cortex-A8 processor. I notice that I get datatype misalignment exceptions when I provide that function with non word aligned values For example: ; NEON memory copy with preload ALIGN LEAF_ENTRY NEONCopyPLD PLD [r1, #0xC0] VLDM r1!,{d0-d7} ;datatype misalignment VSTM r0!,{d0-d7} SUBS r2,r2,#0x40 MOV R0, #0 MOV PC, LR ENTRY_END size_t size = /* arbitrary */; size_t offset = 1; char* src = new char[ size + offset ]; char* dst = new char[ size ]; NEONCopyPLD( dst,

How to convert a variable of data type uint8_t to int32_t using Neon? I could not find any intrinsic for doing this. Assuming you want to convert a vector of 16 x 8 bit ints to four vectors of 4 x 32 bit ints, you can do this by first unpacking to 16 bits and then again to 32 bits: // load 8 bit vector uint8x16_t v = vld1q_u8(p); // load vector of 16 x 8 bits ints from p // unpack to 16 bits int16x8_t vl = vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(v))); // 0..7 int16x8_t vh = vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(v))); // 8..15 // unpack to 32 bits int32x4_t vll = vmovl_s16(vget_low_s16

I feel the need for speed. Double for loops are killing my iPad apps performance. I need SIMD. How do I perform integer SIMD operations on the iPad A4 processor? Thanks, Doug Shervin Emami To get the fastest speed, you will have to write ARM Assembly language code that uses NEON SIMD operations, because the C compilers generally don't make very good SIMD code, so hand-written Assembly will make a big difference. I have a brief intro here: http://www.shervinemami.co.cc/iphoneAssembly.html Note that the iPad A4 uses the ARMv7-A CPU, so the reference manual for the NEON SIMD instructions is at:

I'm developing an iOS app that needs to convert images from RGB -> BGRA fairly quickly. I would like to use NEON intrinsics if possible. Is there a faster way than simply assigning the components? void neonPermuteRGBtoBGRA(unsigned char* src, unsigned char* dst, int numPix) { numPix /= 8; //process 8 pixels at a time uint8x8_t alpha = vdup_n_u8 (0xff); for (int i=0; i<numPix; i++) { uint8x8x3_t rgb = vld3_u8 (src); uint8x8x4_t bgra; bgra.val[0] = rgb.val[2]; //these lines are slow bgra.val[1] = rgb.val[1]; //these lines are slow bgra.val[2] = rgb.val[0]; //these lines are slow bgra.val[3] =

I have two tabs of floats. I need to multiply elements from the first tab by corresponding elements from the second tab and store the result in a third tab. I would like to use NEON to parallelize floats multiplications: four float multiplications simultaneously instead of one. I have expected significant acceleration but I achieved only about 20% execution time reduction. This is my code: #include <stdlib.h> #include <iostream> #include <arm_neon.h> const int n = 100; // table size /* fill a tab with random floats */ void rand_tab(float *t) { for (int i = 0; i < n; i++) t[i] = (float)rand()/

I recently discovered about the vreinterpret{q}_dsttype_srctype casting operator . However this doesn't seem to support conversion in the data type described at this link (bottom of the page): Some intrinsics use an array of vector types of the form: <type><size>x<number of lanes>x<length of array>_t These types are treated as ordinary C structures containing a single element named val. An example structure definition is: struct int16x4x2_t { int16x4_t val[2]; }; Do you know how to convert from uint8x16_t to uint8x8x2_t ? Note that that the problem cannot be reliably addressed using union