Quantcast
Channel: Intel® Integrated Performance Primitives
Viewing all 1294 articles
Browse latest View live

Affine transform produces invalid outputs

$
0
0

Hi,

I am trying to implement this simple test program in IPP. It enlarges a sample 2d matrix by 200%. This is the Matlab version:

A = uint8([1 2 3; 4 5 6]) % Input matrix

tform = affine2d([2 0 0; 0 2 0; 0 0 1]); % Define transform

B = imwarp(A, tform, 'nearest') % Run the transform

I get this output, as expected:

A =

    1    2    3

    4    5    6



B =

    1    1    2    2    3    3

    1    1    2    2    3    3

    4    4    5    5    6    6

    4    4    5    5    6    6

This is IPP equivalent code:

// ipptest.cpp : Attempt to use WarpAffine to scale an image 200%.
//

#include "ipp.h"

#include <iostream>
#include <iomanip>

typedef unsigned char byte;

int main(int argc, char* argv[])
{
 ippInit();

 // Source image and ROI
 static const int kHEIGHT = 2;
 static const int kWIDTH = 3;
 byte srcImage[kHEIGHT][kWIDTH] =
 {
  { 1, 2, 3 },
  { 4, 5, 6 }
 };

 IppiRect srcRoi;
 srcRoi.x = srcRoi.y = 0;
 srcRoi.width = kWIDTH + 1;
 srcRoi.height = kHEIGHT + 1;

 IppiSize srcSize;
 srcSize.height = kHEIGHT;
 srcSize.width = kWIDTH;


 // Destinatino image buffer and ROI
 byte destImage[kHEIGHT * 2][kWIDTH * 2];

 IppiRect destRoi;
 destRoi.x = destRoi.y = 0;
 destRoi.width = kWIDTH * 2 + 1;
 destRoi.height = kHEIGHT * 2 + 1;


 // Scale source image by 200% in both x and y
 double coeffs[2][3] =
 {
  { 2.0, 0.0, 0.0 },
  { 0.0, 2.0, 0.0 }
 };

 IppStatus stat;
 double bound[2][2];

 // Following code is from AffineTransform sample to figure out destination width and height
 stat = ippiGetAffineBound(srcRoi, bound, coeffs);
 double width = bound[1][0] - bound[0][0];
 double height = bound[1][1] - bound[0][1];

 std::cout << "IPP sample says "<< kWIDTH << " x "<< kHEIGHT << " image should be scaled 200% to "<< width << " x "<< height << std::endl;

 // Print input image
 std::cout << std::endl << "Source image: "<< std::endl;
 for (int row = 0; row < kHEIGHT; ++row)
 {
  for (int col = 0; col < kWIDTH; ++col)
  {
   std::cout << ""<< (unsigned int)srcImage[row][col];
  }
  std::cout << std::endl;
 }

 // Apply transform
 stat = ippiWarpAffine_8u_C1R(
  (const Ipp8u*)srcImage, srcSize, kWIDTH, srcRoi,
  (Ipp8u*)destImage, kWIDTH * 2, destRoi,
  coeffs, IPPI_INTER_NN);

 // Print output image
 std::cout << std::endl << "Transformed image: "<< std::endl;
 for (int row = 0; row < kHEIGHT * 2; ++row)
 {
  for (int col = 0; col < kWIDTH * 2; ++col)
  {
   std::cout << ""<< (unsigned int)destImage[row][col];
  }
  std::cout << std::endl;
 }

 return 0;
}

But what I get is this:

IPP sample says 3 x 2 image should be scaled 200% to 6 x 4

Source image:

 1 2 3

 4 5 6

Transformed image:

 1 2 2 3 3 204

 4 5 5 6 6 204

 4 5 5 6 6 204

 204 204 204 204 204 204

Press any key to continue . . .



Obviously the transformed image isn't correct. Can somebody point out what's wrong, please.

 

 

 


error LNK2019: unresolved external symbol ippiMean_16u_C1MR

$
0
0

Dear IPP Users:

