void displayFunc(void)
{
sdkStartTimer(&timer);
TColor *d_dst = NULL;
size_t num_bytes;
if (frameCounter++ == 0)
{
sdkResetTimer(&timer);
}
// DEPRECATED: checkCudaErrors(cudaGLMapBufferObject((void**)&d_dst, gl_PBO));
checkCudaErrors(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
getLastCudaError("cudaGraphicsMapResources failed");
checkCudaErrors(cudaGraphicsResourceGetMappedPointer((void **)&d_dst, &num_bytes, cuda_pbo_resource));
getLastCudaError("cudaGraphicsResourceGetMappedPointer failed");
checkCudaErrors(CUDA_Bind2TextureArray());
runImageFilters(d_dst);
checkCudaErrors(CUDA_UnbindTexture());
// DEPRECATED: checkCudaErrors(cudaGLUnmapBufferObject(gl_PBO));
checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
// Common display code path
{
glClear(GL_COLOR_BUFFER_BIT);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, imageW, imageH, GL_RGBA, GL_UNSIGNED_BYTE, BUFFER_DATA(0));
glBegin(GL_TRIANGLES);
glTexCoord2f(0, 0);
glVertex2f(-1, -1);
glTexCoord2f(2, 0);
glVertex2f(+3, -1);
glTexCoord2f(0, 2);
glVertex2f(-1, +3);
glEnd();
glFinish();
}
if (frameCounter == frameN)
{
frameCounter = 0;
if (g_FPS)
{
printf("FPS: %3.1f\n", frameN / (sdkGetTimerValue(&timer) * 0.001));
g_FPS = false;
}
}
glutSwapBuffers();
glutReportErrors();
sdkStopTimer(&timer);
computeFPS();
}
void runAutoTest(int argc, char **argv, const char *filename, int kernel_param)
{
printf("[%s] - (automated testing w/ readback)\n", sSDKsample);
int devID = findCudaDevice(argc, (const char **)argv);
// First load the image, so we know what the size of the image (imageW and imageH)
printf("Allocating host and CUDA memory and loading image file...\n");
const char *image_path = sdkFindFilePath("portrait_noise.bmp", argv[0]);
if (image_path == NULL)
{
printf("imageDenoisingGL was unable to find and load image file <portrait_noise.bmp>.\nExiting...\n");
exit(EXIT_FAILURE);
}
LoadBMPFile(&h_Src, &imageW, &imageH, image_path);
printf("Data init done.\n");
checkCudaErrors(CUDA_MallocArray(&h_Src, imageW, imageH));
TColor *d_dst = NULL;
unsigned char *h_dst = NULL;
checkCudaErrors(cudaMalloc((void **)&d_dst, imageW*imageH*sizeof(TColor)));
h_dst = (unsigned char *)malloc(imageH*imageW*4);
{
g_Kernel = kernel_param;
printf("[AutoTest]: %s <%s>\n", sSDKsample, filterMode[g_Kernel]);
checkCudaErrors(CUDA_Bind2TextureArray());
runImageFilters(d_dst);
checkCudaErrors(CUDA_UnbindTexture());
checkCudaErrors(cudaDeviceSynchronize());
checkCudaErrors(cudaMemcpy(h_dst, d_dst, imageW*imageH*sizeof(TColor), cudaMemcpyDeviceToHost));
sdkSavePPM4ub(filename, h_dst, imageW, imageH);
}
checkCudaErrors(CUDA_FreeArray());
free(h_Src);
checkCudaErrors(cudaFree(d_dst));
free(h_dst);
printf("\n[%s] -> Kernel %d, Saved: %s\n", sSDKsample, kernel_param, filename);
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
cudaDeviceReset();
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
void runAutoTest(int argc, char **argv)
{
int devID = 0;
printf("[%s] - (automated testing w/ readback)\n", sSDKsample);
devID = cutilChooseCudaDevice(argc, argv);
// First load the image, so we know what the size of the image (imageW and imageH)
printf("Allocating host and CUDA memory and loading image file...\n");
const char *image_path = cutFindFilePath("portrait_noise.bmp", argv[0]);
if (image_path == NULL) {
printf( "imageDenoisingGL was unable to find and load image file <portrait_noise.bmp>.\nExiting...\n");
shrQAFinishExit(argc, (const char **)argv, QA_FAILED);
}
LoadBMPFile(&h_Src, &imageW, &imageH, image_path);
printf("Data init done.\n");
cutilSafeCall( CUDA_MallocArray(&h_Src, imageW, imageH) );
g_CheckRender = new CheckBackBuffer(imageW, imageH, sizeof(TColor), false);
g_CheckRender->setExecPath(argv[0]);
TColor *d_dst = NULL;
cutilSafeCall( cudaMalloc( (void **)&d_dst, imageW*imageH*sizeof(TColor)) );
while (g_Kernel <= 3) {
printf("[AutoTest]: %s <%s>\n", sSDKsample, filterMode[g_Kernel]);
cutilSafeCall( CUDA_Bind2TextureArray() );
runImageFilters(d_dst);
cutilSafeCall( CUDA_UnbindTexture() );
cutilSafeCall( cutilDeviceSynchronize() );
cudaMemcpy(g_CheckRender->imageData(), d_dst, imageW*imageH*sizeof(TColor), cudaMemcpyDeviceToHost);
g_CheckRender->savePPM(sOriginal[g_Kernel], true, NULL);
if (!g_CheckRender->PPMvsPPM(sOriginal[g_Kernel], sReference[g_Kernel], MAX_EPSILON_ERROR, 0.15f)) {
g_TotalErrors++;
}
g_Kernel++;
}
cutilSafeCall( CUDA_FreeArray() );
free(h_Src);
cutilSafeCall( cudaFree( d_dst ) );
delete g_CheckRender;
printf("\n[%s] -> Test Results: %d errors\n", sSDKsample, g_TotalErrors);
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, (!g_TotalErrors ? QA_PASSED : QA_FAILED));
}
void displayFunc(void){
cutStartTimer(hTimer);
TColor *d_dst = NULL;
size_t num_bytes;
if(frameCounter++ == 0) cutResetTimer(hTimer);
// DEPRECATED: cutilSafeCall(cudaGLMapBufferObject((void**)&d_dst, gl_PBO));
cutilSafeCall(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
cutilCheckMsg("cudaGraphicsMapResources failed");
cutilSafeCall(cudaGraphicsResourceGetMappedPointer((void**)&d_dst, &num_bytes, cuda_pbo_resource));
cutilCheckMsg("cudaGraphicsResourceGetMappedPointer failed");
cutilSafeCall( CUDA_Bind2TextureArray() );
runImageFilters(d_dst);
cutilSafeCall( CUDA_UnbindTexture() );
// DEPRECATED: cutilSafeCall(cudaGLUnmapBufferObject(gl_PBO));
cutilSafeCall(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
if (g_bFBODisplay) {
g_FrameBufferObject->bindRenderPath();
}
// Common display code path
{
glClear(GL_COLOR_BUFFER_BIT);
glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, imageW, imageH, GL_RGBA, GL_UNSIGNED_BYTE, BUFFER_DATA(0) );
glBegin(GL_TRIANGLES);
glTexCoord2f(0, 0); glVertex2f(-1, -1);
glTexCoord2f(2, 0); glVertex2f(+3, -1);
glTexCoord2f(0, 2); glVertex2f(-1, +3);
glEnd();
glFinish();
}
if (g_bFBODisplay) {
g_FrameBufferObject->unbindRenderPath();
glBindTexture(GL_TEXTURE_2D, 0);
}
if (g_CheckRender && g_CheckRender->IsQAReadback() && g_Verify) {
printf("> (Frame %d) readback BackBuffer\n", frameCount);
if (g_bFBODisplay) {
g_CheckRender->readback( imageW, imageH, g_FrameBufferObject->getFbo() );
} else {
g_CheckRender->readback( imageW, imageH );
}
g_CheckRender->savePPM ( sOriginal[g_Kernel], true, NULL );
if (!g_CheckRender->PPMvsPPM(sOriginal[g_Kernel], sReference[g_Kernel], MAX_EPSILON_ERROR, 0.15f)) {
g_TotalErrors++;
}
g_Verify = false;
}
if(frameCounter == frameN){
frameCounter = 0;
if(g_FPS){
printf("FPS: %3.1f\n", frameN / (cutGetTimerValue(hTimer) * 0.001) );
g_FPS = false;
}
}
glutSwapBuffers();
cutStopTimer(hTimer);
computeFPS();
}
