int main(int argc, char **argv){
uint8_t *rgb_data = malloc (W*H*4);
uint8_t *rgb_src[3]= {rgb_data, NULL, NULL};
int rgb_stride[3]={4*W, 0, 0};
uint8_t *data = malloc (3*W*H);
uint8_t *src[3]= {data, data+W*H, data+W*H*2};
int stride[3]={W, W, W};
int x, y;
struct SwsContext *sws;
sws= sws_getContext(W/12, H/12, PIX_FMT_RGB32, W, H, PIX_FMT_YUV420P, 2, NULL, NULL, NULL);
for (y=0; y<H; y++){
for (x=0; x<W*4; x++){
rgb_data[ x + y*4*W]= random();
}
}
#if defined(ARCH_X86)
sws_rgb2rgb_init(SWS_CPU_CAPS_MMX*0);
#else
sws_rgb2rgb_init(0);
#endif
sws_scale(sws, rgb_src, rgb_stride, 0, H, src, stride);
#if defined(ARCH_X86)
asm volatile ("emms\n\t");
#endif
selfTest(src, stride, W, H);
return 123;
}
static int preinit(const char *vo_subdevice)
{
uint32_t ver;
const char *devname=vo_subdevice?vo_subdevice:"/dev/mga_vid";
sws_rgb2rgb_init(get_sws_cpuflags());
f = open(devname,O_RDWR);
if(f == -1)
{
perror("open");
mp_msg(MSGT_VO,MSGL_WARN, MSGTR_LIBVO_MGA_CouldntOpen,devname);
return -1;
}
// check whether the mga_vid driver has the same
// version as we expect
ioctl(f,MGA_VID_GET_VERSION,&ver);
if(MGA_VID_VERSION != ver)
{
mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_MGA_mgavidVersionMismatch, ver, MGA_VID_VERSION);
return -1;
}
#ifdef VO_XMGA
if (!vo_init()) {
close(f);
return -1;
}
#endif
return 0;
}
static int config(struct vf_instance_s* vf,
int width, int height, int d_width, int d_height,
unsigned int flags, unsigned int outfmt){
sws_rgb2rgb_init(get_sws_cpuflags());
if(vf_next_query_format(vf,IMGFMT_YUY2)<=0){
mp_msg(MSGT_VFILTER, MSGL_WARN, MSGTR_MPCODECS_WarnNextFilterDoesntSupport, "YUY2");
return 0;
}
return vf_next_config(vf,width,height,d_width,d_height,flags,IMGFMT_YUY2);
}
int main(int argc, char **argv)
{
int i, funcNum;
uint8_t *srcBuffer = av_malloc(SIZE);
uint8_t *dstBuffer = av_malloc(SIZE);
int failedNum = 0;
int passedNum = 0;
if (!srcBuffer || !dstBuffer)
return -1;
av_log(NULL, AV_LOG_INFO, "memory corruption test ...\n");
sws_rgb2rgb_init();
for (funcNum = 0; ; funcNum++) {
struct func_info_s {
int src_bpp;
int dst_bpp;
const char *name;
void (*func)(const uint8_t *src, uint8_t *dst, int src_size);
} func_info[] = {
FUNC(2, 2, rgb15to16),
FUNC(2, 3, rgb15to24),
FUNC(2, 4, rgb15to32),
FUNC(2, 3, rgb16to24),
FUNC(2, 4, rgb16to32),
FUNC(3, 2, rgb24to15),
FUNC(3, 2, rgb24to16),
FUNC(3, 4, rgb24to32),
FUNC(4, 2, rgb32to15),
FUNC(4, 2, rgb32to16),
FUNC(4, 3, rgb32to24),
FUNC(2, 2, rgb16to15),
FUNC(2, 2, rgb15tobgr15),
FUNC(2, 2, rgb15tobgr16),
FUNC(2, 3, rgb15tobgr24),
FUNC(2, 4, rgb15tobgr32),
FUNC(2, 2, rgb16tobgr15),
FUNC(2, 2, rgb16tobgr16),
FUNC(2, 3, rgb16tobgr24),
FUNC(2, 4, rgb16tobgr32),
FUNC(3, 2, rgb24tobgr15),
FUNC(3, 2, rgb24tobgr16),
FUNC(3, 3, rgb24tobgr24),
FUNC(3, 4, rgb24tobgr32),
FUNC(4, 2, rgb32tobgr15),
FUNC(4, 2, rgb32tobgr16),
FUNC(4, 3, rgb32tobgr24),
FUNC(4, 4, shuffle_bytes_2103), /* rgb32tobgr32 */
FUNC(0, 0, NULL)
};
int width;
int failed = 0;
int srcBpp = 0;
int dstBpp = 0;
if (!func_info[funcNum].func)
break;
av_log(NULL, AV_LOG_INFO, ".");
memset(srcBuffer, srcByte, SIZE);
for (width = 63; width > 0; width--) {
int dstOffset;
for (dstOffset = 128; dstOffset < 196; dstOffset += 4) {
int srcOffset;
memset(dstBuffer, dstByte, SIZE);
for (srcOffset = 128; srcOffset < 196; srcOffset += 4) {
uint8_t *src = srcBuffer + srcOffset;
uint8_t *dst = dstBuffer + dstOffset;
const char *name = NULL;
// don't fill the screen with shit ...
if (failed)
break;
srcBpp = func_info[funcNum].src_bpp;
dstBpp = func_info[funcNum].dst_bpp;
name = func_info[funcNum].name;
func_info[funcNum].func(src, dst, width * srcBpp);
if (!srcBpp)
break;
for (i = 0; i < SIZE; i++) {
if (srcBuffer[i] != srcByte) {
av_log(NULL, AV_LOG_INFO,
"src damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name);
failed = 1;
break;
}
}
for (i = 0; i < dstOffset; i++) {
if (dstBuffer[i] != dstByte) {
av_log(NULL, AV_LOG_INFO,
"dst damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name);
failed = 1;
break;
}
}
for (i = dstOffset + width * dstBpp; i < SIZE; i++) {
if (dstBuffer[i] != dstByte) {
av_log(NULL, AV_LOG_INFO,
"dst damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name);
failed = 1;
break;
}
}
}
}
}
if (failed)
failedNum++;
else if (srcBpp)
passedNum++;
}
av_log(NULL, AV_LOG_INFO,
"\n%d converters passed, %d converters randomly overwrote memory\n",
passedNum, failedNum);
return failedNum;
}
void wsXInit( void* mDisplay )
{
int eventbase;
int errorbase;
if(mDisplay){
wsDisplay=mDisplay;
} else {
char * DisplayName = ":0.0";
if ( getenv( "DISPLAY" ) ) DisplayName=getenv( "DISPLAY" );
wsDisplay=XOpenDisplay( DisplayName );
if ( !wsDisplay )
{
mp_msg( MSGT_GPLAYER,MSGL_FATAL,MSGTR_WS_CouldNotOpenDisplay );
exit( 0 );
}
}
/* enable DND atoms */
wsXDNDInitialize();
{ /* on remote display XShm will be disabled - LGB */
char *dispname=DisplayString(wsDisplay);
int localdisp=1;
if (dispname&&*dispname!=':') {
localdisp=0;
wsUseXShm=0;
}
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"[ws] display name: %s => %s display.\n",dispname,localdisp?"local":"REMOTE");
if (!localdisp) mp_msg( MSGT_GPLAYER,MSGL_V,MSGTR_WS_RemoteDisplay );
}
if ( !XShmQueryExtension( wsDisplay ) )
{
mp_msg( MSGT_GPLAYER,MSGL_ERR,MSGTR_WS_NoXshm );
wsUseXShm=0;
}
#ifdef HAVE_XSHAPE
if ( !XShapeQueryExtension( wsDisplay,&eventbase,&errorbase ) )
{
mp_msg( MSGT_GPLAYER,MSGL_ERR,MSGTR_WS_NoXshape );
wsUseXShape=0;
}
#else
wsUseXShape=0;
#endif
XSynchronize( wsDisplay,True );
wsScreen=DefaultScreen( wsDisplay );
wsRootWin=RootWindow( wsDisplay,wsScreen );
#ifdef HAVE_XF86VM
{
int clock;
XF86VidModeModeLine modeline;
XF86VidModeGetModeLine( wsDisplay,wsScreen,&clock ,&modeline );
wsMaxX=modeline.hdisplay;
wsMaxY=modeline.vdisplay;
}
#endif
{
wsOrgX = wsOrgY = 0;
if ( !wsMaxX )
wsMaxX=DisplayWidth( wsDisplay,wsScreen );
if ( !wsMaxY )
wsMaxY=DisplayHeight( wsDisplay,wsScreen );
}
vo_screenwidth = wsMaxX; vo_screenheight = wsMaxY;
xinerama_x = wsOrgX; xinerama_y = wsOrgY;
update_xinerama_info();
wsMaxX = vo_screenwidth; wsMaxY = vo_screenheight;
wsOrgX = xinerama_x; wsOrgY = xinerama_y;
wsGetDepthOnScreen();
#ifdef DEBUG
{
int minor,major,shp;
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] Screen depth: %d\n",wsDepthOnScreen );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] size: %dx%d\n",wsMaxX,wsMaxY );
#ifdef HAVE_XINERAMA
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] origin: +%d+%d\n",wsOrgX,wsOrgY );
#endif
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] red mask: 0x%x\n",wsRedMask );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] green mask: 0x%x\n",wsGreenMask );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] blue mask: 0x%x\n",wsBlueMask );
if ( wsUseXShm )
{
XShmQueryVersion( wsDisplay,&major,&minor,&shp );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] XShm version is %d.%d\n",major,minor );
}
#ifdef HAVE_XSHAPE
if ( wsUseXShape )
{
XShapeQueryVersion( wsDisplay,&major,&minor );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] XShape version is %d.%d\n",major,minor );
}
#endif
}
#endif
wsOutMask=wsGetOutMask();
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"[ws] Initialized converter: " );
sws_rgb2rgb_init(get_sws_cpuflags());
switch ( wsOutMask )
{
case wsRGB32:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb32\n" );
wsConvFunc=rgb32torgb32;
break;
case wsBGR32:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr32\n" );
wsConvFunc=rgb32tobgr32;
break;
case wsRGB24:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb24\n" );
wsConvFunc=rgb32to24;
break;
case wsBGR24:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr24\n" );
wsConvFunc=rgb32tobgr24;
break;
case wsRGB16:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb16\n" );
wsConvFunc=rgb32to16;
break;
case wsBGR16:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr16\n" );
wsConvFunc=rgb32tobgr16;
break;
case wsRGB15:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb15\n" );
wsConvFunc=rgb32to15;
break;
case wsBGR15:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr15\n" );
wsConvFunc=rgb32tobgr15;
break;
}
XSetErrorHandler( wsErrorHandler );
}
int main(int argc, char **argv)
{
int i, funcNum;
uint8_t *srcBuffer= (uint8_t*)av_malloc(SIZE);
uint8_t *dstBuffer= (uint8_t*)av_malloc(SIZE);
int failedNum=0;
int passedNum=0;
av_log(NULL, AV_LOG_INFO, "memory corruption test ...\n");
args_parse(argc, argv);
av_log(NULL, AV_LOG_INFO, "CPU capabilities forced to %x\n", cpu_caps);
sws_rgb2rgb_init(cpu_caps);
for(funcNum=0; funcNum<100; funcNum++){
int width;
int failed=0;
int srcBpp=0;
int dstBpp=0;
av_log(NULL, AV_LOG_INFO,".");
memset(srcBuffer, srcByte, SIZE);
for(width=32; width<64; width++){
int dstOffset;
for(dstOffset=128; dstOffset<196; dstOffset+=4){
int srcOffset;
memset(dstBuffer, dstByte, SIZE);
for(srcOffset=128; srcOffset<196; srcOffset+=4){
uint8_t *src= srcBuffer+srcOffset;
uint8_t *dst= dstBuffer+dstOffset;
char *name=NULL;
if(failed) break; //don't fill the screen with shit ...
switch(funcNum){
case 0:
srcBpp=2;
dstBpp=2;
name="rgb15to16";
rgb15to16(src, dst, width*srcBpp);
break;
case 1:
srcBpp=2;
dstBpp=3;
name="rgb15to24";
rgb15to24(src, dst, width*srcBpp);
break;
case 2:
srcBpp=2;
dstBpp=4;
name="rgb15to32";
rgb15to32(src, dst, width*srcBpp);
break;
case 3:
srcBpp=2;
dstBpp=3;
name="rgb16to24";
rgb16to24(src, dst, width*srcBpp);
break;
case 4:
srcBpp=2;
dstBpp=4;
name="rgb16to32";
rgb16to32(src, dst, width*srcBpp);
break;
case 5:
srcBpp=3;
dstBpp=2;
name="rgb24to15";
rgb24to15(src, dst, width*srcBpp);
break;
case 6:
srcBpp=3;
dstBpp=2;
name="rgb24to16";
rgb24to16(src, dst, width*srcBpp);
break;
case 7:
srcBpp=3;
dstBpp=4;
name="rgb24to32";
rgb24to32(src, dst, width*srcBpp);
break;
case 8:
srcBpp=4;
dstBpp=2;
name="rgb32to15";
//((*s++) << TGA_SHIFT32) | TGA_ALPHA32;
rgb32to15(src, dst, width*srcBpp);
break;
case 9:
srcBpp=4;
dstBpp=2;
name="rgb32to16";
rgb32to16(src, dst, width*srcBpp);
break;
case 10:
srcBpp=4;
dstBpp=3;
name="rgb32to24";
rgb32to24(src, dst, width*srcBpp);
break;
case 11:
srcBpp=2;
dstBpp=2;
name="rgb16to15";
rgb16to15(src, dst, width*srcBpp);
break;
case 14:
srcBpp=2;
dstBpp=2;
name="rgb15tobgr15";
rgb15tobgr15(src, dst, width*srcBpp);
break;
case 15:
srcBpp=2;
dstBpp=2;
name="rgb15tobgr16";
rgb15tobgr16(src, dst, width*srcBpp);
break;
case 16:
srcBpp=2;
dstBpp=3;
name="rgb15tobgr24";
rgb15tobgr24(src, dst, width*srcBpp);
break;
case 17:
srcBpp=2;
dstBpp=4;
name="rgb15tobgr32";
rgb15tobgr32(src, dst, width*srcBpp);
break;
case 18:
srcBpp=2;
dstBpp=2;
name="rgb16tobgr15";
rgb16tobgr15(src, dst, width*srcBpp);
break;
case 19:
srcBpp=2;
dstBpp=2;
name="rgb16tobgr16";
rgb16tobgr16(src, dst, width*srcBpp);
break;
case 20:
srcBpp=2;
dstBpp=3;
name="rgb16tobgr24";
rgb16tobgr24(src, dst, width*srcBpp);
break;
case 21:
srcBpp=2;
dstBpp=4;
name="rgb16tobgr32";
rgb16tobgr32(src, dst, width*srcBpp);
break;
case 22:
srcBpp=3;
dstBpp=2;
name="rgb24tobgr15";
rgb24tobgr15(src, dst, width*srcBpp);
break;
case 23:
srcBpp=3;
dstBpp=2;
name="rgb24tobgr16";
rgb24tobgr16(src, dst, width*srcBpp);
break;
case 24:
srcBpp=3;
dstBpp=3;
name="rgb24tobgr24";
rgb24tobgr24(src, dst, width*srcBpp);
break;
case 25:
srcBpp=3;
dstBpp=4;
name="rgb24tobgr32";
rgb24tobgr32(src, dst, width*srcBpp);
break;
case 26:
srcBpp=4;
dstBpp=2;
name="rgb32tobgr15";
rgb32tobgr15(src, dst, width*srcBpp);
break;
case 27:
srcBpp=4;
dstBpp=2;
name="rgb32tobgr16";
rgb32tobgr16(src, dst, width*srcBpp);
break;
case 28:
srcBpp=4;
dstBpp=3;
name="rgb32tobgr24";
rgb32tobgr24(src, dst, width*srcBpp);
break;
case 29:
srcBpp=4;
dstBpp=4;
name="rgb32tobgr32";
rgb32tobgr32(src, dst, width*srcBpp);
break;
}
if(!srcBpp) break;
for(i=0; i<SIZE; i++){
if(srcBuffer[i]!=srcByte){
av_log(NULL, AV_LOG_INFO, "src damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name);
failed=1;
break;
}
}
for(i=0; i<dstOffset; i++){
if(dstBuffer[i]!=dstByte){
av_log(NULL, AV_LOG_INFO, "dst damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name);
failed=1;
break;
}
}
for(i=dstOffset + width*dstBpp; i<SIZE; i++){
if(dstBuffer[i]!=dstByte){
av_log(NULL, AV_LOG_INFO, "dst damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name);
failed=1;
break;
}
}
}
}
}
if(failed) failedNum++;
else if(srcBpp) passedNum++;
}
av_log(NULL, AV_LOG_INFO, "%d converters passed, %d converters randomly overwrote memory\n", passedNum, failedNum);
return failedNum;
}
main(int argc, char **argv)
{
int i, funcNum;
uint8_t *srcBuffer= (uint8_t*)memalign(128, SIZE);
uint8_t *dstBuffer= (uint8_t*)memalign(128, SIZE);
int failedNum=0;
int passedNum=0;
printf("memory corruption test ...\n");
if(argc==2){
GetCpuCaps(&gCpuCaps);
printf("testing mmx\n");
}
sws_rgb2rgb_init(get_sws_cpuflags());
for(funcNum=0; funcNum<100; funcNum++){
int width;
int failed=0;
int srcBpp=0;
int dstBpp=0;
printf("."); fflush(stdout);
memset(srcBuffer, srcByte, SIZE);
for(width=32; width<64; width++){
int dstOffset;
for(dstOffset=128; dstOffset<196; dstOffset++){
int srcOffset;
memset(dstBuffer, dstByte, SIZE);
for(srcOffset=128; srcOffset<196; srcOffset++){
uint8_t *src= srcBuffer+srcOffset;
uint8_t *dst= dstBuffer+dstOffset;
char *name=NULL;
if(failed) break; //don't fill the screen with shit ...
switch(funcNum){
case 0:
srcBpp=2;
dstBpp=2;
name="rgb15to16";
rgb15to16(src, dst, width*srcBpp);
break;
case 1:
srcBpp=2;
dstBpp=3;
name="rgb15to24";
rgb15to24(src, dst, width*srcBpp);
break;
case 2:
srcBpp=2;
dstBpp=4;
name="rgb15to32";
rgb15to32(src, dst, width*srcBpp);
break;
case 3:
srcBpp=2;
dstBpp=3;
name="rgb16to24";
rgb16to24(src, dst, width*srcBpp);
break;
case 4:
srcBpp=2;
dstBpp=4;
name="rgb16to32";
rgb16to32(src, dst, width*srcBpp);
break;
case 5:
srcBpp=3;
dstBpp=2;
name="rgb24to15";
rgb24to15(src, dst, width*srcBpp);
break;
case 6:
srcBpp=3;
dstBpp=2;
name="rgb24to16";
rgb24to16(src, dst, width*srcBpp);
break;
case 7:
srcBpp=3;
dstBpp=4;
name="rgb24to32";
rgb24to32(src, dst, width*srcBpp);
break;
case 8:
srcBpp=4;
dstBpp=2;
name="rgb32to15";
rgb32to15(src, dst, width*srcBpp);
break;
case 9:
srcBpp=4;
dstBpp=2;
name="rgb32to16";
rgb32to16(src, dst, width*srcBpp);
break;
case 10:
srcBpp=4;
dstBpp=3;
name="rgb32to24";
rgb32to24(src, dst, width*srcBpp);
break;
case 11:
srcBpp=2;
dstBpp=2;
name="rgb16to15";
rgb16to15(src, dst, width*srcBpp);
break;
case 14:
srcBpp=2;
dstBpp=2;
name="rgb15tobgr15";
rgb15tobgr15(src, dst, width*srcBpp);
break;
case 15:
srcBpp=2;
dstBpp=2;
name="rgb15tobgr16";
rgb15tobgr16(src, dst, width*srcBpp);
break;
case 16:
srcBpp=2;
dstBpp=3;
name="rgb15tobgr24";
rgb15tobgr24(src, dst, width*srcBpp);
break;
case 17:
srcBpp=2;
dstBpp=4;
name="rgb15tobgr32";
rgb15tobgr32(src, dst, width*srcBpp);
break;
case 18:
srcBpp=2;
dstBpp=2;
name="rgb16tobgr15";
rgb16tobgr15(src, dst, width*srcBpp);
break;
case 19:
srcBpp=2;
dstBpp=2;
name="rgb16tobgr16";
rgb16tobgr16(src, dst, width*srcBpp);
break;
case 20:
srcBpp=2;
dstBpp=3;
name="rgb16tobgr24";
rgb16tobgr24(src, dst, width*srcBpp);
break;
case 21:
srcBpp=2;
dstBpp=4;
name="rgb16tobgr32";
rgb16tobgr32(src, dst, width*srcBpp);
break;
case 22:
srcBpp=3;
dstBpp=2;
name="rgb24tobgr15";
rgb24tobgr15(src, dst, width*srcBpp);
break;
case 23:
srcBpp=3;
dstBpp=2;
name="rgb24tobgr16";
rgb24tobgr16(src, dst, width*srcBpp);
break;
case 24:
srcBpp=3;
dstBpp=3;
name="rgb24tobgr24";
rgb24tobgr24(src, dst, width*srcBpp);
break;
case 25:
srcBpp=3;
dstBpp=4;
name="rgb24tobgr32";
rgb24tobgr32(src, dst, width*srcBpp);
break;
case 26:
srcBpp=4;
dstBpp=2;
name="rgb32tobgr15";
rgb32tobgr15(src, dst, width*srcBpp);
break;
case 27:
srcBpp=4;
dstBpp=2;
name="rgb32tobgr16";
rgb32tobgr16(src, dst, width*srcBpp);
break;
case 28:
srcBpp=4;
dstBpp=3;
name="rgb32tobgr24";
rgb32tobgr24(src, dst, width*srcBpp);
break;
case 29:
srcBpp=4;
dstBpp=4;
name="rgb32tobgr32";
rgb32tobgr32(src, dst, width*srcBpp);
break;
}
if(!srcBpp) break;
for(i=0; i<SIZE; i++){
if(srcBuffer[i]!=srcByte){
printf("src damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name);
failed=1;
break;
}
}
for(i=0; i<dstOffset; i++){
if(dstBuffer[i]!=dstByte){
printf("dst damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name);
failed=1;
break;
}
}
for(i=dstOffset + width*dstBpp; i<SIZE; i++){
if(dstBuffer[i]!=dstByte){
printf("dst damaged at %d w:%d src:%d dst:%d %s\n",
i, width, srcOffset, dstOffset, name);
failed=1;
break;
}
}
}
}
}
if(failed) failedNum++;
else if(srcBpp) passedNum++;
}
printf("%d converters passed, %d converters randomly overwrote memory\n", passedNum, failedNum);
return failedNum;
}