I got error LNK2019: unresolved external symbol ippiMean_16u_C1MR when I use ippiMean to calculate mean in a ROI with mask data. Here is my code:

#include "ippcv.h"

#include "ippi.h"
Ipp64f IppMean( const Ipp16u* pSrc, const Ipp8u* pMask, int roiWidth, int roiHeight )
{
	Ipp64f mean;
    Ipp16u* pDst = (Ipp16u*)malloc(sizeof(Ipp16u)*roiWidth*roiHeight);
    IppiSize roi = {roiWidth,roiHeight};
    ippiSet_16u_C1MR(1, pDst, roiWidth, roi, pMask,roiWidth );

    ippiMean_16u_C1MR( pSrc, roiWidth, pMask, roiWidth, roi, &mean);

	free(pDst);

	return mean;
}

I have

1. included the ipp/intel64/inlcude in my project

2. added ippcore.lib, ippvm.lib, ipps.lib, ippi.lib in my input library in my project

3. linked  ipp/intel64/dll in my projection as addtional library.

I don't understand, and I think it should work. Anyone can give me some suggestions where I did wrong, and how I should correct it? Thanks.

Nick

IPP multithreaded libraries not installed?

$
0
0

Hello

I'm getting this error when I compile my program with Intel's compiler v14:

1>C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V120\Platforms\x64\PlatformToolsets\Intel C++ Compiler XE 14.0\ImportBefore\Intel.Libs.IPP.Intel C++ Compiler XE 14.0.targets(91,5): error : IPP multi-threaded libraries are not installed.

I have Parallel Studio XE 2013 for windows, I thought it came included with IPP, did I miss something?

Thanks

Renewal of IPP

$
0
0

Hello,

I purchased Intel IPP 7.0(8.0 is also valid) and got 2 licenses until 11 Oct 2013.

Should I renew my licenses to use IPP 7.0 or 8.0? I don't need to upgrade 8.1 until now because I've made a s/w already using this library.

But when I download old version from your website and try to reinstall this, I've got error message "license is expired, need to renew".

Does it means "I have to renew Intel IPP library every year for my applications?"

Central moment IPL-IPP conversion

$
0
0

Hello and good day.

When converting from the old IPL to the IPP library (v8.1) I get strange results for the IPL function for central moment.

Example code:

	int width = 103; // minimum size for the discrepancy
	int height =2;
	// create unsigned char image (w,h)=(103,2)
	IplImage* iplIm = iplCreateImageHeader(1, 0, IPL_DEPTH_8U, "GRAY", "GRAY",
											IPL_DATA_ORDER_PIXEL, IPL_ORIGIN_TL,
											IPL_ALIGN_QWORD, width, height,
											NULL, NULL, NULL, NULL);
	// set all pixels to 1.
	iplAllocateImage(iplIm, 1, 1);


	//create ipp state for moments
	IppHintAlgorithm hint = ippAlgHintAccurate;//ippAlgHintAccurate;//ippAlgHintFast;// ippAlgHintNone
	// allocate memory for state
	IppiMomentState_64f* pState;
	IppStatus sts = ippiMomentInitAlloc_64f( &pState, hint);
	// calculate moments
	IppiSize size = {width, height};
	sts = ippiMoments64f_8u_C1R((Ipp8u*)iplIm->imageData, iplIm->widthStep, size, pState);


	// get central moment for IPL and IPP
	int mOrd = 3;
	int nOrd = 0;
	double res_ipp;
	sts = ippiGetCentralMoment_64f( pState, mOrd, nOrd, 0, &res_ipp);
	double res_ipl =  iplCentralMoment(iplIm, mOrd, nOrd);

	assert(res_ipl == res_ipp);

Results:

Third moment should be zero for an image consisting only of ones.

IPP: -7.4505805969238281e-009, Good enough

IPL: -2.0000000074505806, ???

System details:

I7-2600, Win7 32bit, IPP8.1SP1.

Loaded IPP dlls:

ippccg9-8.1.dll

ippsg9-8.1.dll

ippcvg9-8.1.dll

ippig9-8.1.dll

 

Achieving bicubic interpolation on resizing

$
0
0

I noticed that there is ippiInterpolationType::ippCubic, but not bicubic.

Being a beginner in image processing I'd like to hear from the experts how one would achieve bicubic interpolation? I've read that bicubic is applying cubic filtering both horizontally and vertically.

Isn't it what cubic filtering does in IPP?

Thank you

umc_video_dec_con NV12 scaling

$
0
0

Hello all,

I am using the sample application umc_video_dec_con.exe to convert a h264 video file into nv12.

Using a command such as:

umc_video_dec_con -i myfile.mp4 -f nv12 -o outfile.yuv

works as expected (verifying the output file using third party image/video viewing software).

When I introduce horizontal scaling:

umc_video_dec_con -i myfile.mp4 -f nv12 -o outfile.yuv -r 1918 1080 -k

the output file colours are not correct; it looks like a vertical stripe of nv12 (uv) colour, followed by a vertical stripe of nv21 (vu) colour, repeating.

I see the effect using any scaling factor (horizontal only, vertical works correctly).

I do not see any error when converting to rgb, yuv modes and yv12.

Is this a known issue, or am I doing something wrong?

Many thanks in advance.

Using:

Intel(R) IPP:

  ippCore 7.1.1 (r37466) Sep 24 2012 

  ippSP AVX (g9) 7.1.1 (r37466) Sep 24 2012 

  ippIP AVX (g9) 7.1.1 (r37466) Sep 24 2012 

  ippJP AVX (g9) 7.1.1 (r37466) Sep 25 2012 

  ippVC AVX (g9) 7.1.1 (r37466) Sep 25 2012 

  ippDC AVX (g9) 7.1.1 (r37466) Sep 25 2012 

  ippCC AVX (g9) 7.1.1 (r37466) Sep 25 2012 

Perturbation Filters in IPP

$
0
0

I downloaded IPP and find it to be VERY interesting. Lot of functions, lots of domain! Awesome stuff. I am specifically looking for high performing implementation of a custom excitation algorithm with different loop idioms as below.

1.   a[j] = a[j] + k*(a[j+1] - a[j-1])

2.  a[j] = a[j-1] + k*(a[j] - a[j-1])

Unfortunately, the dependency in the loop is painful. Could any experts from IPP tell me if there any existing functions in IPP that I could use for optimizing my loop ? We are considering moving to Intel compiler, but that would take some time as well..

Regards - momo

 


Linking IPP 7.0.1 libraries

$
0
0

 I am creating a MP4 video with MPEG4 muxer and H264 Encoder using IPP UMC samples version 7.0.1.127. I need help in linking the IPP libraries in my executable. My IDE is Visual Studio 2012 on Win 7 OS.

Static Linking:

I need to build my solution in both debug and release builds which involve different versions of the C run time library. Intel libs are built against the release version of C run time and so there is RunTimeLibrary mismatch when I build my project in debug mode.

Dynamic Linking:

I am trying to create a dll with exported functions from IPP using the Intel IPP custom build tool. I am facing linker errors when I run the batch file. I am attaching the build tool scripts, export.def file and the linker errors on executing the script.

 

 

AttachmentSize
DownloadIPP_Errors.zip34.85 KB

Function for matrix multiplication of complex values

$
0
0

I'm fairly new to IPP and I have what seems like a silly question. Does IPP provide a function for multiplying two matrices of complex values (32fc format)? A colleague and I scoured the Small Matrices and Realistic Rendering and Signal Processing reference manuals yesterday and could not find it. Is this operation not supported (in a single function call) in IPP? If not, what about MKL?

Extensive memory allocation on OS X 10.9.4

$
0
0

Hello,

I'm in a team developing a video based application that extensively uses Intel's IPP library (IPP v6.1).

Lately we started testing the application on the pre-released OS X 10.9.4 version, and encountered several crashes at different locations, when the application runs for a long time (several hours). In most of the cases the crashes were in Apple's threads and code.

I started analysing the issues using the Xcode leak instrument and found out that the memory consumption of the application is significantly higher when running on OS X 10.9.4 than on OS X 10.9.2. For example, after an hour of running on 10.9.4 the application memory consumption reaches about 800 MB, and after 90 minutes it reaches 1.8 GB, whereas the same application on 10.9.2 is constantly using about 120 MB.

Most of the additional memory consumption, on 10.9.4, seems to be due to Intel's IPP allocations. However, the Xcode leak instrument did not identify any leaks in the code.

 

Does anyone know of a similar issue with OS X 10.9.4?

Debug version for linking

$
0
0

My application has to build in both debug and release modes and I want to link Intel IPP libs statically. Are the debug libs available ?

Even in case of dlls, are the debug version of Intel IPP libraries available. I am aware that debugging in release mode can be enabled but I would like to link my application with debug CRT.

 

 

 

Performance ippiCrossCorrNorm

$
0
0

Since the function ippiCrossCorrValid_NormLevel_32f_C1R is marked as deprecated,
we switched to the new function ippiCrossCorrNorm_32f_C1R.

Using this new function, we see a slowdown by a factor 7 between these 2 function calls in IPP8.1

We use a srcRoiSize of 21x21 pixels and a tplRoiSize of 17x17 pixels.
The used algorithm type definition for ippiCrossCorrNorm is:
IppEnum funCfg = (IppEnum)(ippAlgAuto | ippiROIValid | ippiNormCoefficient);

We also noticed that ippiCrossCorrValid_NormLevel_32f_C1R for the given src and tpl sizes is significant faster
than the alternatives ippiCrossCorrValid_Norm_32f_C1R and ippiCrossCorrValid_32f_C1R
which are mathematically simpler image proximity measures.

Any suggestion how to reach the performance of ippiCrossCorrValid_NormLevel_32f_C1R with the new function ippiCrossCorrNorm?

Best regards,

3d convolution function in ipp

$
0
0

hi all,

my application currently involves applying 3d convolution function on vedio frames.. but ipp seems to have only 2d convolution function..

how do i use 3d convolution function.. with ipp..   any hints on this would be of great help..   thanks

 

 

IPP 2D convolution work properly on demo data only

$
0
0

Hello,

I have a question.

There are two functions of 2D convolution in attached cpp-file.

The first one is a standard convolution on floating-point data.

The second is a function, that use ippiConvValid_32f_C1R() for convolution.

When I use data of this example (https://software.intel.com/sites/products/documentation/doclib/ipp_sa/80...) with integer numbers for source matrix and kernel, everything is ok, results of two functions are equal, but when i use generator of random integer or floating-point numbers, ippiConvValid_32f_C1R() returns wrong result.

What's the problem?

AttachmentSize
Downloadconvolution_0.cpp4.02 KB

IPPI and IPPS with IEEE 754 accuracy standards

$
0
0

Hello Intel,

We have been using Intel IPP 6.1 for 6 years now. Our product medical regulated product and we would like to see accurate results while changing integrating new IPP version.

I see IPP already has a Fixed accuracy functions. But, I looking for the lot more function from IPPS and IPPI libraries with a similar precision definition.

1. Is there any compiler option to enable IEEE 754 standard results?

2. Are there ippmQRDecomp_m_64f_f_A24, ippiFilter_32fC1R_A24 functions?

Thanks,

Uday

Intel IPP 7.1 Crashes on AMD CPU

$
0
0

Hello,

I am using Intel IPP 7.1 Update 1 for image processing.

I'm compiling the code statically (Single Thread).

When running the code on AMD Phenom II the program crashes.

Yet on Intel CPU it works with no problems.

I know you disable many of the optimizations when running on AMD CPU's, yet I wasn't aware there is no compatibility.

Could you address that?

Thank You.

Linux 8.1 error on IppInit() Error:ippStsWaterfall: Cannot load required library

$
0
0

I am using Linux Intel64 version of IPP8.1 ( part of Composer XE 2013 SP1) and when I call IppInit I get the following (non-fatal) error.

IppInit() Error:ippStsWaterfall: Cannot load required library, waterfall is used.

I am linking with the single threaded dynamically linked version

 

ldd shows

 libippvm.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippvm.so.8.1 (0x00002b666e51e000)

        libippvc.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippvc.so.8.1 (0x00002b666e732000)

        libippsc.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippsc.so.8.1 (0x00002b666e952000)

        libippr.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippr.so.8.1 (0x00002b666eb6b000)

        libippm.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippm.so.8.1 (0x00002b666ed70000)

        libippj.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippj.so.8.1 (0x00002b666ef9d000)

        libippdi.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippdi.so.8.1 (0x00002b666f1af000)

        libippcv.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippcv.so.8.1 (0x00002b666f3b4000)

        libippch.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippch.so.8.1 (0x00002b666f5dc000)

        libippcc.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippcc.so.8.1 (0x00002b666f7e3000)

        libippac.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippac.so.8.1 (0x00002b666fa00000)

        libippdc.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippdc.so.8.1 (0x00002b666fc0f000)

        libippi.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippi.so.8.1 (0x00002b666fe18000)

        libipps.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libipps.so.8.1 (0x00002b66700d6000)

        libippgen.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippgen.so.8.1 (0x00002b6670341000)

        libippcore.so.8.1 => /opt/intel/composer_xe_2013_sp1.3.174/ipp/lib/intel64/libippcore.so.8.1 (0x00002b667057f000)

[

YUV422 10bits: Conformance issues with H264 decoder IPP samples 8.0.0.005

$
0
0

Hi all,

I have many conformance issues on YUV 4:2:2 10 bits H264 streams using the H264 decoder from IPP samples 8.0.0.005 and IPP 8.1.

I used conformance streams from Sony and I compared with JM 18.4. 

Errors are only on some pixels and are a difference of one or two.

Are there any fixes already available somewhere?

 

Matthieu 

AttachmentSize
DownloadBugIPP.zip4.85 MB

MP4 muxer with H264 encoder - debug vs release

$
0
0

Hi,

I have some grayscale frames and I need to create an mp4 video with H264 encoding out of it. I am using Intel IPP Samples 7.0.1.

The application works fine in debug but doesn't in release configuration. The mp4 output in release has the correct size, duration and dimensions, but the image wont play in any player.

This is not the case in debug mode or when I do debug with breakpoints in release mode (which I guess makes the execution a bit slow for the encoder/muxer to work properly).After some investigation, it seems that due to optimizations in release mode, the execution is very fast and hence proper mp4 output is not generated. 

he documentation says that according to the H264 algorithm there could be some B frames pending in the buffer and they need flushed, so I tried passing NULL to the encoder and retrieve pending frames. But even that didnt help in release mode.

Should I try flushing the muxer? but at what stage? 

I am attaching the input 8 bit grayscale image (1024 X 1024 X 100 frames).

 

Please find my code below 

//initialize code for the mp4 creator
bool MP4::Initialize(const int& numFrames, const int& frameWidth, const int& frameHeight, const int& frameRate, const std::string& fullfilepath)
{
	m_width = frameWidth;
	m_height = frameHeight;
	m_bitDepth = 8;
	m_numFrames = numFrames;
	m_currentFrameIndex = 0;


	vm_string_strcpy(writerParams.m_file_name, fullfilepath.c_str());
	writerParams.m_portion_size = 0;
	result = writer.Init(&writerParams);

	videoInfo.clip_info.height = frameHeight;
	videoInfo.clip_info.width = frameWidth;
	videoInfo.stream_type = UMC::VideoStreamType::H264_VIDEO;
	videoInfo.color_format = UMC::ColorFormat::YUV420;
	videoInfo.interlace_type = UMC::InterlaceType::PROGRESSIVE;
	videoInfo.bitrate = 10000000;
	videoInfo.framerate = float(frameRate);
	videoInfo.streamPID = 0;
	videoInfo.duration = float(numFrames) / frameRate;

	muxerParams.m_lpDataWriter = &writer;
	muxerParams.m_SystemType = UMC::SystemStreamType::H264_PURE_VIDEO_STREAM;
	muxerParams.m_lFlags = FLAG_FRAGMENTED_AT_I_PICTURES;
	muxerParams.m_nNumberOfTracks = 1;
	muxerParams.pTrackParams = new UMC::TrackParams[1];//&videoTrackParams;
	muxerParams.pTrackParams[0].type = UMC::VIDEO_TRACK;
	muxerParams.pTrackParams[0].info.video = &videoInfo;
	muxerParams.pTrackParams[0].bufferParams.m_numberOfFrames = numFrames;


	result = m_MP4muxer.Init(&muxerParams);

	m_H264EncoderParams.key_frame_controls.method=1;
	m_H264EncoderParams.info.clip_info.height=frameHeight;
	m_H264EncoderParams.info.clip_info.width=frameWidth;
	m_H264EncoderParams.info.bitrate = 10000000;
	m_H264EncoderParams.numThreads = 1;
	m_H264EncoderParams.chroma_format_idc = 1;
	m_H264EncoderParams.numFramesToEncode = numFrames;
	m_H264EncoderParams.info.duration = (float)numFrames/frameRate;
	m_H264EncoderParams.info.framerate = frameRate;

	result = m_H264Encoder.Init(&m_H264EncoderParams);
	return result == UMC_OK;
}

 

//Add frame code for mp4 creator
bool MP4::AddFrame(void* frameData) // framedata is 8 bit grayscale image
{
	int yuvframeSize = m_width * m_height * 3/2;
	Ipp8u* yuvPixels = ippsMalloc_8u(yuvframeSize);
	memset(yuvPixels, 127, yuvframeSize); 						//neutral values for u and v components
	memcpy(yuvPixels, frameData, m_width * m_height); // grayscale to yuv completed

	UMC::VideoData uncompressedData;
	uncompressedData.Init(m_width, m_height, UMC::ColorFormat::YUV420, m_bitDepth);
	uncompressedData.SetBufferPointer(yuvPixels, yuvframeSize);
	uncompressedData.SetDataSize(yuvframeSize);

	UMC::MediaData videoData;
	result = m_MP4muxer.LockBuffer(&videoData, 0);
	result = m_H264Encoder.GetFrame(&uncompressedData, &videoData);

	Ipp64f start = (m_currentFrameIndex/(float)m_numFrames)*m_H264EncoderParams.info.duration;
	Ipp64f end = ((m_currentFrameIndex+1)/(float)m_numFrames)*m_H264EncoderParams.info.duration;
	videoData.SetTime(start,end);

	result = m_MP4muxer.UnlockBuffer(&videoData,0);

	ippsFree(yuvPixels);
	m_currentFrameIndex++;
	return result == UMC::UMC_OK;
}

 

bool MP4::::Close()
{
	UMC::Status status = UMC::UMC_OK;
	status = m_MP4muxer.PutEndOfStream(0);
	status = m_MP4muxer.Close();
	delete [] muxerParams.pTrackParams;
	return status == UMC::UMC_OK;
}

 

 

Client Code

#include <fstream>
#include <mp4.h>
using namespace std;
using namespace IntelIPP;

void main()
{
	int width = 1024;
	int height = 1024;
	int numFrames = 100;
	int frameRate = 10;
	int frameSize = width*height;

	char* rawData = new char[frameSize* numFrames];

	ifstream fxdFile;
	fxdFile.open("D:\\Temp\\testImage.raw",std::ios::binary);
	fxdFile.read(rawData, frameSize*numFrames);
	fxdFile.close();

	MP4 mp4creator;
	mp4creator.Initialize(numFrames, width, height, frameRate, "D:\\Temp\\video.mp4");

	char* frame = new char[frameSize];
	for(int i = 0; i<numFrames; i++)
	{
		memcpy(frame, rawData + i*frameSize, frameSize);
		mp4creator.AddFrame(frame);
	}

	mp4creator.Close();
}

 

AttachmentSize
DownloadtestImage.raw_.txt100 MB
Viewing all 1294 articles
Browse latest View live


<script src="https://jsc.adskeeper.com/r/s/rssing.com.1596347.js" async> </script>