DM8148 开发记录 四 opencv 应用c6accel

http://software-dl.ti.com/dsps/dsps_public_sw/c6000/web/c6accel/latest/index_FDS.html 下载地址

http://software-dl.ti.com/dsps/dsps_public_sw/ezsdk/index.html

For C6Accel 2.01.00.11 and later

C6Accel 2.01.00.11 intergrates OpenCV functionality on the DSP along with other libraries. This release adds a test application and a new build target 'opencv_app' to build this in the package. There is a pre-requisite to build this opencv_app. This requires users to build OpenCV 2.x for the ARM as described here and place the OpenCV shared libraries on the target filesystem under the path $TARGETFS/usr/lib

After the prequisite step is complete execute make to build and install the OpenCV test application

make opencv_app
make opencv_app_install

 从以上的文字可以看出，要交叉编译opencv，因为，这个工具有做arm 和dsp运算速度的比较。所以要交叉编译opencv。其实这个，貌似不是很有必要，对于有些环节，移植opencv 到a8，都有困难。

我本人也在dm3730上完全移植过opencv 1.0 到codec engine中，改天把四路和代码一起贴出来。

c6accel 做的工作，很方便，不过如果要做优化，也要改动一部分的代码，貌似，源码都是打包好的

下面是dm8148的arm 和dsp 做opencv的耗时比较 的源码

/*================================================================================*/
 
/*   Copyright (c) 2010, Texas Instruments Incorporated                           */
 
/*   All rights reserved.                                                         */
 
/*                                                                                */
 
/*   Name: C6Accel_testfxns.c                                                     */
 
/*                                                                                */
 
/*   Descriptions:                                                                */
 
/*   File contains code to test kernels in the C6Accel codec                      */
 
/*                                                                                */
 
/*      Version: 0.0.1                                                            */
 
/*================================================================================*/
 
 
 
/* This define uses the new frame based (ie row and col parameters) that are optimised for C6Accel
 as they only request one operation on all rows rather than row operations*/
 
#define USE_NEW_FRAME_APIS
 
 
 
/*XDC and codec engine includes*/
 
#include <xdc/std.h>
 
#include <ti/sdo/ce/osal/Memory.h>
 
 
 
/* Run Time lib include files: */
 
#include <stdio.h>
 
#include <stdlib.h>
 
#include <string.h>
 
#include <stdarg.h>
 
#include <math.h>
 
//#include "precomp.hpp"
 
#include <ti/sdo/linuxutils/cmem/src/interface/cmem.h>
 
 
 
/* Declare MACROS that will be used for benchmarking*/
 
#include "benchmark.h"
 
 
 
/* Include C6ACCEL headers*/
 
#include "../../c6accelw/c6accelw.h"
 
#include "../../c6accelw/c6accelw_opencv.h"
 
 
 
// extra headers for OpenCV
 
/*#include <time.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/stat.h>*/
 
#include "opencv/highgui.h"
 
 
 
#define CVX_GRAY50 cvScalar(100,0,0,0)
 
#define CVX_WHITE  cvScalar(255,0,0,0)
 
 
 
/* Create default heap memory configuration for test functions */
 
static Memory_AllocParams testfxnsMemParams =
 
{
 
    Memory_CONTIGHEAP,
 
    Memory_CACHED,
 
    Memory_DEFAULTALIGNMENT,
 
    0
 
};
 
 
 
extern CMEM_AllocParams cvCmemParams;// = {CMEM_HEAP, CMEM_CACHED, 8};
 
 
 
 
 
/* Test for Floating point kernels */
 
/*
 * Test function for arithmetic rts single precision functions in this function
 */
 
// helper function - get overhead time
 
static int get_overhead_time(void)
 
{
 
        struct timeval startTime, endTime;
 
        
 
        gettimeofday(&startTime, NULL);
 
        gettimeofday(&endTime, NULL);
 
        
 
        return endTime.tv_usec - startTime.tv_usec;
 
}
 
 
 
Int c6accel_test_cvSobel(C6accel_Handle hC6accel, char *input_file_name, int n)
 
{
 
    IplImage *inputImg, *outputImg_arm, *outputImg_dsp, *scaleImg_arm, *scaleImg_dsp;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    float t_avg;
 
    
 
    printf("cvSobel Test (%s, %i iterations)\n", input_file_name, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input image from file
 
    inputImg = cvLoadImage( input_file_name, CV_LOAD_IMAGE_GRAYSCALE);
 
    
 
    // 2. Check image depth; require 8-bit
 
    if (inputImg->depth != IPL_DEPTH_8U && inputImg->depth != IPL_DEPTH_8S)
 
    {
 
        printf("C6accel_cvSobel test failed; input image must have 8-bit depth.\n");
 
        return 0;
 
    }
 
    
 
    // 3. Allocate output images (must have 16- and 8-bit depth; output MUST be 16S)
 
    outputImg_arm = cvCreateImage(cvSize(inputImg->width, inputImg->height), IPL_DEPTH_16S, 1);
 
    outputImg_dsp = cvCreateImage(cvSize(inputImg->width, inputImg->height), IPL_DEPTH_16S, 1);
 
    scaleImg_arm = cvCreateImage(cvSize(inputImg->width, inputImg->height), IPL_DEPTH_8U, 1);
 
    scaleImg_dsp = cvCreateImage(cvSize(inputImg->width, inputImg->height), IPL_DEPTH_8U, 1);
 
 
 
 
 
    //printf("outputImage: %x\n", CMEM_getPhys(outputImg_arm));
 
    // printf("outputImagedata: %x\n", CMEM_getPhys(outputImg_arm->imageData));
 
    // 4.a Apply ARM algorithm
 
    cvSobel(inputImg, outputImg_arm, 1, 1, 3); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvSobel(inputImg, outputImg_arm, 1, 1, 3);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM Sobel function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 4.b Apply DSP algorithm
 
    C6accel_cvSobel(hC6accel, inputImg, outputImg_dsp, 1, 1, 3); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvSobel(hC6accel, inputImg, outputImg_dsp, 1, 1, 3);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP Sobel function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 5.a Apply scale conversion on ARM
 
    cvConvertScale(outputImg_arm, scaleImg_arm, 0.5, 128); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvConvertScale(outputImg_arm, scaleImg_arm, 0.5, 128);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM ConvertScale function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 5.b Apply scale conversion on DSP
 
    C6accel_cvConvertScale(hC6accel, outputImg_dsp, scaleImg_dsp, 0.5, 128); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvConvertScale(hC6accel, outputImg_dsp, scaleImg_dsp, 0.5, 128);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP ConvertScale function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 6. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(scaleImg_arm, scaleImg_dsp, CV_L2, NULL));
 
    
 
    // 7. Save outputs to filesystem
 
    cvSaveImage("./output_arm.png", scaleImg_arm, 0);
 
    cvSaveImage("./output_dsp.png", scaleImg_dsp, 0);
 
    
 
    //Free memory as cvFree was not patched during the openCv build
 
    // printf("outputImage: %x\n", CMEM_getPhys(outputImg_arm));
 
    // printf("outputImagedata: %x\n", CMEM_getPhys(outputImg_arm->imageData));
 
 
 
    // Freeing memory
 
      cvReleaseImage(&outputImg_arm);
 
      cvReleaseImage(&outputImg_dsp);
 
      cvReleaseImage(&scaleImg_arm);
 
      cvReleaseImage(&scaleImg_dsp);
 
      cvReleaseImage(&inputImg);
 
 
 
    printf("C6accel_cvSobel test completed successfully; outputs saved to filesystem\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvFlip(C6accel_Handle hC6accel, char *input_file_name, int n)
 
{
 
    IplImage *inputImg, *outputImg_arm, *outputImg_dsp, *copyImg_arm, *copyImg_dsp;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    float t_avg;
 
    
 
    printf("cvFlip Test (%s, %i iterations)\n", input_file_name, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input image from file
 
    inputImg = cvLoadImage( input_file_name, CV_LOAD_IMAGE_COLOR);
 
    
 
    // 2. Allocate output images (must have same depth, channels as input)
 
    outputImg_arm = cvCreateImage(cvSize(inputImg->width, inputImg->height), inputImg->depth, inputImg->nChannels);
 
    outputImg_dsp = cvCreateImage(cvSize(inputImg->width, inputImg->height), inputImg->depth, inputImg->nChannels);
 
    copyImg_arm = cvCreateImage(cvSize(inputImg->width, inputImg->height), inputImg->depth, inputImg->nChannels);
 
    copyImg_dsp = cvCreateImage(cvSize(inputImg->width, inputImg->height), inputImg->depth, inputImg->nChannels);
 
    
 
    // 3.a Apply ARM algorithm
 
    cvFlip(inputImg, outputImg_arm, -1); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvFlip(inputImg, outputImg_arm, -1);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM Flip function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 3.b Apply DSP algorithm
 
    C6accel_cvFlip(hC6accel, inputImg, outputImg_dsp, -1); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvFlip(hC6accel, inputImg, outputImg_dsp, -1);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP Flip function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 4.a Copy image on ARM
 
    cvCopy(outputImg_arm, copyImg_arm, NULL); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvCopy(outputImg_arm, copyImg_arm, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM Copy function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 4.b Copy image on DSP
 
    C6accel_cvCopy(hC6accel, outputImg_dsp, copyImg_dsp, NULL); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvCopy(hC6accel, outputImg_dsp, copyImg_dsp, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP Copy function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 5. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(copyImg_arm, copyImg_dsp, CV_L2, NULL));
 
    
 
    // 6. Save outputs to filesystem
 
    cvSaveImage("./output_arm.png", copyImg_arm, 0);
 
    cvSaveImage("./output_dsp.png", copyImg_dsp, 0);
 
 
 
    //OpenCV way of Freeing memory
 
      cvReleaseImage(&outputImg_arm);
 
      cvReleaseImage(&outputImg_dsp);
 
      cvReleaseImage(©Img_arm);
 
      cvReleaseImage(©Img_dsp);
 
      cvReleaseImage(&inputImg);
 
    
 
    printf("C6accel_cvFlip test completed successfully; outputs saved to filesystem\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvCircle(C6accel_Handle hC6accel, char *input_file_name, int n)
 
{
 
    IplImage *armImg, *dspImg;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, radius, i;
 
    CvScalar orange = { 0, 128, 255, 255 }, blue = {255, 0, 0, 255}; // BGRA
 
    CvPoint center, pt1, pt2;
 
    float t_avg;
 
    
 
    printf("cvCircle Test (%s, %i iterations)\n", input_file_name, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input image from file
 
    armImg = cvLoadImage( input_file_name, CV_LOAD_IMAGE_COLOR);
 
    dspImg = cvLoadImage( input_file_name, CV_LOAD_IMAGE_COLOR);
 
    
 
    // 2. Compute circle and rectangle parameters (center, radius, pt1, pt2)
 
    center.x = armImg->width / 2;
 
    center.y = armImg->height / 2;
 
    radius = (center.x >= center.y) ? center.y : center.x;
 
    pt1.x = pt1.y = 0;
 
    pt2.x = center.x;
 
    pt2.y = armImg->height;
 
    
 
    // 3.a Zero out ARM image
 
    cvSetZero(armImg); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvSetZero(armImg);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM SetZero function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 3.b Zero out DSP image
 
    C6accel_cvSetZero(hC6accel, dspImg); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvSetZero(hC6accel, dspImg);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP SetZero function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 4.a Draw rectangle on ARM image
 
    cvRectangle(armImg, pt1, pt2, blue, 1, 8, 0); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvRectangle(armImg, pt1, pt2, blue, -1, 8, 0);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM Rectangle function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 4.b Draw rectangle on DSP image
 
    C6accel_cvRectangle(hC6accel, dspImg, pt1, pt2, blue, 1, 8, 0); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvRectangle(hC6accel, dspImg, pt1, pt2, blue, -1, 8, 0);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP Rectangle function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 5.a Draw circle on ARM image
 
    cvCircle(armImg, center, radius, orange, 1, 8, 0); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvCircle(armImg, center, radius, orange, -1, 8, 0);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM Circle function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 5.b Draw circle on DSP image
 
    C6accel_cvCircle(hC6accel, dspImg, center, radius, orange, 1, 8, 0); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvCircle(hC6accel, dspImg, center, radius, orange, -1, 8, 0);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP Circle function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 6. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(armImg, dspImg, CV_L2, NULL));
 
    
 
    // 7. Save outputs to filesystem
 
    cvSaveImage("./output_arm.png", armImg, 0);
 
    cvSaveImage("./output_dsp.png", dspImg, 0);
 
    
 
    // Free memory
 
    cvReleaseImage(&armImg);
 
    cvReleaseImage(&dspImg);
 
    
 
    printf("C6accel_cvCircle test completed successfully; outputs saved to filesystem\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvResize(C6accel_Handle hC6accel, char *input_file_name, int n)
 
{
 
    IplImage *inputImg, *colorImg_arm, *colorImg_dsp, *resizeImg_arm, *resizeImg_dsp;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    float t_avg;
 
    
 
    printf("cvResize Test (%s, %i iterations)\n", input_file_name, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input image from file
 
    inputImg = cvLoadImage( input_file_name, CV_LOAD_IMAGE_COLOR);
 
    
 
    // 2. Allocate recolor images (must same depth, channels, size as input)
 
    //    and resize images (must have same depth, channels, as input with half size)
 
    colorImg_arm = cvCreateImage(cvSize(inputImg->width, inputImg->height), inputImg->depth, inputImg->nChannels);
 
    colorImg_dsp = cvCreateImage(cvSize(inputImg->width, inputImg->height), inputImg->depth, inputImg->nChannels);
 
    resizeImg_arm = cvCreateImage(cvSize(inputImg->width / 2, inputImg->height / 2), inputImg->depth, inputImg->nChannels);
 
    resizeImg_dsp = cvCreateImage(cvSize(inputImg->width / 2, inputImg->height / 2), inputImg->depth, inputImg->nChannels);
 
    
 
    // 3.a Apply ARM algorithm
 
    cvCvtColor(inputImg, colorImg_arm, CV_BGR2YCrCb); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvCvtColor(inputImg, colorImg_arm, CV_BGR2YCrCb);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM CvtColor function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 3.b Apply DSP algorithm
 
    C6accel_cvCvtColor(hC6accel, inputImg, colorImg_dsp, CV_BGR2YCrCb); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    //for (i = 0; i < 1000; i++)
 
        C6accel_cvCvtColor(hC6accel, inputImg, colorImg_dsp, CV_BGR2YCrCb);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP CvtColor function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 4.a Resize image on ARM
 
    cvResize(colorImg_arm, resizeImg_arm, CV_INTER_LINEAR); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvResize(colorImg_arm, resizeImg_arm, CV_INTER_LINEAR);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM Resize function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 4.b Resize image on DSP
 
    C6accel_cvResize(hC6accel, colorImg_dsp, resizeImg_dsp, CV_INTER_LINEAR); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvResize(hC6accel, colorImg_dsp, resizeImg_dsp, CV_INTER_LINEAR);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP Resize function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 5. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(resizeImg_arm, resizeImg_dsp, CV_L2, NULL));
 
    
 
    // 6. Save outputs to filesystem
 
    cvSaveImage("./output_arm.png", resizeImg_arm, 0);
 
    cvSaveImage("./output_dsp.png", resizeImg_dsp, 0);
 
 
 
    // Free memory
 
    cvReleaseImage(&resizeImg_arm);
 
    cvReleaseImage(&resizeImg_dsp);
 
    cvReleaseImage(&colorImg_arm);
 
    cvReleaseImage(&colorImg_dsp);
 
    cvReleaseImage(&inputImg);
 
    printf("C6accel_cvResize test completed successfully; outputs saved to filesystem\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvEqualizeHist(C6accel_Handle hC6accel, char *input_file_name, int n)
 
{
 
    IplImage *inputImg, *outputImg_arm, *outputImg_dsp;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    float t_avg;
 
    
 
    printf("cvEqualizeHist Test (%s, %i iterations)\n", input_file_name, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input image from file
 
    inputImg = cvLoadImage( input_file_name, CV_LOAD_IMAGE_GRAYSCALE);
 
    
 
    // 2. Check image depth; require 8-bit
 
    if (inputImg->depth != IPL_DEPTH_8U && inputImg->depth != IPL_DEPTH_8S)
 
    {
 
        printf("C6accel_cvEqualizeHist test failed; input image must have 8-bit depth.\n");
 
        return 0;
 
    }
 
    
 
    // 3. Allocate output images
 
    outputImg_arm = cvCreateImage(cvSize(inputImg->width, inputImg->height), IPL_DEPTH_8U, 1);
 
    outputImg_dsp = cvCreateImage(cvSize(inputImg->width, inputImg->height), IPL_DEPTH_8U, 1);
 
 
 
    // 4.a Apply ARM algorithm
 
    cvEqualizeHist(inputImg, outputImg_arm); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvEqualizeHist(inputImg, outputImg_arm);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM EqualizeHist function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 4.b Apply DSP algorithm
 
    C6accel_cvEqualizeHist(hC6accel, inputImg, outputImg_dsp); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvEqualizeHist(hC6accel, inputImg, outputImg_dsp);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP EqualizeHist function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 6. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
    
 
    // 7. Save outputs to filesystem
 
    cvSaveImage("./output_arm.png", outputImg_arm, 0);
 
    cvSaveImage("./output_dsp.png", outputImg_dsp, 0);
 
 
 
   // Free memory
 
    cvReleaseImage(&outputImg_arm);
 
    cvReleaseImage(&outputImg_dsp);
 
    cvReleaseImage(&inputImg);    
 
    printf("C6accel_cvEqualizeHist test completed successfully; outputs saved to filesystem\n");
 
    return 1;
 
}
 
 
 
   // TEMP: function to traverse classifier cascade
 
    typedef int sumtype;
 
    typedef double sqsumtype;
 
 
 
    typedef struct CvHidHaarFeature
 
    {
 
        struct
 
        {
 
            sumtype *p0, *p1, *p2, *p3;
 
            float weight;
 
        }
 
        rect[CV_HAAR_FEATURE_MAX];
 
    }
 
    CvHidHaarFeature;
 
 
 
 
 
    typedef struct CvHidHaarTreeNode
 
    {
 
        CvHidHaarFeature feature;
 
        float threshold;
 
        int left;
 
        int right;
 
    }
 
    CvHidHaarTreeNode;
 
 
 
 
 
    typedef struct CvHidHaarClassifier
 
    {
 
        int count;
 
        //CvHaarFeature* orig_feature;
 
        CvHidHaarTreeNode* node;
 
        float* alpha;
 
    }
 
    CvHidHaarClassifier;
 
 
 
 
 
    typedef struct CvHidHaarStageClassifier
 
    {
 
        int  count;
 
        float threshold;
 
        CvHidHaarClassifier* classifier;
 
        int two_rects;
 
        
 
        struct CvHidHaarStageClassifier* next;
 
        struct CvHidHaarStageClassifier* child;
 
        struct CvHidHaarStageClassifier* parent;
 
    }
 
    CvHidHaarStageClassifier;
 
 
 
 
 
    struct CvHidHaarClassifierCascade
 
    {
 
        int  count;
 
        int  is_stump_based;
 
        int  has_tilted_features;
 
        int  is_tree;
 
        double inv_window_area;
 
        CvMat sum, sqsum, tilted;
 
        CvHidHaarStageClassifier* stage_classifier;
 
        sqsumtype *pq0, *pq1, *pq2, *pq3;
 
        sumtype *p0, *p1, *p2, *p3;
 
 
 
        void** ipp_stages;
 
    };
 
 
 
    
 
     void traverse_and_translate_hid_cascade(CvHidHaarClassifierCascade *cascade, FILE *fp)
 
    {
 
        CvHidHaarStageClassifier *hid_stage;
 
        CvHidHaarClassifier *hid_classifier;
 
        CvHidHaarTreeNode *hid_node;
 
        int stage_count, classifier_count, feature_count;
 
        int i, j, k, l;
 
    
 
        if (cascade == NULL)
 
        {
 
            fprintf(fp, "//\tHidden cascade pointer is NULL; no traversal required\n");
 
            return;
 
        }
 
        else
 
        {
 
            stage_count = cascade->count;
 
            fprintf(fp, "//\tHidden cascade at 0x%08X has %i stages\n",
 
                   (unsigned int)cascade,
 
                   stage_count);
 
            for (i = 0; i < cascade->count; i++)
 
            {
 
                hid_stage = cascade->stage_classifier + i;
 
                classifier_count = hid_stage->count;
 
                fprintf(fp, "//\t\tHidden stage %i at 0x%08X has %i classifiers\n",
 
                        i, (unsigned int)hid_stage, classifier_count);
 
                for (j = 0; j < classifier_count; j++)
 
                {
 
                    hid_classifier = hid_stage->classifier + j;
 
                    feature_count = hid_classifier->count;
 
                    fprintf(fp, "//\t\t\tHidden classifier %i at 0x%08X has %i nodes/features\n",
 
                            j, (unsigned int)hid_classifier, feature_count);
 
                    for (k = 0; k < feature_count; k++)
 
                    {
 
                        hid_node = hid_classifier->node + k;
 
                        
 
                        // apply CMEM_getPhys to node contents (none)
 
                        
 
                        // apply CMEM_getPhys to feature contents (rect[0].p0, .p1, .p2, .p3, rect[1].p0, etc.)
 
                        for (l = 0; l < CV_HAAR_FEATURE_MAX; l++)
 
                        {
 
                            hid_node->feature.rect[l].p0 = hid_node->feature.rect[l].p0 ?
 
                                (void *)CMEM_getPhys(hid_node->feature.rect[l].p0) : NULL;
 
                            hid_node->feature.rect[l].p1 = hid_node->feature.rect[l].p1 ?
 
                                (void *)CMEM_getPhys(hid_node->feature.rect[l].p1) : NULL;
 
                            hid_node->feature.rect[l].p2 = hid_node->feature.rect[l].p2 ?
 
                                (void *)CMEM_getPhys(hid_node->feature.rect[l].p2) : NULL;
 
                            hid_node->feature.rect[l].p3 = hid_node->feature.rect[l].p3 ?
 
                                (void *)CMEM_getPhys(hid_node->feature.rect[l].p3) : NULL;
 
                            fprintf(fp, "//\t\t\t\tHidden node %i feature rect %i pointers translated to physical addresses (0x%08X, 0x%08X, 0x%08X, 0x%08X)\n",
 
                            k, l, (unsigned int)hid_node->feature.rect[l].p0, (unsigned int)hid_node->feature.rect[l].p1,
 
                            hid_node->feature.rect[l].p2, hid_node->feature.rect[l].p3);
 
                        }
 
                    }
 
                    
 
                    // apply CMEM_getPhys to classifier contents (node, alpha)
 
                    hid_classifier->node  = hid_classifier->node  ? (void *)CMEM_getPhys(hid_classifier->node)  : NULL;
 
                    hid_classifier->alpha = hid_classifier->alpha ? (void *)CMEM_getPhys(hid_classifier->alpha) : NULL;
 
                    fprintf(fp, "//\t\t\tHidden classifier %i pointers translated to physical addresses (0x%08X, 0x%08X)\n",
 
                            j, (unsigned int)hid_classifier->node, (unsigned int)hid_classifier->alpha);
 
                }
 
                
 
                // apply CMEM_getPhys to stage contents (classifier, next, child, parent)
 
                hid_stage->classifier = hid_stage->classifier ? (void *)CMEM_getPhys(hid_stage->classifier) : NULL;
 
                hid_stage->next = hid_stage->next ? (void *)CMEM_getPhys(hid_stage->next) : NULL;
 
                hid_stage->child = hid_stage->child ? (void *)CMEM_getPhys(hid_stage->child) : NULL;
 
                hid_stage->parent = hid_stage->parent ? (void *)CMEM_getPhys(hid_stage->parent) : NULL;
 
                fprintf(fp, "//\t\tHidden stage %i pointers translated to physical addresses (0x%08X, 0x%08X, 0x%08X, 0x%08X)\n",
 
                        i, (unsigned int)hid_stage->classifier, (unsigned int)hid_stage->next,
 
                        (unsigned int)hid_stage->child, (unsigned int)hid_stage->parent);
 
            }
 
            
 
            // apply CMEM_getPhys to hid_cascade contents (stage_classifier, sum.refcount, sum.data.i,
 
            //     sqsum.refcount, sqsum.data.db, tilted.refcount, tilted.data.i, pq0, pq1, pq2, pq3,
 
            //     p0, p1, p2, p3, ipp_stages)
 
            cascade->stage_classifier = cascade->stage_classifier ?
 
                (void *)CMEM_getPhys(cascade->stage_classifier) : NULL;
 
            cascade->sum.refcount = cascade->sum.refcount ?
 
                (void *)CMEM_getPhys(cascade->sum.refcount) : NULL;
 
            cascade->sum.data.i = cascade->sum.data.i ?
 
                (void *)CMEM_getPhys(cascade->sum.data.i) : NULL;
 
            cascade->sqsum.refcount = cascade->sqsum.refcount ?
 
                (void *)CMEM_getPhys(cascade->sqsum.refcount) : NULL;
 
            cascade->sqsum.data.db = cascade->sqsum.data.db ?
 
                (void *)CMEM_getPhys(cascade->sqsum.data.db) : NULL;
 
            cascade->tilted.refcount = cascade->tilted.refcount ?
 
                (void *)CMEM_getPhys(cascade->tilted.refcount) : NULL;
 
            cascade->tilted.data.i = cascade->tilted.data.i ?
 
                (void *)CMEM_getPhys(cascade->tilted.data.i) : NULL;
 
            fprintf(fp, "//\tHidden cascade pointers translated to physical addresses (1 of 4) (0x%08X, 0x%08X, 0x%08X)\n",
 
                    (unsigned int)cascade->stage_classifier, (unsigned int)cascade->sum.refcount,
 
                    (unsigned int)cascade->sum.data.i);
 
            fprintf(fp, "//\tHidden cascade pointers translated to physical addresses (2 of 4) (0x%08X, 0x%08X, 0x%08X, 0x%08X)\n",
 
                    (unsigned int)cascade->sqsum.refcount, (unsigned int)cascade->sqsum.data.db,
 
                    (unsigned int)cascade->tilted.refcount, (unsigned int)cascade->tilted.data.i);
 
            cascade->pq0 = cascade->pq0 ? (void *)CMEM_getPhys(cascade->pq0) : NULL;
 
            cascade->pq1 = cascade->pq1 ? (void *)CMEM_getPhys(cascade->pq1) : NULL;
 
            cascade->pq2 = cascade->pq2 ? (void *)CMEM_getPhys(cascade->pq2) : NULL;
 
            cascade->pq3 = cascade->pq3 ? (void *)CMEM_getPhys(cascade->pq3) : NULL;
 
            cascade->p0 = cascade->p0 ? (void *)CMEM_getPhys(cascade->p0) : NULL;
 
            cascade->p1 = cascade->p1 ? (void *)CMEM_getPhys(cascade->p1) : NULL;
 
            cascade->p2 = cascade->p2 ? (void *)CMEM_getPhys(cascade->p2) : NULL;
 
            cascade->p3 = cascade->p3 ? (void *)CMEM_getPhys(cascade->p3) : NULL;
 
            fprintf(fp, "//\tHidden cascade pointers translated to physical addresses (3 of 4) (0x%08X, 0x%08X, 0x%08X, 0x%08X)\n",
 
                    (unsigned int)cascade->pq0, (unsigned int)cascade->pq1,
 
                    (unsigned int)cascade->pq2, (unsigned int)cascade->pq3);
 
            fprintf(fp, "//\tHidden cascade pointers translated to physical addresses (4 of 4) (0x%08X, 0x%08X, 0x%08X, 0x%08X)\n",
 
                    (unsigned int)cascade->p0, (unsigned int)cascade->p1,
 
                    (unsigned int)cascade->p2, (unsigned int)cascade->p3);
 
            if (cascade->ipp_stages == NULL)
 
            {
 
                fprintf(fp, "//\tHidden cascade ipp stage array pointer is NULL; sub-array not traversed\n");
 
            }
 
            else
 
            {
 
                for (i = 0; i < cascade->count; i++)
 
                {
 
                    cascade->ipp_stages[i] = cascade->ipp_stages[i] ?
 
                        (void *)CMEM_getPhys(cascade->ipp_stages[i]) : NULL;
 
                    fprintf(fp, "//\tHidden cascade ipp stage %i translated to physical address (0x%08X)\n",
 
                        i, (unsigned int)cascade->ipp_stages[i]);
 
                }
 
            }
 
            
 
            cascade->ipp_stages = cascade->ipp_stages ?
 
                (void *)CMEM_getPhys(cascade->ipp_stages) : NULL;
 
            fprintf(fp, "//\tHidden cascade ipp stage array pointer translated to physical address (0x%08X)\n",
 
                (unsigned int)cascade->ipp_stages);
 
        }
 
    }
 
 
 
 void LOCAL_restore_hid_cascade(CvHidHaarClassifierCascade *cascade)
 
    {
 
        CvHidHaarStageClassifier *hid_stage;
 
        CvHidHaarClassifier *hid_classifier;
 
        CvHidHaarTreeNode *hid_node;
 
        int stage_count, classifier_count, feature_count;
 
        int i, j, k, l;
 
    
 
        if (cascade == NULL)
 
        {
 
           return;
 
        }
 
        else
 
        {
 
            stage_count = cascade->count;
 
            // apply Memory_getBufferVirtualAddress to hid_cascade contents (stage_classifier, sum.refcount, sum.data.i,
 
            //     sqsum.refcount, sqsum.data.db, tilted.refcount, tilted.data.i, pq0, pq1, pq2, pq3,
 
            //     p0, p1, p2, p3, ipp_stages)
 
            cascade->stage_classifier = cascade->stage_classifier ?
 
                (void *)Memory_getBufferVirtualAddress((int)cascade->stage_classifier,sizeof(CvHidHaarStageClassifier)) : NULL;
 
            cascade->sum.refcount = cascade->sum.refcount ?
 
                (void *)Memory_getBufferVirtualAddress((int)cascade->sum.refcount,sizeof(int)) : NULL;
 
            cascade->sum.data.i = cascade->sum.data.i ?
 
                (void *)Memory_getBufferVirtualAddress((int)cascade->sum.data.i,sizeof(int)) : NULL;
 
            cascade->sqsum.refcount = cascade->sqsum.refcount ?
 
                (void *)Memory_getBufferVirtualAddress((int)cascade->sqsum.refcount,sizeof(int)) : NULL;
 
            cascade->sqsum.data.db = cascade->sqsum.data.db ?
 
                (void *)Memory_getBufferVirtualAddress((int)cascade->sqsum.data.db,sizeof(double *)) : NULL;
 
            cascade->tilted.refcount = cascade->tilted.refcount ?
 
                (void *)Memory_getBufferVirtualAddress((int)cascade->tilted.refcount,sizeof(int)) : NULL;
 
            cascade->tilted.data.i = cascade->tilted.data.i ?
 
                (void *)Memory_getBufferVirtualAddress((int)cascade->tilted.data.i,sizeof(int)) : NULL;
 
            cascade->pq0 = cascade->pq0 ? (void *)Memory_getBufferVirtualAddress((int)cascade->pq0,sizeof(sqsumtype)) : NULL;
 
            cascade->pq1 = cascade->pq1 ? (void *)Memory_getBufferVirtualAddress((int)cascade->pq1,sizeof(sqsumtype)) : NULL;
 
            cascade->pq2 = cascade->pq2 ? (void *)Memory_getBufferVirtualAddress((int)cascade->pq2,sizeof(sqsumtype)) : NULL;
 
            cascade->pq3 = cascade->pq3 ? (void *)Memory_getBufferVirtualAddress((int)cascade->pq3,sizeof(sqsumtype)) : NULL;
 
            cascade->p0 = cascade->p0 ? (void *)Memory_getBufferVirtualAddress((int)cascade->p0,sizeof(sumtype)) : NULL;
 
            cascade->p1 = cascade->p1 ? (void *)Memory_getBufferVirtualAddress((int)cascade->p1,sizeof(sumtype)) : NULL;
 
            cascade->p2 = cascade->p2 ? (void *)Memory_getBufferVirtualAddress((int)cascade->p2,sizeof(sumtype)) : NULL;
 
            cascade->p3 = cascade->p3 ? (void *)Memory_getBufferVirtualAddress((int)cascade->p3,sizeof(sumtype)) : NULL;
 
            
 
            for (i = 0; i < cascade->count; i++)
 
            {
 
                hid_stage = cascade->stage_classifier + i;
 
                classifier_count = hid_stage->count;
 
                // apply Memory_getBufferVirtualAddress to stage contents (classifier, next, child, parent)
 
                hid_stage->classifier = hid_stage->classifier ? (void *)Memory_getBufferVirtualAddress((int)hid_stage->classifier,sizeof(CvHidHaarClassifier)) : NULL;
 
                hid_stage->next = hid_stage->next ? (void *)Memory_getBufferVirtualAddress((int)hid_stage->next,sizeof(CvHidHaarStageClassifier)) : NULL;
 
                hid_stage->child = hid_stage->child ? (void *)Memory_getBufferVirtualAddress((int)hid_stage->child,sizeof(CvHidHaarStageClassifier)) : NULL;
 
                hid_stage->parent = hid_stage->parent ? (void *)Memory_getBufferVirtualAddress((int)hid_stage->parent,sizeof(CvHidHaarStageClassifier)) : NULL;
 
                
 
                for (j = 0; j < classifier_count; j++)
 
                {
 
                    hid_classifier = hid_stage->classifier + j;
 
                    feature_count = hid_classifier->count;
 
                    // apply Memory_getBufferVirtualAddress to classifier contents (node, alpha)
 
                    hid_classifier->node  = hid_classifier->node  ? (void *)Memory_getBufferVirtualAddress((int)hid_classifier->node,sizeof(CvHidHaarTreeNode))  : NULL;
 
                    hid_classifier->alpha = hid_classifier->alpha ? (void *)Memory_getBufferVirtualAddress((int)hid_classifier->alpha,sizeof(float)) : NULL;
 
                    
 
                    for (k = 0; k < feature_count; k++)
 
                    {
 
                        hid_node = hid_classifier->node + k;
 
                        
 
                        // apply Memory_getBufferVirtualAddress to node contents (none)
 
                        
 
                        // apply Memory_getBufferVirtualAddress to feature contents (rect[0].p0, .p1, .p2, .p3, rect[1].p0, etc.)
 
                        for (l = 0; l < CV_HAAR_FEATURE_MAX; l++)
 
                        {
 
                            hid_node->feature.rect[l].p0 = hid_node->feature.rect[l].p0 ?
 
                                (void *)Memory_getBufferVirtualAddress((int)hid_node->feature.rect[l].p0,sizeof(sumtype)) : NULL;
 
                            hid_node->feature.rect[l].p1 = hid_node->feature.rect[l].p1 ?
 
                                (void *)Memory_getBufferVirtualAddress((int)hid_node->feature.rect[l].p1,sizeof(sumtype)) : NULL;
 
                            hid_node->feature.rect[l].p2 = hid_node->feature.rect[l].p2 ?
 
                                (void *)Memory_getBufferVirtualAddress((int)hid_node->feature.rect[l].p2,sizeof(sumtype)) : NULL;
 
                            hid_node->feature.rect[l].p3 = hid_node->feature.rect[l].p3 ?
 
                                (void *)Memory_getBufferVirtualAddress((int)hid_node->feature.rect[l].p3,sizeof(sumtype)) : NULL;
 
                           
 
                        }
 
                    }
 
                    
 
                    
 
                }
 
                
 
                
 
            }
 
                      
 
            if (cascade->ipp_stages == NULL)
 
            {
 
                printf( "//\tHidden cascade ipp stage array pointer is NULL; sub-array not traversed\n");
 
            }
 
            else
 
            {
 
                for (i = 0; i < cascade->count; i++)
 
                {
 
                    cascade->ipp_stages[i] = cascade->ipp_stages[i] ?
 
                       (void *)Memory_getBufferVirtualAddress((int)cascade->ipp_stages[i],sizeof(void *)) : NULL;
 
                }
 
            }
 
            
 
            cascade->ipp_stages = cascade->ipp_stages ?
 
                (void *)Memory_getBufferVirtualAddress((int)cascade->ipp_stages,sizeof(void *)) : NULL;
 
           }
 
    }
 
 
 
    
 
       void traverse_and_translate_cascade(CvHaarClassifierCascade *cascade )
 
    {
 
        CvHaarStageClassifier *stage;
 
        CvHaarClassifier *classifier;
 
        CvHaarFeature *feature;
 
        int stage_count, classifier_count, feature_count;
 
        unsigned int new_thresh, new_left, new_right, new_alpha;
 
        int i, j, k;
 
        
 
        FILE *fp = fopen("dsp_cascade_traversal_log.txt", "w+");
 
        
 
        stage_count = cascade->count;
 
        fprintf(fp, "Cascade at 0x%08X has %i stages\n",
 
               (unsigned int)cascade,
 
               stage_count);
 
        for (i = 0; i < stage_count; i++)
 
        {
 
            stage = cascade->stage_classifier + i;
 
            classifier_count = stage->count;
 
            fprintf(fp, "\tStage %i at 0x%08X has %i classifiers\n", i, (unsigned int)stage, classifier_count);
 
            for (j = 0; j < classifier_count; j++)
 
            {
 
                classifier = stage->classifier + j;
 
                feature_count = classifier->count;
 
                fprintf(fp, "\t\tClassifier %i at 0x%08X has %i features\n", j, (unsigned int)classifier, feature_count);
 
                for (k = 0; k < feature_count; k++)
 
                {
 
                    feature = classifier->haar_feature + k;
 
                    fprintf(fp, "\t\t\tFeature %i at 0x%08X rect array that begins at 0x%08X\n", k,
 
                            (unsigned int)feature, (unsigned int)feature->rect);
 
                    
 
                    // apply CMEM_getPhys to feature contents (rect)
 
                    // NOT NECESSARY (array pointer doesn't actually exist; feature->rect == (char *)feature + 4
 
                    //feature->rect = (unsigned int)CMEM_getPhys(feature->rect);
 
                    //fprintf(fp, "0x%08X\n", (unsigned int)feature->rect);
 
                }
 
                
 
                // apply CMEM_getPhys to classifier contents (haar_feature, threshold, left, right, alpha)
 
                
 
                classifier->haar_feature = classifier->haar_feature ? (void *)Memory_getBufferPhysicalAddress(classifier->haar_feature, sizeof(CvHaarFeature),NULL) : NULL;
 
                classifier->threshold = classifier->threshold ? (void *)Memory_getBufferPhysicalAddress(classifier->threshold,sizeof(float),NULL) : NULL;
 
                classifier->left = classifier->left ? (void *)Memory_getBufferPhysicalAddress(classifier->left,sizeof(int),NULL) : NULL;
 
                classifier->right = classifier->right ? (void *)Memory_getBufferPhysicalAddress(classifier->right,sizeof(int),NULL) : NULL;
 
                classifier->alpha = classifier->alpha ? (void *)Memory_getBufferPhysicalAddress(classifier->alpha,sizeof(float),NULL) : NULL;
 
                fprintf(fp, "\t\tClassifier %i pointers translated to physical addresses (0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X)\n",
 
                        j, (unsigned int)classifier->haar_feature, (unsigned int)classifier->threshold,
 
                        (unsigned int)classifier->left, (unsigned int)classifier->right,
 
                        (unsigned int)classifier->alpha);
 
                Memory_cacheWbInv( (void *)classifier, sizeof(CvHaarClassifier));
 
           //     Cache_wait();
 
              }
 
            
 
            // apply CMEM_getPhys to stage contents (classifier)
 
            fprintf(fp, "\tBefore translation :Stage %i pointers translated to physical addresses (0x%08X)\n", i, (unsigned int)stage->classifier);
 
            stage->classifier = stage->classifier ? (void *)Memory_getBufferPhysicalAddress(stage->classifier,sizeof(CvHaarClassifier),NULL) : NULL;
 
            Memory_cacheWbInv( (void *)stage,sizeof(CvHaarStageClassifier));
 
 
 
            fprintf(fp, "\tStage %i pointers translated to physical addresses (0x%08X)\n", i, (unsigned int)stage->classifier);
 
        }
 
        
 
        // traverse "hidden" cascade, too
 
        traverse_and_translate_hid_cascade(cascade->hid_cascade, fp);
 
                
 
        // apply CMEM_getPhys to cascade contents (stage_classifier, hid_cascade)
 
       // cascade->stage_classifier->classifier = cascade->stage_classifier->classifier ? (void *)CMEM_getPhys(cascade->stage_classifier->classifier) : NULL;
 
        cascade->stage_classifier = cascade->stage_classifier ? (void *)Memory_getBufferPhysicalAddress(cascade->stage_classifier,sizeof(CvHaarStageClassifier),NULL) : NULL;
 
        cascade->hid_cascade = cascade->hid_cascade ? (void *)Memory_getBufferPhysicalAddress(cascade->hid_cascade,sizeof(CvHidHaarClassifierCascade),NULL) : NULL;
 
         
 
	 fprintf(fp, "Cascade pointers translated to physical addresses (0x%08X, 0x%08X)\n", (unsigned int)cascade->stage_classifier,
 
                (unsigned int)cascade->hid_cascade);
 
 
 
        Memory_cacheWbInvAll();
 
	 //Cache_wait();
 
        fclose(fp);
 
    }
 
 
 
 
 
void LOCAL_restore_cascade(CvHaarClassifierCascade *cascade)
 
    {
 
        CvHaarStageClassifier *stage;
 
        CvHaarClassifier *classifier;
 
        CvHaarFeature *feature;
 
        int stage_count, classifier_count, feature_count;
 
        unsigned int new_thresh, new_left, new_right, new_alpha;
 
        int i, j, k;
 
       
 
        stage_count = cascade->count;
 
       // printf("Stage_classifier %x\n",(int)cascade->stage_classifier);
 
        cascade->stage_classifier = (void *)Memory_getBufferVirtualAddress(((int)cascade->stage_classifier),sizeof(CvHaarStageClassifier)+sizeof(int));
 
       // printf("Stage_classifier %x\n",(int)cascade->stage_classifier);
 
        cascade->hid_cascade =  cascade->hid_cascade ? (void *)Memory_getBufferVirtualAddress((int)cascade->hid_cascade,sizeof(CvHidHaarClassifierCascade)): NULL;
 
              
 
	for (i = 0; i < stage_count; i++)
 
        {
 
       //     printf("In stage loop\n");
 
            stage = cascade->stage_classifier + i;
 
        //    printf("stage %x\n",(int)stage );
 
            classifier_count = stage->count;
 
             // apply CMEM_getPhys to stage contents (classifier)
 
            stage->classifier = (void *)Memory_getBufferVirtualAddress((int)stage->classifier,sizeof(CvHaarClassifier));
 
            
 
            for (j = 0; j < classifier_count; j++)
 
            {
 
          //     printf("In classifier loop\n");
 
                classifier = stage->classifier + j;
 
          //     printf(" classifier %x\n", classifier);
 
                feature_count = classifier->count;
 
                
 
                // apply CMEM_getPhys to classifier contents (haar_feature, threshold, left, right, alpha)
 
                classifier->haar_feature = (void *)Memory_getBufferVirtualAddress((int)(classifier->haar_feature),sizeof(CvHaarFeature));
 
                classifier->threshold =  (void *)Memory_getBufferVirtualAddress((int)classifier->threshold,sizeof(float)) ;
 
                classifier->left = (void *)Memory_getBufferVirtualAddress((int)classifier->left,sizeof(int));
 
                classifier->right =  (void *)Memory_getBufferVirtualAddress((int)classifier->right,sizeof(int));
 
                classifier->alpha =  (void *)Memory_getBufferVirtualAddress((int)classifier->alpha,sizeof(float));
 
               // Memory_cacheWbInv( (void *)classifier, sizeof(CvHaarClassifier));
 
                for (k = 0; k < feature_count; k++)
 
                {
 
            //        printf("In Feature loop\n");
 
                    feature = classifier->haar_feature + k;
 
                          
 
                    // apply CMEM_getPhys to feature contents (rect)
 
                    // NOT NECESSARY (array pointer doesn't actually exist; feature->rect == (char *)feature + 4
 
                    //feature->rect = (unsigned int)CMEM_getPhys(feature->rect);
 
                    //fprintf(fp, "0x%08X\n", (unsigned int)feature->rect);
 
                }
 
                
 
            }
 
            
 
           
 
        }
 
        LOCAL_restore_hid_cascade(cascade->hid_cascade);     
 
    }
 
 
 
Int c6accel_test_cvHaarDetectObjects(C6accel_Handle hC6accel, char *image_file_name, char *cascade_file_name)
 
{
 
    IplImage *image, *image_color;
 
    CvSeq *arm_sequence = NULL, *dsp_sequence = NULL;
 
    CvHaarClassifierCascade *cascade;
 
    CvMemStorage *storage;
 
    CvRect *r;
 
    CvPoint c1, c2;
 
    CvScalar red = {0, 0, 255, 255}, black = {0, 0, 0, 255};
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    void *temp_ptr;
 
    
 
    printf("cvHaarDetectObjects Test (%s, %s)\n", image_file_name, cascade_file_name);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    printf("Memory for images,cascade and \n");
 
    // 1. Read input image and cascade files
 
    image       = cvLoadImage(image_file_name, CV_LOAD_IMAGE_GRAYSCALE);
 
    image_color = cvLoadImage(image_file_name, CV_LOAD_IMAGE_COLOR);
 
       
 
    // 2. Create memory storage space; use dummy allocation to prime for DSP
 
    storage = cvCreateMemStorage(0);
 
    printf("Memory allocation for images and storage done\n");
 
    cascade     = (CvHaarClassifierCascade *)cvLoad(cascade_file_name, 0, 0, 0);
 
    printf("Reading of Cascade complete\n");
 
    // 3.a Apply ARM algorithm
 
    arm_sequence = cvHaarDetectObjects(image_color, cascade, storage, 1.1, 2, CV_HAAR_DO_CANNY_PRUNING, cvSize(30, 30));
 
    gettimeofday(&startTime, NULL);
 
    printf("top= %x\n", storage->top);
 
    printf("bottom= %x\n", storage->bottom);
 
    for (i = 0; i < 1; i++)
 
        arm_sequence = cvHaarDetectObjects(image_color, cascade, storage, 1.1, 2, CV_HAAR_DO_CANNY_PRUNING, cvSize(30, 30));
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called ARM HaarDetectObjects function (time: %f ms)\n", t_algo / 1000.0 / 1.0);
 
    // 4.a Mark and print list of matches detected by ARM
 
    if (arm_sequence == NULL)
 
    {
 
        printf("ARM sequence returned NULL\n");
 
    }
 
    else
 
    {
 
        printf("ARM sequence contains %i elements:\n", arm_sequence->total);
 
        for (i = 0; i < arm_sequence->total; i++){
 
            r = (CvRect *)cvGetSeqElem(arm_sequence, i);
 
            printf("%4i: %4i, %4i (%ix%i)\n", i, r->x, r->y, r->width, r->height);
 
            
 
            // mark with thick black rectangle
 
            c1.x = r->x;
 
            c1.y = r->y;
 
            c2.x = r->x + r->width;
 
            c2.y = r->y + r->height;
 
            cvRectangle(image_color, c1, c2, black, 2, 8, 0);
 
        }
 
    }
 
    cvReleaseHaarClassifierCascade(&cascade);
 
    cvReleaseMemStorage(&storage);
 
 
 
 
 
    // 3.b Apply DSP algorithm
 
    storage = cvCreateMemStorage(0);
 
    temp_ptr = cvMemStorageAlloc(storage, 64);
 
    printf("Memory allocation for images and storage done\n");
 
    cascade     = (CvHaarClassifierCascade *)cvLoad(cascade_file_name, 0, 0, 0);
 
    traverse_and_translate_cascade(cascade);
 
 
 
    gettimeofday(&startTime, NULL);
 
    C6accel_cvHaarDetectObjects(hC6accel, image_color, cascade, storage, 1.1, 2, CV_HAAR_DO_CANNY_PRUNING, cvSize(30, 30), &dsp_sequence);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    
 
    printf("Called DSP HaarDetectObjects function (time: %f ms)\n", t_algo / 1000.0);
 
        
 
    // 4.b Mark and print list of matches detected by DSP
 
    if (dsp_sequence == NULL)
 
    {
 
        printf("DSP sequence returned NULL\n");
 
    }
 
    else
 
    {
 
        printf("DSP sequence contains %i elements:\n", dsp_sequence->total);
 
        for (i = 0; i < dsp_sequence->total; i++)
 
        {
 
            r = (CvRect *)cvGetSeqElem(dsp_sequence, i);
 
            printf("%4i: %4i, %4i (%ix%i)\n", i, r->x, r->y, r->width, r->height);
 
            
 
            // mark with thin red rectangle
 
            c1.x = r->x;
 
            c1.y = r->y;
 
            c2.x = r->x + r->width;
 
            c2.y = r->y + r->height;
 
            cvRectangle(image_color, c1, c2, red, 1, 8, 0);
 
        }
 
    }
 
    
 
    // 7. Save marked image to filesystem
 
    cvSaveImage("./output.png", image_color, 0);
 
    cvReleaseImage(&image);
 
    cvReleaseImage(&image_color);
 
 
 
    
 
    LOCAL_restore_cascade(cascade);
 
    cvReleaseHaarClassifierCascade(&cascade);
 
    cvReleaseMemStorage(&storage);
 
    printf("C6accel_cvHaarDetectObjects test completed successfully\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_Cascade(char *cascade_file_name)
 
{
 
    
 
    CvHaarClassifierCascade *cascade;
 
    
 
    printf("Reading Cascade\n");
 
    cascade     = (CvHaarClassifierCascade *)cvLoad("opencv_images/haarcascade_frontalface_alt2.xml", 0, 0, 0);
 
    printf("Reading of Cascade complete\n");
 
    
 
    traverse_and_translate_cascade(cascade);
 
    printf("Traverse and translate complete\n");
 
    printf("count: %x\n", cascade->count);
 
    LOCAL_restore_cascade(cascade);
 
      
 
    cvReleaseHaarClassifierCascade(&cascade);
 
 
 
    printf("C6accel_Cascade test completed successfully\n");
 
    return 1;
 
}
 
 
 
 
 
Int c6accel_test_cvGoodFeaturesToTrack(C6accel_Handle hC6accel, char *input_file_name, int n)
 
{
 
    IplImage *input_image, *output_image, *eig_image, *temp_image;
 
    CvPoint2D32f *arm_corners, *dsp_corners, *arm_corners_rough, *dsp_corners_rough;
 
    int arm_cornerCount = 256, dsp_cornerCount = 256;
 
    CvScalar red = {0, 0, 255, 255}, black = {0, 0, 0, 255};
 
    CvPoint c1, c2;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    
 
    printf("cvGoodFeaturesToTrack Test (%s, %i)\n", input_file_name, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input image and create working images
 
    input_image  = cvLoadImage(input_file_name, CV_LOAD_IMAGE_GRAYSCALE);
 
   
 
 
 
    output_image = cvLoadImage(input_file_name, CV_LOAD_IMAGE_COLOR);
 
    eig_image    = cvCreateImage(cvGetSize(input_image), 32, 1);
 
    temp_image   = cvCreateImage(cvGetSize(input_image), 32, 1);
 
    
 
    // 2. Allocate output buffers
 
    arm_corners = (CvPoint2D32f *)cvAlloc(256 * sizeof(CvPoint2D32f));
 
    dsp_corners = (CvPoint2D32f *)cvAlloc(256 * sizeof(CvPoint2D32f));
 
    arm_corners_rough = (CvPoint2D32f *)cvAlloc(256 * sizeof(CvPoint2D32f));
 
    dsp_corners_rough = (CvPoint2D32f *)cvAlloc(256 * sizeof(CvPoint2D32f));
 
    
 
    // 3.a Apply ARM algorithm to find features
 
    cvGoodFeaturesToTrack(input_image, eig_image, temp_image, arm_corners, &arm_cornerCount, 0.01, 10.0, NULL, 3, 0, 0.04);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvGoodFeaturesToTrack(input_image, eig_image, temp_image, arm_corners, &arm_cornerCount, 0.01, 10.0, NULL, 3, 0, 0.04);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called ARM GoodFeaturesToTrack function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 3.b Apply DSP algorithm to find features
 
    C6accel_cvGoodFeaturesToTrack(hC6accel, input_image, eig_image, temp_image, dsp_corners,
 
                                  &dsp_cornerCount, 0.01, 10.0, NULL, 3, 0, 0.04);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvGoodFeaturesToTrack(hC6accel, input_image, eig_image, temp_image, dsp_corners,
 
                                      &dsp_cornerCount, 0.01, 10.0, NULL, 3, 0, 0.04);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called DSP GoodFeaturesToTrack function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 4. Save rough corner locations so we can accurately benchmark the refinement functions
 
    memcpy(arm_corners_rough, arm_corners, arm_cornerCount * sizeof(CvPoint2D32f));
 
    memcpy(dsp_corners_rough, dsp_corners, dsp_cornerCount * sizeof(CvPoint2D32f));
 
    // printf("I finished memcpy\n");
 
    // 4.a Apply ARM algorithm to refine features
 
 
 
    //cvFindCorner SubPix issue to be resolved
 
    cvFindCornerSubPix(input_image, dsp_corners, dsp_cornerCount, cvSize(10, 10), cvSize(-1, -1),
 
                                   cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03));
 
    t_algo = 0;
 
    for (i = 0; i < n; i++)
 
    {
 
        memcpy(arm_corners, arm_corners_rough, arm_cornerCount * sizeof(CvPoint2D32f));
 
        printf("ARM Benchmark begin \n");
 
        gettimeofday(&startTime, NULL);
 
        cvFindCornerSubPix(input_image, arm_corners, arm_cornerCount, cvSize(10, 10), cvSize(-1, -1),
 
                           cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03));
 
        gettimeofday(&endTime, NULL);
 
        t_algo += (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    }
 
    printf("Called ARM FindCornerSubPix function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 4.b Apply DSP algorithm to refine features
 
    C6accel_cvFindCornerSubPix(hC6accel, input_image, dsp_corners, dsp_cornerCount, cvSize(10, 10), cvSize(-1, -1),
 
                               cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03));
 
    t_algo = 0;
 
    for (i = 0; i < n; i++)
 
    {
 
        memcpy(dsp_corners, dsp_corners_rough, dsp_cornerCount * sizeof(CvPoint2D32f));
 
        //printf("DSP Benchmark begin \n");
 
        gettimeofday(&startTime, NULL);
 
        C6accel_cvFindCornerSubPix(hC6accel, input_image, dsp_corners, dsp_cornerCount, cvSize(10, 10), cvSize(-1, -1),
 
                                   cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03));
 
        gettimeofday(&endTime, NULL);
 
        t_algo += (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    }
 
    printf("Called DSP FindCornerSubPix function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 5.a Mark features detected by ARM and report number of elements
 
   /* printf("ARM list contains %i features.\n", arm_cornerCount);
    for (i = 0; i < arm_cornerCount; i++)
    {
        //printf("%3i: (%10f,%10f) -> (%10f,%10f)\n", i, 
        //       arm_corners_rough[i].x, arm_corners_rough[i].y,
        //       arm_corners[i].x, arm_corners[i].y);
        // mark with large black square
        c1.x = cvRound(arm_corners[i].x) - 2;
        c1.y = cvRound(arm_corners[i].y) - 2;
        c2.x = cvRound(arm_corners[i].x) + 2;
        c2.y = cvRound(arm_corners[i].y) + 2;
        cvRectangle(output_image, c1, c2, black, -1, 8, 0);
    }*/
 
 
 
    // 5.b Mark and print list of matches detected by DSP
 
    printf("DSP list contains %i features.\n", dsp_cornerCount);
 
    for (i = 0; i < dsp_cornerCount; i++)
 
    {
 
        //printf("%3i: (%10f,%10f) -> (%10f,%10f)\n", i, 
 
        //       dsp_corners_rough[i].x, dsp_corners_rough[i].y,
 
        //       dsp_corners[i].x, dsp_corners[i].y);
 
        // mark with small red square
 
        c1.x = cvRound(dsp_corners[i].x) - 1;
 
        c1.y = cvRound(dsp_corners[i].y) - 1;
 
        c2.x = cvRound(dsp_corners[i].x) + 1;
 
        c2.y = cvRound(dsp_corners[i].y) + 1;
 
        cvRectangle(output_image, c1, c2, red, -1, 8, 0);
 
    }
 
    
 
    // 5. Save marked image to filesystem
 
    cvSaveImage("./output.png", output_image, 0);
 
    printf("Saved image\n");
 
    //6. Free memory allocated for the images
 
    cvReleaseImage(&output_image);
 
    cvReleaseImage(&eig_image);
 
    cvReleaseImage(&input_image);
 
    cvReleaseImage(&temp_image);
 
 
 
    cvFree(&arm_corners);
 
    cvFree(&dsp_corners);
 
    printf("dsp_corners free\n");
 
 
 
 
 
    printf("dsp_corner_phys: %x\n",CMEM_getPhys(dsp_corners_rough));
 
    cvFree(&dsp_corners_rough);
 
	
 
    cvFree(&arm_corners_rough);
 
    
 
    printf("C6accel_cvGoodFeaturesToTrack test completed successfully\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvCalcOpticalFlowPyrLK(C6accel_Handle hC6accel, char *input_file_name_1, char *input_file_name_2, int n)
 
{
 
    IplImage *prev_input_image, *curr_input_image, *eig_image, *temp_image,
 
             *prev_pyramid, *curr_pyramid,
 
             *output_image;
 
    CvPoint2D32f *prev_corners, *arm_curr_corners, *dsp_curr_corners;
 
    char *arm_status, *dsp_status;
 
    int arm_cornerCount = 1024, dsp_cornerCount = 1024;
 
    CvScalar red = {0, 0, 255, 255}, black = {0, 0, 0, 255};
 
    CvPoint c1, c2;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    
 
    printf("cvCalcOpticalFlowPyrLK Test (%s -> %s, %i)\n", input_file_name_1, input_file_name_2, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input image and create working images
 
    prev_input_image = cvLoadImage(input_file_name_1, CV_LOAD_IMAGE_GRAYSCALE);
 
    curr_input_image = cvLoadImage(input_file_name_2, CV_LOAD_IMAGE_GRAYSCALE);
 
    output_image     = cvLoadImage(input_file_name_2, CV_LOAD_IMAGE_COLOR);
 
    
 
    eig_image        = cvCreateImage(cvGetSize(prev_input_image), 32, 1);
 
    temp_image       = cvCreateImage(cvGetSize(prev_input_image), 32, 1);
 
    prev_pyramid     = cvCreateImage(cvGetSize(prev_input_image), 8, 1);
 
    curr_pyramid     = cvCreateImage(cvGetSize(prev_input_image), 8, 1);
 
   
 
    // 2. Allocate output buffers
 
    prev_corners     = (CvPoint2D32f *)cvAlloc(arm_cornerCount * sizeof(CvPoint2D32f));
 
    arm_curr_corners = (CvPoint2D32f *)cvAlloc(arm_cornerCount * sizeof(CvPoint2D32f));
 
    dsp_curr_corners = (CvPoint2D32f *)cvAlloc(dsp_cornerCount * sizeof(CvPoint2D32f));
 
    arm_status  = (char *)cvAlloc(arm_cornerCount * sizeof(char));
 
    dsp_status  = (char *)cvAlloc(dsp_cornerCount * sizeof(char));
 
    
 
    // 3. Apply ARM algorithm to find features
 
    cvGoodFeaturesToTrack(prev_input_image, eig_image, temp_image, prev_corners, &arm_cornerCount, 0.01, 10.0, NULL, 3, 0, 0.04);
 
    dsp_cornerCount = arm_cornerCount;
 
    
 
    // 4.a Apply ARM algorithm to refine features
 
    cvCalcOpticalFlowPyrLK(prev_input_image, curr_input_image, prev_pyramid, curr_pyramid,
 
                           prev_corners, arm_curr_corners, arm_cornerCount, cvSize(10, 10), 3,
 
                           arm_status, NULL, cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03), 0);
 
    gettimeofday(&startTime, NULL);
 
    
 
    for (i = 0; i < n; i++)
 
    {
 
        cvCalcOpticalFlowPyrLK(prev_input_image, curr_input_image, prev_pyramid, curr_pyramid,
 
                               prev_corners, arm_curr_corners, arm_cornerCount, cvSize(10, 10), 3,
 
                               arm_status, NULL, cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03), 0);
 
    }
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called ARM cvCalcOpticalFlowPyrLK function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 4.b Apply DSP algorithm to refine features
 
    C6accel_cvCalcOpticalFlowPyrLK(hC6accel, prev_input_image, curr_input_image, prev_pyramid, curr_pyramid,
 
                                   prev_corners, dsp_curr_corners, dsp_cornerCount, cvSize(10, 10), 3,
 
                                   dsp_status, NULL, cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03), 0);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
    {
 
        C6accel_cvCalcOpticalFlowPyrLK(hC6accel, prev_input_image, curr_input_image, prev_pyramid, curr_pyramid,
 
                                       prev_corners, dsp_curr_corners, dsp_cornerCount, cvSize(10, 10), 3,
 
                                       dsp_status, NULL, cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03), 0);
 
    }
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called DSP cvCalcOpticalFlowPyrLK function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 5.a Mark motion detected by ARM and report number of elements
 
    printf("ARM list contains %i features.\n", arm_cornerCount);
 
    for (i = 0; i < arm_cornerCount; i++)
 
    {
 
        //printf("%3i: (%10f,%10f) -> (%10f,%10f)\n", i, 
 
        //       arm_corners_rough[i].x, arm_corners_rough[i].y,
 
        //       arm_corners[i].x, arm_corners[i].y);
 
        // mark with thick black line
 
        c1.x = cvRound(prev_corners[i].x);
 
        c1.y = cvRound(prev_corners[i].y);
 
        c2.x = cvRound(arm_curr_corners[i].x);
 
        c2.y = cvRound(arm_curr_corners[i].y);
 
        cvCircle(
 
                    output_image,
 
                    c1,
 
                    2,
 
                    CVX_GRAY50,
 
                    -1,8,0
 
                );
 
        //cvLine(output_image, c1, c2, black, 2, 8, 0);
 
    }
 
 
 
    // 5.b Mark and print list of matches detected by DSP
 
    printf("DSP list contains %i features.\n", dsp_cornerCount);
 
    for (i = 0; i < dsp_cornerCount; i++)
 
    {
 
        //printf("%3i: (%10f,%10f) -> (%10f,%10f)\n", i, 
 
        //       dsp_corners_rough[i].x, dsp_corners_rough[i].y,
 
        //       dsp_corners[i].x, dsp_corners[i].y);
 
        // mark with thin red line
 
        c1.x = cvRound(prev_corners[i].x);
 
        c1.y = cvRound(prev_corners[i].y);
 
        c2.x = cvRound(dsp_curr_corners[i].x);
 
        c2.y = cvRound(dsp_curr_corners[i].y);
 
        cvLine(output_image, c1, c2, red, 1, 8, 0);
 
    }
 
    
 
    // 5. Save marked image to filesystem
 
    cvSaveImage("./output.png", output_image, 0);
 
    cvReleaseImage(&prev_input_image); 
 
    cvReleaseImage(&curr_input_image);
 
    cvReleaseImage(&output_image);    
 
    
 
    cvReleaseImage(&eig_image);       
 
    cvReleaseImage(&temp_image);      
 
    cvReleaseImage(&prev_pyramid);    
 
    cvReleaseImage(&curr_pyramid);    
 
 
 
 // 2. Allocate output buffers
 
    prev_corners     = cvFree(&prev_corners);
 
    arm_curr_corners = cvFree(&arm_curr_corners);
 
    dsp_curr_corners = cvFree(&dsp_curr_corners);
 
    arm_status  = cvFree(&arm_status);
 
    dsp_status  = cvFree(&dsp_status);
 
    printf("C6accel_cvCalcOpticalFlowPyrLK test completed successfully\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvMatchTemplate(C6accel_Handle hC6accel, char *input_file_name, char *template_file_name, int n)
 
{
 
    IplImage *input_image, *template_image, *arm_output_image, *dsp_output_image,
 
             *arm_scale_image, *dsp_scale_image;
 
    CvSize output_size;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    
 
    printf("cvMatchTemplate Test (%s, %s, %i)\n", input_file_name, template_file_name, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input and template images
 
    input_image    = cvLoadImage(input_file_name, CV_LOAD_IMAGE_GRAYSCALE);
 
    template_image = cvLoadImage(template_file_name, CV_LOAD_IMAGE_GRAYSCALE);
 
    
 
    // 2. Allocate output images
 
    output_size  = cvSize(input_image->width  - template_image->width  + 1,
 
                          input_image->height - template_image->height + 1);
 
    arm_output_image = cvCreateImage(output_size, 32, 1);
 
    arm_scale_image  = cvCreateImage(output_size, 8,  1);
 
    dsp_output_image = cvCreateImage(output_size, 32, 1);
 
    dsp_scale_image  = cvCreateImage(output_size, 8,  1);
 
    
 
    cvSetZero(arm_output_image);
 
    cvSetZero(dsp_output_image);
 
    
 
    // 3.a Apply ARM algorithm to match template
 
    cvMatchTemplate(input_image, template_image, arm_output_image, CV_TM_SQDIFF);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvMatchTemplate(input_image, template_image, arm_output_image, CV_TM_SQDIFF);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called ARM cvMatchTemplate function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 4.b Apply DSP algorithm to refine features
 
    C6accel_cvMatchTemplate(hC6accel, input_image, template_image, dsp_output_image, CV_TM_SQDIFF);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvMatchTemplate(hC6accel, input_image, template_image, dsp_output_image, CV_TM_SQDIFF);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called DSP cvMatchTemplate function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 5. Normalize output images
 
    cvNormalize(arm_output_image, arm_scale_image, 0, 255, CV_MINMAX, NULL);
 
    cvNormalize(dsp_output_image, dsp_scale_image, 0, 255, CV_MINMAX, NULL);
 
    
 
    // 6. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(arm_scale_image, dsp_scale_image, CV_L2, NULL));
 
    
 
    // 7. Save output images to filesystem
 
    cvSaveImage("./output_arm.png", arm_scale_image, 0);
 
    cvSaveImage("./output_dsp.png", dsp_scale_image, 0);
 
 
 
    // 8. Free memory allocated to images
 
    cvReleaseImage(&template_image);
 
    cvReleaseImage(&input_image);
 
    cvReleaseImage(&arm_output_image);
 
    cvReleaseImage(&arm_scale_image);
 
    cvReleaseImage(&dsp_output_image);
 
    cvReleaseImage(&dsp_scale_image);
 
 
 
    printf("C6accel_cvMatchTemplate test completed successfully\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvMulSpectrums(C6accel_Handle hC6accel, char *input_file_name_1, char *input_file_name_2, int n)
 
{
 
    IplImage *input_image_1, *input_image_2, *input_image_1f, *input_image_2f,
 
             *dft_image_1, *dft_image_2,
 
             *arm_mult_image, *dsp_mult_image, *arm_idft_image,
 
             *dsp_idft_image, *arm_norm_image, *dsp_norm_image;
 
    CvSize dft_size;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    
 
    printf("cvMulSpectrums Test (%s, %s, %i)\n", input_file_name_1, input_file_name_2, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input images and check that sizes match
 
    input_image_1 = cvLoadImage(input_file_name_1, CV_LOAD_IMAGE_GRAYSCALE);
 
    input_image_2 = cvLoadImage(input_file_name_2, CV_LOAD_IMAGE_GRAYSCALE);
 
    if ((input_image_1->width  != input_image_2->width)   ||
 
        (input_image_1->height != input_image_2->height))
 
    {
 
        printf("Image size mismatch; cvMulSpectrums Test aborted!\n");
 
        return -1;
 
    }
 
    
 
    // 2. Allocate working and output images (and convert input images to floating point)
 
    dft_size = cvSize(input_image_1->width, input_image_1->height);
 
    input_image_1f = cvCreateImage(dft_size, IPL_DEPTH_32F, 1);
 
    input_image_2f = cvCreateImage(dft_size, IPL_DEPTH_32F, 1);
 
    dft_image_1    = cvCreateImage(dft_size, IPL_DEPTH_32F, 1);
 
    dft_image_2    = cvCreateImage(dft_size, IPL_DEPTH_32F, 1);
 
    arm_mult_image = cvCreateImage(dft_size, IPL_DEPTH_32F, 1);
 
    arm_idft_image = cvCreateImage(dft_size, IPL_DEPTH_32F, 1);
 
    arm_norm_image = cvCreateImage(dft_size, IPL_DEPTH_32F, 1);
 
    dsp_mult_image = cvCreateImage(dft_size, IPL_DEPTH_32F, 1);
 
    dsp_idft_image = cvCreateImage(dft_size, IPL_DEPTH_32F, 1);
 
    dsp_norm_image = cvCreateImage(dft_size, IPL_DEPTH_32F, 1);
 
    cvConvertScale(input_image_1, input_image_1f, 1.0f / 255.0f, 0);
 
    cvConvertScale(input_image_2, input_image_2f, 1.0f / 255.0f, 0);
 
    
 
    // 3. Apply ARM algorithm to calculate DFT for images 1, 2 (don't time)
 
    cvDFT(input_image_1f, dft_image_1, CV_DXT_FORWARD, 0);
 
    cvDFT(input_image_2f, dft_image_2, CV_DXT_FORWARD, 0);
 
    
 
    // 4.a Apply ARM algorithm to multiply spectrums
 
    cvMulSpectrums(dft_image_1, dft_image_2, arm_mult_image, 0);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvMulSpectrums(dft_image_1, dft_image_2, arm_mult_image, 0);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called ARM cvMulSpectrums function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 4.b Apply DSP algorithm to multiply spectrums
 
    C6accel_cvMulSpectrums(hC6accel, dft_image_1, dft_image_2, dsp_mult_image, 0);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvMulSpectrums(hC6accel, dft_image_1, dft_image_2, dsp_mult_image, 0);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called DSP cvMulSpectrums function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 5.a Apply ARM IDFT algorithm
 
    cvDFT(arm_mult_image, arm_idft_image, CV_DXT_INVERSE, 0);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvDFT(arm_mult_image, arm_idft_image, CV_DXT_INVERSE, 0);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called ARM cvDFT function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 5.b Apply DSP IDFT algorithm
 
    C6accel_cvDFT(hC6accel, dsp_mult_image, dsp_idft_image, CV_DXT_INVERSE, 0);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvDFT(hC6accel, dsp_mult_image, dsp_idft_image, CV_DXT_INVERSE, 0);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called DSP cvDFT function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 6.a Apply ARM algorithm to normalize image
 
    cvNormalize(arm_idft_image, arm_norm_image, 0, 255, CV_MINMAX, NULL);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvNormalize(arm_idft_image, arm_norm_image, 0, 255, CV_MINMAX, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called ARM cvNormalize function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 6.b Apply DSP algorithm to normalize image
 
    C6accel_cvNormalize(hC6accel, dsp_idft_image, dsp_norm_image, 0, 255, CV_MINMAX, NULL);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvNormalize(hC6accel, dsp_idft_image, dsp_norm_image, 0, 255, CV_MINMAX, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called DSP cvNormalize function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 7. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(arm_norm_image, dsp_norm_image, CV_L2, NULL));
 
    
 
    // 8. Save output images to filesystem
 
    cvSaveImage("./output_arm.png", arm_norm_image, 0);
 
    cvSaveImage("./output_dsp.png", dsp_norm_image, 0);
 
    
 
    //9. Free memory allocated to the images
 
     cvReleaseImage(&input_image_1);
 
     cvReleaseImage(&input_image_2);
 
     cvReleaseImage(&dft_image_1);
 
     cvReleaseImage(&dft_image_2);
 
     cvReleaseImage(&input_image_1f);  
 
     cvReleaseImage(&input_image_2f);
 
     cvReleaseImage(&arm_mult_image);
 
     cvReleaseImage(&arm_idft_image);
 
     cvReleaseImage(&arm_norm_image);
 
     cvReleaseImage(&dsp_mult_image);
 
     cvReleaseImage(&dsp_idft_image);
 
     cvReleaseImage(&dsp_norm_image);
 
    printf("C6accel_cvMulSpectrums test completed successfully\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvNorm(C6accel_Handle hC6accel, char *input_file_name, int n)
 
{
 
    IplImage *input_image;
 
    double arm_min_val, arm_max_val, dsp_min_val, dsp_max_val,
 
           arm_norm, dsp_norm;
 
    CvPoint arm_min_loc, arm_max_loc, dsp_min_loc, dsp_max_loc;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    
 
    printf("cvNorm Test (%s, %i)\n", input_file_name, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input image
 
    input_image = cvLoadImage(input_file_name, CV_LOAD_IMAGE_GRAYSCALE);
 
 
 
    // 2.a Apply ARM algorithm to find min/max pixels
 
    cvMinMaxLoc(input_image, &arm_min_val, &arm_max_val, &arm_min_loc, &arm_max_loc, NULL);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvMinMaxLoc(input_image, &arm_min_val, &arm_max_val, &arm_min_loc, &arm_max_loc, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called ARM cvMinMaxLoc function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 2.b Apply DSP algorithm to find min/max pixels
 
    C6accel_cvMinMaxLoc(hC6accel, input_image, &dsp_min_val, &dsp_max_val, &dsp_min_loc, &dsp_max_loc, NULL);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvMinMaxLoc(hC6accel, input_image, &dsp_min_val, &dsp_max_val, &dsp_min_loc, &dsp_max_loc, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called DSP cvMinMaxLoc function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 3.a Apply ARM algorithm to find norm
 
    arm_norm = cvNorm(input_image, NULL, CV_L2, NULL);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        arm_norm = cvNorm(input_image, NULL, CV_L2, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called ARM cvNorm function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 3.b Apply DSP algorithm to find norm
 
    C6accel_cvNorm(hC6accel, input_image, NULL, CV_L2, NULL, &dsp_norm);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvNorm(hC6accel, input_image, NULL, CV_L2, NULL, &dsp_norm);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called DSP cvNorm function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 4. Compare outputs
 
    printf("ARM image statistics:\n\tL2 Norm:\t%f\n\tMin Val:\t%f\t(%i, %i)\n\tMax Val:\t%f\t(%i, %i)\n",
 
           arm_norm, arm_min_val, arm_min_loc.x, arm_min_loc.y, arm_max_val, arm_max_loc.x, arm_max_loc.y);
 
    printf("DSP image statistics:\n\tL2 Norm:\t%f\n\tMin Val:\t%f\t(%i, %i)\n\tMax Val:\t%f\t(%i, %i)\n",
 
           dsp_norm, dsp_min_val, dsp_min_loc.x, dsp_min_loc.y, dsp_max_val, dsp_max_loc.x, dsp_max_loc.y);
 
    
 
    cvReleaseImage(&input_image);
 
    printf("C6accel_cvNorm test completed successfully\n");
 
 
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvIntegral(C6accel_Handle hC6accel, char *input_file_name, int n)
 
{
 
    IplImage *input_image, *arm_sum_image, *arm_norm_image,
 
             *dsp_sum_image, *dsp_norm_image;
 
    CvSize integral_size;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    
 
    printf("cvIntegral Test (%s, %i)\n", input_file_name, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input image
 
    input_image = cvLoadImage(input_file_name, CV_LOAD_IMAGE_GRAYSCALE);
 
    
 
    // 2. Create output images
 
    integral_size = cvSize(input_image->width + 1, input_image->height + 1);
 
    arm_sum_image =  cvCreateImage(integral_size, IPL_DEPTH_32S, 1);
 
    arm_norm_image = cvCreateImage(integral_size, IPL_DEPTH_32S, 1);
 
    dsp_sum_image =  cvCreateImage(integral_size, IPL_DEPTH_32S, 1);
 
    dsp_norm_image = cvCreateImage(integral_size, IPL_DEPTH_32S, 1);
 
 
 
    // 3.a Apply ARM integral algorithm
 
    cvIntegral(input_image, arm_sum_image, NULL, NULL);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvIntegral(input_image, arm_sum_image, NULL, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called ARM cvIntegral function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 3.b Apply DSP integral algorithm
 
    C6accel_cvIntegral(hC6accel, input_image, dsp_sum_image, NULL, NULL);
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvIntegral(hC6accel, input_image, dsp_sum_image, NULL, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    printf("Called DSP cvIntegral function (time: %f ms)\n", t_algo / 1000.0 / n);
 
    
 
    // 4. Normalize output images
 
    cvNormalize(arm_sum_image, arm_norm_image, 0, 255, CV_MINMAX, NULL);
 
    cvNormalize(dsp_sum_image, dsp_norm_image, 0, 255, CV_MINMAX, NULL);
 
    
 
    // 5. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(arm_norm_image, dsp_norm_image, CV_L2, NULL));
 
    
 
    // 6. Save output images to filesystem
 
    cvSaveImage("./output_arm.png", arm_norm_image, 0);
 
    cvSaveImage("./output_dsp.png", dsp_norm_image, 0);
 
    
 
    // 7. Free memory allocated to images
 
    cvReleaseImage(&input_image);
 
    cvReleaseImage(&arm_sum_image);
 
    cvReleaseImage(&arm_norm_image);
 
    cvReleaseImage(&dsp_sum_image);
 
    cvReleaseImage(&dsp_norm_image);
 
 
 
    printf("C6accel_cvIntegral test completed successfully\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvAdd(C6accel_Handle hC6accel, char *input_file_name1,char *input_file_name2, int n)
 
{
 
    IplImage *inputImg1,*inputImg2, *outputImg_arm, *outputImg_dsp;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    float t_avg;
 
    
 
    printf("cvAdd Test (%s, %i iterations)\n", input_file_name1, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input images from file
 
    inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
    inputImg2 = cvLoadImage( input_file_name2, CV_LOAD_IMAGE_COLOR);
 
    
 
    // 2. Allocate output images (must have same depth, channels as input)
 
    outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
    outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
    
 
    // 3.a Apply ARM algorithm
 
    cvAdd(inputImg1,inputImg2,outputImg_arm,NULL); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvAdd(inputImg1,inputImg2, outputImg_arm, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM Add function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 3.b Apply DSP algorithm
 
    C6accel_cvAdd(hC6accel, inputImg1,inputImg2,outputImg_dsp,NULL); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvAdd(hC6accel, inputImg1, inputImg2, outputImg_dsp,NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP Add function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        
 
    // 4. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
    
 
    // 5. Save outputs to filesystem
 
    cvSaveImage("./output_arm.png", outputImg_arm, 0);
 
    cvSaveImage("./output_dsp.png", outputImg_dsp, 0);
 
    
 
    // 6. Free memory allocated to images
 
    cvReleaseImage(&inputImg1);
 
    cvReleaseImage(&inputImg2);
 
    cvReleaseImage(&outputImg_arm);
 
    cvReleaseImage(&outputImg_dsp);
 
 
 
    printf("C6accel_cvAdd test completed successfully; outputs saved to filesystem\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvAddS(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
    IplImage *inputImg1, *outputImg_arm, *outputImg_dsp;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    float t_avg;
 
    CvScalar red = {0, 0, 255, 255};
 
    printf("cvAddS Test (%s, %i iterations)\n", input_file_name1, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input images from file
 
    inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
    
 
    // 2. Allocate output images (must have same depth, channels as input)
 
    outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
    outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
    
 
    // 3.a Apply ARM algorithm
 
    cvAddS(inputImg1,red,outputImg_arm,NULL); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvAddS(inputImg1,red, outputImg_arm, NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM Add function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 3.b Apply DSP algorithm
 
    C6accel_cvAddS(hC6accel, inputImg1,red,outputImg_dsp,NULL); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvAddS(hC6accel, inputImg1, red, outputImg_dsp,NULL);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP AddS function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        
 
    // 5. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
    
 
    // 6. Save outputs to filesystem
 
    cvSaveImage("./output_arm.png", outputImg_arm, 0);
 
    cvSaveImage("./output_dsp.png", outputImg_dsp, 0);
 
 
 
    //7. Free memory allocated to images
 
    cvReleaseImage(&inputImg1);
 
    cvReleaseImage(&outputImg_arm);
 
    cvReleaseImage(&outputImg_dsp);
 
 
 
    printf("C6accel_cvAddS test completed successfully; outputs saved to filesystem\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvAbsDiff(C6accel_Handle hC6accel, char *input_file_name1,char *input_file_name2, int n)
 
{
 
    IplImage *inputImg1,*inputImg2, *outputImg_arm, *outputImg_dsp;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    float t_avg;
 
    
 
    printf("cvAbsDiff Test (%s, %i iterations)\n", input_file_name1, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input images from file
 
    inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
    inputImg2 = cvLoadImage( input_file_name2, CV_LOAD_IMAGE_COLOR);
 
    
 
    // 2. Allocate output images (must have same depth, channels as input)
 
    outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
    outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
    
 
    // 3.a Apply ARM algorithm
 
    cvAbsDiff(inputImg1,inputImg2,outputImg_arm); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvAbsDiff(inputImg1,inputImg2, outputImg_arm);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM AbsDiff function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 3.b Apply DSP algorithm
 
    C6accel_cvAbsDiff(hC6accel, inputImg1,inputImg2,outputImg_dsp); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvAbsDiff(hC6accel, inputImg1, inputImg2, outputImg_dsp);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP AbsDiff function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        
 
    // 5. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
    
 
    // 6. Save outputs to filesystem
 
    cvSaveImage("./output_arm.png", outputImg_arm, 0);
 
    cvSaveImage("./output_dsp.png", outputImg_dsp, 0);
 
    
 
    //7. Free memeory allocated to images
 
    cvReleaseImage(&inputImg1);
 
    cvReleaseImage(&inputImg2);
 
    cvReleaseImage(&outputImg_arm);
 
    cvReleaseImage(&outputImg_dsp);
 
 
 
    printf("C6accel_cvAbsDiff test completed successfully; outputs saved to filesystem\n");
 
    return 1;
 
}
 
 
 
Int c6accel_test_cvAbsDiffS(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
    IplImage *inputImg1, *outputImg_arm, *outputImg_dsp;
 
    struct timeval startTime, endTime;
 
    int t_overhead, t_algo, i;
 
    float t_avg;
 
    CvScalar value = cvScalarAll(0.0);
 
    printf("cvAbsDiffS Test (%s, %i iterations)\n", input_file_name1, n);
 
    
 
    // initialize timer
 
    t_overhead = get_overhead_time();
 
    printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
    
 
    // 1. Read input images from file
 
    inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
    
 
    // 2. Allocate output images (must have same depth, channels as input)
 
    outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
    outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
    
 
    // 3.a Apply ARM algorithm
 
    cvAbsDiffS(inputImg1,outputImg_arm,value); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        cvAbsDiffS(inputImg1, outputImg_arm,value);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
 
 
    printf("Called ARM AbsDiffS function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
    
 
    // 3.b Apply DSP algorithm
 
    C6accel_cvAbsDiffS(hC6accel, inputImg1,outputImg_arm,value); // run once before timing
 
    gettimeofday(&startTime, NULL);
 
    for (i = 0; i < n; i++)
 
        C6accel_cvAbsDiffS(hC6accel, inputImg1, outputImg_dsp,value);
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called DSP AbsDiffS function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    
 
    // 4. Compare outputs
 
    printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
 
 
    // 5. Save outputs to filesystem
 
    cvSaveImage("./output_arm.png", outputImg_arm, 0);
 
    cvSaveImage("./output_dsp.png", outputImg_dsp, 0);
 
 
 
   //6. Free memory allocated to images
 
    cvReleaseImage(&inputImg1);
 
    cvReleaseImage(&outputImg_arm);
 
    cvReleaseImage(&outputImg_dsp);
 
 
 
    printf("C6accel_cvAbsDiffS test completed successfully; outputs saved to filesystem\n");
 
 
 
    return 1;
 
 
 
}
 
 
 
 
 
 
 
Int C6accel_test_contours(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1,  *inputImg2, *outputImg_arm, *outputImg_dsp;
 
        IplImage*	g_gray = NULL;
 
        double		g_thresh = 100.0;
 
        CvSeq* contours = 0, *contour2;
 
        CvMemStorage* 	g_storage = NULL;
 
        int status;
 
        struct timeval startTime, endTime;
 
        int t_overhead=0, t_algo, i;
 
        double t_br_arm=0.0, t_dc_arm=0.0, t_ca_arm=0.0,t_br_dsp=0.0, t_dc_dsp=0.0, t_ca_dsp=0.0;
 
        float t_avg;
 
        CvScalar value = cvScalarAll(0.0);
 
        CvRect boundbox;
 
        double area,area_arm,area_dsp, Total_area_arm, Total_area_dsp;
 
 
 
        //Important: For DSP implementation pass pointer and allocate memroy from CMEM
 
        CvRect *boundbox_ptr;
 
 
 
        void *temp_ptr;
 
        printf("cvThreshold Test (%s, %i iterations)\n", input_file_name1, n);
 
        
 
       // initialize timer
 
         t_overhead = get_overhead_time();
 
         printf("(Overhead time is %f ms.)\n", t_overhead / 1000.0);
 
      
 
       // 1. Read input images from file
 
        inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
        inputImg2 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
        
 
       //allocate memory for CvRect from CMEM
 
        boundbox_ptr=Memory_alloc(sizeof(CvRect), &testfxnsMemParams);
 
 
 
       // 2. Allocate output images (must have same depth, channels as input)
 
       // cvThreshold supports only single chanel output(8bit)
 
       outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), 8,1);
 
       outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), 8,1);
 
      
 
       g_gray = cvCreateImage(cvSize(inputImg1->width, inputImg1->height),8,1);
 
 
 
       //3. Create storage for the contour
 
        g_storage = cvCreateMemStorage(0);
 
        temp_ptr = cvMemStorageAlloc(g_storage, 64);
 
	contours = cvCreateSeq(0,sizeof(CvSeq),sizeof(CvPoint), g_storage);
 
	cvCvtColor( inputImg1, g_gray, CV_BGR2GRAY );
 
        gettimeofday(&startTime, NULL);
 
        // 3.a Apply ARM algorithm
 
        for (i = 0; i < n; i++)
 
           cvThreshold(g_gray, outputImg_arm , g_thresh, 255.0, CV_THRESH_BINARY );
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM cvThreshold function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        // 3.b Apply DSP algorithm
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
        status = C6accel_cvThreshold(hC6accel, g_gray, outputImg_dsp , g_thresh, 255.0, CV_THRESH_BINARY );
 
 
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP cvThreshold function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
         // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
        cvSaveImage("./output_arm_thresh.png",outputImg_arm , 0);
 
        cvSaveImage("./output_dsp_thresh.png",outputImg_dsp , 0);
 
 
 
        printf("Find Contours Called\n");
 
        //6 Test for drawing functions and contour features :Bounding Rect, DrawContours, ContourArea        
 
	C6accel_cvFindContours(hC6accel,outputImg_arm, g_storage, &contours, sizeof(CvContour),CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE,cvPoint(0,0) );
 
        printf("Find Contours Complete\n");
 
        gettimeofday(&startTime, NULL);
 
        boundbox = cvBoundingRect(contours,1);
 
        gettimeofday(&endTime, NULL);
 
        
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM cvBoundingRect function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        
 
        gettimeofday(&startTime, NULL);
 
        C6accel_cvBoundingRect(hC6accel,contours,boundbox_ptr,1);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;    
 
        printf("Called DSP cvBoundingRect function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
 
 
        gettimeofday(&startTime, NULL);
 
        cvDrawContours(inputImg1, contours,CV_RGB(255,0,0),CV_RGB(0,255,0),-1, 1,8, cvPoint(0,0) );
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;    
 
        printf("Called ARM cvDrawContour function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        gettimeofday(&startTime, NULL);
 
         C6accel_cvDrawContours(hC6accel,inputImg2, contours,CV_RGB(255,0,0),CV_RGB(0,255,0),-1, 1,8, cvPoint(0,0) );
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;    
 
        printf("Called DSP cvDrawContour function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        gettimeofday(&startTime, NULL);
 
        cvContourArea( (void *)contours,CV_WHOLE_SEQ,0);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;    
 
        printf("Called ARM cvContourArea function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        gettimeofday(&startTime, NULL);
 
         C6accel_cvContourArea(hC6accel, contours,CV_WHOLE_SEQ,&area );
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;    
 
        printf("Called DSP cvContourArea function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
 
 
        i=0;
 
        Total_area_arm = 0.0;
 
        Total_area_dsp = 0.0;
 
       
 
        gettimeofday(&startTime, NULL);  
 
        for(; contours; contours = contours->h_next) {
 
         if( contours ){
 
                i++;
 
                //ARM code
 
                boundbox = cvBoundingRect(contours,1);
 
                cvRectangle(inputImg1,                    
 
                            cvPoint(boundbox.x, boundbox.y),        
 
                            cvPoint(boundbox.x+boundbox.width, boundbox.y+boundbox.height),      
 
                            cvScalar(255,0,0,0),
 
                             1, 8, 0);  
 
        
 
                //DSP code
 
                //Find minimal bounding box for each sequence
 
                 C6accel_cvBoundingRect(hC6accel,contours,boundbox_ptr,1);
 
         
 
                cvRectangle(inputImg2,                    
 
                            cvPoint(boundbox_ptr->x, boundbox_ptr->y),        
 
                            cvPoint(boundbox_ptr->x+boundbox_ptr->width, boundbox_ptr->y+boundbox_ptr->height),      
 
                            cvScalar(255,0,0,0),
 
                            1, 8, 0); 
 
               
 
         
 
                cvDrawContours(inputImg1, contours,CV_RGB(255,0,0),CV_RGB(0,255,0),-1, 1,8, cvPoint(0,0) );
 
            
 
                C6accel_cvDrawContours(hC6accel,inputImg2, contours,CV_RGB(255,0,0),CV_RGB(0,255,0),-1, 1,8, cvPoint(0,0) );
 
         
 
                area_arm = fabs(cvContourArea( (void *)contours,CV_WHOLE_SEQ,0));
 
                Total_area_arm += area_arm;
 
                        
 
                C6accel_cvContourArea(hC6accel, contours,CV_WHOLE_SEQ,&area );
 
               
 
                Total_area_dsp += fabs(area);
 
                
 
	  }
 
     }
 
     gettimeofday(&endTime, NULL);
 
     t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
     t_avg = (float)t_algo / (float)n;    
 
     printf("Called DSP Plotting function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
     printf("Difference between total area calculated using ContourArea =%f\n", fabs(Total_area_dsp-Total_area_arm) );
 
 
 
 
 
     // 6. Save outputs to filesystem
 
     cvSaveImage("./output_arm_contour.png",inputImg1 , 0);
 
     cvSaveImage("./output_dsp_contour.png",inputImg2 , 0);
 
 
 
     //7. Free memory allocated to images
 
     cvReleaseImage(&inputImg1);
 
     cvReleaseImage(&g_gray);
 
     cvReleaseImage(&inputImg2);
 
     cvReleaseImage(&outputImg_arm);
 
     cvReleaseImage(&outputImg_dsp);
 
     cvReleaseMemStorage(&g_storage);
 
 
 
     printf("Test for contours completed successfully; outputs saved to filesystem\n");
 
     return 1;
 
}
 
 
 
Int C6Accel_test_Matchshapes(C6accel_Handle hC6accel, char *input_file_name1, char *input_file_name2,int n)
 
{
 
  IplImage *inputImg1,  *inputImg2, *outputImg_arm, *outputImg_dsp;
 
  IplImage*	g_gray = NULL;
 
  double		g_thresh = 100.0;
 
  CvSeq *contour1,*contour2, *tmp1, *tmp2;
 
  CvMemStorage* 	g_storage_1 = NULL;
 
   CvMemStorage* 	g_storage_2 = NULL;
 
  int status;
 
  struct timeval startTime, endTime;
 
  int t_overhead, t_algo, i;
 
  float t_avg;
 
  void *temp_ptr_1,*temp_ptr_2;
 
  double measure,measure_arm;
 
  unsigned int var;
 
 
 
       // 1. Read input images from file
 
       inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
       inputImg2 = cvLoadImage( input_file_name2, CV_LOAD_IMAGE_COLOR);
 
       // 2. Allocate output images (must have same depth, channels as input)
 
       // cvThreshold supports only single chanel output(8bit)
 
       outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), 8,1);
 
       outputImg_dsp = cvCreateImage(cvSize(inputImg2->width, inputImg1->height), 8,1);
 
      
 
       g_gray = cvCreateImage(cvSize(inputImg1->width, inputImg1->height),8,1);
 
       
 
       //3.Create storage for the contour
 
        g_storage_1 = cvCreateMemStorage(0);
 
        temp_ptr_1 = cvMemStorageAlloc(g_storage_1, 64);
 
        
 
	contour1 = cvCreateSeq(0,sizeof(CvSeq),sizeof(CvPoint), g_storage_1);
 
  
 
	cvCvtColor( inputImg1, g_gray, CV_BGR2GRAY );
 
        cvThreshold(g_gray, outputImg_arm , g_thresh, 255.0, CV_THRESH_BINARY );
 
        
 
       
 
        cvFindContours(outputImg_arm,g_storage_1, &contour1,sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE,cvPoint(0,0));
 
     
 
         g_storage_2 = cvCreateMemStorage(0);
 
        temp_ptr_2 = cvMemStorageAlloc(g_storage_2, 64);
 
        
 
	contour2 = cvCreateSeq(0,sizeof(CvSeq),sizeof(CvPoint), g_storage_1);
 
  
 
	cvCvtColor( inputImg2, g_gray, CV_BGR2GRAY );
 
        cvThreshold(g_gray, outputImg_dsp , g_thresh, 255.0, CV_THRESH_BINARY );
 
        
 
       
 
        cvFindContours(outputImg_dsp,g_storage_2, &contour2,sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE,cvPoint(0,0));
 
 
 
       tmp1= contour1;
 
       tmp2= contour2;
 
       cvCopy(inputImg2,inputImg1,0);
 
 
 
       //ARM: Benchmark loop
 
       gettimeofday(&startTime, NULL);
 
       for(i=0; contour1,contour2; contour1 = contour1->h_next,contour2 = contour2->h_next) {
 
           measure_arm = cvMatchShapes(contour2,contour1, 2,1.0);
 
        }
 
       gettimeofday(&endTime, NULL);
 
        
 
       //ARM: Draw loop
 
       contour1=tmp1;
 
       contour2=tmp2;
 
       for(i=0; contour1,contour2; contour1 = contour1->h_next,contour2 = contour2->h_next) {
 
                 measure_arm = cvMatchShapes(contour2,contour1, 2,1.0);
 
                //Code to plot matched and unmatched contours
 
                  printf("match_arm = %f\n",(double)measure_arm);
 
                 if(measure_arm<0.7){ //arbitary threshold
 
                     cvDrawContours(inputImg1, contour2,CV_RGB(0,255,0),CV_RGB(0,255,0),-1, 3,8, cvPoint(0,0) );
 
                    }
 
                   if(measure_arm>=0.7){//arbitary threshold
 
                     cvDrawContours(inputImg1, contour2,CV_RGB(0,0,255),CV_RGB(0,0,255),-1, 3,8, cvPoint(0,0) );
 
                   }
 
     
 
       }
 
       t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
       t_avg = (float)t_algo / (float)n;
 
 
 
       printf("Called ARM cvMatchShapes function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
       contour1=tmp1;
 
       contour2=tmp2;
 
       //DSP: Benchmark loop
 
       gettimeofday(&startTime, NULL);
 
       for(i=0; contour1,contour2; contour1 = contour1->h_next,contour2 = contour2->h_next) {
 
           C6accel_cvMatchShapes(hC6accel,contour1,contour2, 2,1.0,&measure);
 
        }
 
 
 
      gettimeofday(&endTime, NULL);
 
      t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
      t_avg = (float)t_algo / (float)n;
 
 
 
      printf("Called DSP cvMatchShapes function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
      contour1=tmp1;
 
      contour2=tmp2;
 
      //DSP: Draw loop
 
      for(i=0; contour1,contour2; contour1 = contour1->h_next,contour2 = contour2->h_next) {
 
           C6accel_cvMatchShapes(hC6accel,contour1,contour2, 2,1.0,&measure);
 
           printf("match_dsp = %f\n",(double)measure);
 
           if(measure<0.7){
 
              cvDrawContours(inputImg2, contour2,CV_RGB(0,255,0),CV_RGB(0,255,0),-1, 3,8, cvPoint(0,0) );
 
           }
 
           if(measure>=0.7){
 
              cvDrawContours(inputImg2, contour2,CV_RGB(0,0,255),CV_RGB(0,0,255),-1, 3,8, cvPoint(0,0) );
 
           }
 
        }
 
 
 
      gettimeofday(&endTime, NULL);
 
      // 6. Save outputs to filesystem
 
        cvSaveImage("./output_arm_matchcontour.png",inputImg1 , 0);
 
        cvSaveImage("./output_dsp_matchcontour.png",inputImg2 , 0);
 
    
 
     //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&inputImg2);
 
        cvReleaseImage(&g_gray);
 
        cvReleaseMemStorage(&g_storage_1);
 
        cvReleaseMemStorage(&g_storage_2);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
 
 
 
 
        return 0;
 
}
 
       
 
Int C6Accel_test_FindContours(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
 
 
{
 
  IplImage *inputImg1,  *inputImg2, *outputImg_arm, *outputImg_dsp;
 
  IplImage*	g_gray = NULL;
 
  double		g_thresh = 100.0;
 
  CvSeq *contour1 = NULL,*contour2=NULL , *tmp1, *tmp2;
 
  CvMemStorage* 	g_storage_1 = NULL;
 
  CvMemStorage* 	g_storage_2 = NULL;
 
  int status;
 
  struct timeval startTime, endTime;
 
  int t_overhead, t_algo, i;
 
  float t_avg;
 
  void *temp_ptr_1,*temp_ptr_2;
 
  double measure,measure_arm;
 
  unsigned int var;
 
  int storage_size =  200*1024; // 200K /*** Storage size from one image to other *****/
 
   
 
 
 
 // 1. Read input images from file
 
   inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
   printf("inp_image->imagedata= %x\n",CMEM_getPhys(inputImg1->imageData));
 
   inputImg2 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
 // 2. Allocate output images (must have same depth, channels as input)
 
 // cvThreshold supports only single chanel output(8bit)
 
    outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), 8,1);
 
    outputImg_dsp = cvCreateImage(cvSize(inputImg2->width, inputImg2->height), 8,1);
 
   
 
    g_gray = cvCreateImage(cvSize(inputImg1->width, inputImg1->height),8,1);
 
       
 
 //Create storage for the contour
 
 //ARM loop       
 
    g_storage_1 = cvCreateMemStorage(storage_size);
 
    temp_ptr_1 = cvMemStorageAlloc(g_storage_1, 64);
 
        
 
    cvCvtColor( inputImg1, g_gray, CV_BGR2GRAY );
 
    cvThreshold(g_gray, outputImg_arm , g_thresh, 255.0, CV_THRESH_BINARY );
 
 
 
    gettimeofday(&startTime, NULL);
 
    cvFindContours(outputImg_arm,g_storage_1, &contour1,sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE,cvPoint(0,0));
 
    gettimeofday(&endTime, NULL);
 
    t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
    t_avg = (float)t_algo / (float)n;
 
    printf("Called ARM cvFindContours function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
    for(i=0;contour1;contour1=contour1->h_next,i++)  {
 
     //  status = contour1->flags;
 
     //    printf("Flag=%x\n",status);
 
       cvDrawContours(inputImg1, contour1,CV_RGB(255,0,0),CV_RGB(0,255,0),-1, 1,8, cvPoint(0,0) );
 
    }
 
   // printf("Press Enter\n");
 
    // getchar();
 
    
 
    //DSP loop 
 
      g_storage_2 = cvCreateMemStorage(storage_size);
 
      temp_ptr_2 = cvMemStorageAlloc(g_storage_2, 64);
 
        
 
      contour2 = cvCreateSeq(0,sizeof(CvSeq),sizeof(CvPoint), g_storage_1);
 
      cvCvtColor( inputImg2, g_gray, CV_BGR2GRAY );
 
      cvThreshold(g_gray, outputImg_dsp , g_thresh, 255.0, CV_THRESH_BINARY );
 
        
 
      gettimeofday(&startTime, NULL);
 
        C6accel_cvFindContours(hC6accel, outputImg_dsp,g_storage_2, &contour2,sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE,cvPoint(0,0));
 
      gettimeofday(&endTime, NULL);
 
      t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
      t_avg = (float)t_algo / (float)n;
 
      printf("Called DSP cvFindContours function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
      printf("Test for cvFindContours function called successfully. Output saved to filesystem\n");
 
      
 
      for(i=0;contour2;contour2=contour2->h_next,i++)  {
 
        // status = contour2->flags;
 
        // printf("Flag=%x\n",status);
 
         C6accel_cvDrawContours(hC6accel,inputImg2, contour2,CV_RGB(255,0,0),CV_RGB(0,255,0),-1, 1,8, cvPoint(0,0) );
 
       }
 
        
 
      // 6. Save outputs to filesystem
 
        cvSaveImage("./output_arm_contour.png",inputImg1 , 0);
 
        cvSaveImage("./output_dsp_contour.png",inputImg2 , 0);
 
   
 
      //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&inputImg2);
 
        cvReleaseImage(&g_gray);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
        cvReleaseMemStorage(&g_storage_2);
 
        cvReleaseMemStorage(&g_storage_1);
 
        return 0;
 
}
 
 
 
Int C6Accel_test_Dilate(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1, *outputImg_arm, *outputImg_dsp;
 
        int pos= 0;
 
        struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
        // 1. Load Input
 
        inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
       
 
        // 2. Allocate output images (must have same depth, channels as input)
 
        outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
        outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
        
 
        //3. Benchmark the ARM call
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
           cvDilate(inputImg1,outputImg_arm,NULL,pos);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM cvDilate function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        //4. Benchmark the DSP call
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
           C6accel_cvDilate(hC6accel,inputImg1,outputImg_dsp,NULL,pos);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP cvDilate function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        
 
       // 5. Compare outputs
 
       printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
       // 6. Save output
 
        cvSaveImage("./output_arm.png",outputImg_arm , 0);
 
        cvSaveImage("./output_dsp.png",outputImg_dsp , 0);
 
        printf("Test for Dilate operations done\n");
 
                      
 
       //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
        return 1;
 
 
 
}
 
 
 
Int C6Accel_test_Erode(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1, *outputImg_arm, *outputImg_dsp;
 
        int pos= 0;
 
        struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
 
 
        inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
       
 
        // 2. Allocate output images (must have same depth, channels as input)
 
        outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
        outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
        
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
           cvErode(inputImg1,outputImg_arm,NULL,pos);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM cvErode function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
           C6accel_cvErode(hC6accel,inputImg1,outputImg_dsp,NULL,pos);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP cvErode function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        
 
       // 5. Compare outputs
 
       printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
   
 
        cvSaveImage("./output_arm.png",outputImg_arm , 0);
 
        cvSaveImage("./output_dsp.png",outputImg_dsp , 0);
 
        printf("Test for Erode operations done\n");
 
     
 
       //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
        return 1;
 
 
 
}
 
 
 
Int C6Accel_test_Laplace(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1, *outputImg_arm, *outputImg_dsp, *g_gray;
 
        int pos= 0;
 
        struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
 
 
        inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
       
 
        // 2. Allocate output images (must have same depth, channels as input)
 
        outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), IPL_DEPTH_16S, 1);
 
        outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), IPL_DEPTH_16S, 1);
 
        g_gray = cvCreateImage(cvSize(inputImg1->width, inputImg1->height),IPL_DEPTH_8U, 1);
 
	
 
	cvCvtColor( inputImg1, g_gray, CV_BGR2GRAY );
 
        
 
        gettimeofday(&startTime, NULL);
 
        //for (i = 0; i < n; i++)
 
         cvLaplace(g_gray,outputImg_arm ,3);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM cvLaplace function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        gettimeofday(&startTime, NULL);
 
       // for (i = 0; i < n; i++)
 
         C6accel_cvLaplace(hC6accel,g_gray,outputImg_dsp,3);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo /(float)n;
 
 
 
        printf("Called DSP cvLaplace function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
         // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
   
 
        cvSaveImage("./output_arm.png",outputImg_arm , 0);
 
        cvSaveImage("./output_dsp.png",outputImg_dsp , 0);
 
        printf("Test for Laplace operations done\n");
 
  
 
       //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&g_gray);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
        return 1;
 
 
 
}
 
 
 
Int C6Accel_test_PyrDown(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1, *outputImg_arm, *outputImg_dsp;
 
        int pos= 0;
 
        struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
 
 
        inputImg1 = cvLoadImage( input_file_name1, 0);
 
        
 
        // 2. Allocate output images (must have same depth, channels as input)
 
        outputImg_arm = cvCreateImage(cvSize(inputImg1->width/2, inputImg1->height/2), IPL_DEPTH_8U, 1);
 
        outputImg_dsp = cvCreateImage(cvSize(inputImg1->width/2, inputImg1->height/2), IPL_DEPTH_8U, 1);
 
                
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         cvPyrDown(inputImg1,outputImg_arm ,CV_GAUSSIAN_5x5);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM cvPyrDown function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         C6accel_cvPyrDown(hC6accel,inputImg1,outputImg_dsp,CV_GAUSSIAN_5x5);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP cvPyrDown function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
         // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
   
 
        cvSaveImage("./output_arm.png",outputImg_arm , 0);
 
        cvSaveImage("./output_dsp.png",outputImg_dsp , 0);
 
        printf("Test for PyrDown operations done\n");
 
  
 
       //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
        return 1;
 
 
 
}
 
 
 
Int C6Accel_test_Filter2D(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1, *outputImg_arm, *outputImg_dsp;
 
        int pos= 0;
 
        struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
        CvMat *filter;
 
        int nFiltCols=5, nFiltRows =5;
 
        float kernel [25] = { 0,-1, 0,1,0,
 
                            -1,-2,0,2,1,
 
                            -1,-2,1,2,1,
 
                            -1,-1,0,2,1,
 
                             0,-1,0,1,0};
 
        float* pkernel;
 
         /* Allocate CMEM memory for 3x3 short mask*/
 
        pkernel = Memory_alloc(25*sizeof(float), &testfxnsMemParams);
 
        memcpy( pkernel,kernel,25*sizeof(float));
 
 
 
        inputImg1 = cvLoadImage( input_file_name1, 0);
 
       
 
        // 2. Allocate output images (must have same depth, channels as input)
 
        outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), IPL_DEPTH_8U, 1);
 
        outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), IPL_DEPTH_8U, 1);
 
        
 
        filter = cvCreateMat(nFiltRows, nFiltCols,  CV_32FC1);
 
        cvSetData(filter,pkernel,nFiltCols*sizeof(float) );
 
 
 
        printf("Mat =%x\n", CMEM_getPhys(filter));
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
            cvFilter2D(inputImg1,outputImg_arm,filter,cvPoint(-1,-1));
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
        printf("Called ARM cvFilter2D function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         C6accel_cvFilter2D(hC6accel,inputImg1,outputImg_dsp,filter,cvPoint(-1,-1));
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
     
 
        printf("Called DSP cvFilter2D function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
         // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
   
 
        cvSaveImage("./output_arm.png",outputImg_arm , 0);
 
        cvSaveImage("./output_dsp.png",outputImg_dsp , 0);
 
 
 
        printf("Test for Filter2D operations done\n");
 
      
 
       //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
        //printf("Test for Filter2D operations done\n");
 
        /*  Release Gaussian CMEM */
 
        Memory_free(pkernel,25*sizeof(float),&testfxnsMemParams);
 
        return 1;
 
 
 
}
 
 
 
 
 
Int C6Accel_test_Canny(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1, *outputImg_arm, *outputImg_dsp, *g_gray;
 
        int pos= 0;
 
        struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
 
 
        inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
       
 
        // 2. Allocate output images (must have same depth, channels as input)
 
        outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), 8,1);
 
        outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), 8,1);
 
         g_gray = cvCreateImage(cvSize(inputImg1->width, inputImg1->height),8,1);
 
	//for (i=0;i<30;i++)
 
	cvCvtColor(inputImg1, g_gray, CV_BGR2GRAY );
 
        
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         cvCanny(g_gray,outputImg_arm ,10.0,100.0,3);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM cvCanny function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         C6accel_cvCanny(hC6accel,g_gray,outputImg_dsp,(double)10.0,(double)100.00,3);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP cvCanny function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
         // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
   
 
        cvSaveImage("./output_arm.png",outputImg_arm , 0);
 
        cvSaveImage("./output_dsp.png",outputImg_dsp , 0);
 
        printf("Test for Canny edge detection done\n");
 
             
 
       //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&g_gray);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
        return 1;
 
 
 
}
 
 
 
Int C6Accel_test_CornerHarris(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1, *outputImg_arm, *outputImg_dsp, *corner8;
 
        int pos= 0;
 
        struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
        double minVal=0.0, maxVal=0.0;   
 
        double scale, shift;   
 
        double min=0, max=255;   
 
 
 
 
 
        inputImg1 = cvLoadImage( input_file_name1, 0);
 
       
 
        // 2. Allocate output images (must have same depth, channels as input)
 
        outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height),IPL_DEPTH_32F ,1);
 
        outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), IPL_DEPTH_32F ,1);
 
        corner8 = cvCreateImage(cvSize(inputImg1->width, inputImg1->height),IPL_DEPTH_8U ,1);
 
		       
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         cvCornerHarris(inputImg1,outputImg_arm ,3,3, 0.04);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM cvCornerHarris function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        cvMinMaxLoc( outputImg_arm, &minVal, &maxVal, NULL, NULL, 0);   
 
        scale = (max - min)/(maxVal-minVal);   
 
        shift = -minVal * scale + min;   
 
        cvConvertScale(outputImg_arm, corner8 ,scale,shift);
 
        cvSaveImage("./output_arm.png",corner8 , 0);
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         C6accel_cvCornerHarris(hC6accel,inputImg1,outputImg_dsp,3,3, 0.04);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP cvCornerHarris function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        cvMinMaxLoc( outputImg_dsp, &minVal, &maxVal, NULL, NULL, 0);   
 
        scale = (max - min)/(maxVal-minVal);   
 
        shift = -minVal * scale + min;   
 
        cvConvertScale(outputImg_dsp, corner8 ,scale,shift);
 
 
 
         // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
           
 
        cvSaveImage("./output_dsp.png",corner8 , 0);
 
        printf("Test for cornerharris edge detection done\n");
 
             
 
       //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&corner8);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
        return 1;
 
 
 
}
 
 
 
Int C6Accel_test_CornerEigenValsAndVecs(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1, *outputImg_arm, *outputImg_dsp, *g_gray, *eig_val_arm, *eig_val_dsp;
 
        int pos= 0;
 
        struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
        double minVal=0.0, maxVal=0.0;   
 
        double scale, shift;   
 
        double min=0, max=255;   
 
 
 
 
 
        inputImg1 = cvLoadImage( input_file_name1, 1);
 
       
 
        // 2. Allocate output images (must have same depth, channels as input)
 
        //Output must have 6 times the width of the input image to store Eigen values and eigen vectors.
 
        outputImg_arm = cvCreateImage(cvSize(inputImg1->width*6, inputImg1->height),IPL_DEPTH_32F ,1);
 
        outputImg_dsp = cvCreateImage(cvSize(inputImg1->width*6, inputImg1->height), IPL_DEPTH_32F ,1);
 
        g_gray = cvCreateImage(cvSize(inputImg1->width,inputImg1->height), inputImg1->depth, 1);
 
        eig_val_arm = cvCreateImage(cvSize(inputImg1->width,inputImg1->height), IPL_DEPTH_32F, 1);
 
        eig_val_dsp = cvCreateImage(cvSize(inputImg1->width,inputImg1->height), IPL_DEPTH_32F, 1);
 
        cvvConvertImage (inputImg1, g_gray, 0);
 
 
 
        gettimeofday(&startTime, NULL);
 
       
 
        //After that it finds eigenvectors and eigenvalues of
 
        //the resultant matrix and stores them into destination
 
        //image in form (¦Ë1, ¦Ë2, x1, y1, x2, y2), where
 
        //¦Ë1, ¦Ë2 - eigenvalues of M; not sorted
 
        //(x1, y1) - eigenvector corresponding to ¦Ë1
 
        //(x2, y2) - eigenvector corresponding to ¦Ë2
 
 
 
 
 
        for (i = 0; i < n; i++)
 
         cvCornerEigenValsAndVecs(g_gray,outputImg_arm ,5,5);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
        printf("Called ARM cvCornerEigenValsAndVecs function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
       // cvSaveImage("./output_arm.png",outputImg_arm , 0);
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         C6accel_cvCornerEigenValsAndVecs(hC6accel,g_gray,outputImg_dsp,5,5);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP cvCornerEigenValsAndVecs function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
        
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         cvCornerMinEigenVal(g_gray,eig_val_arm ,5,5);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
        printf("Called ARM cvCornerMinEigenVal function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        cvSaveImage("./output_arm.png",eig_val_arm , 0);
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         C6accel_cvCornerMinEigenVal(hC6accel,g_gray,eig_val_dsp ,5,5);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
        printf("Called DSP cvCornerMinEigenVal function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        cvSaveImage("./output_dsp.png",eig_val_dsp , 0);
 
        // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(eig_val_arm, eig_val_dsp, CV_L2, NULL));
 
 
 
               
 
        printf("Test for CornerEigenValsAndVecs and CornerMinEigVal completed successfully\n");
 
             
 
       //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&g_gray);
 
        cvReleaseImage(&eig_val_arm);
 
        cvReleaseImage(&eig_val_dsp);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
        return 1;
 
 
 
}
 
 
 
 
 
Int C6Accel_test_Smooth(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1, *outputImg_arm, *outputImg_dsp, *g_gray;
 
        int pos= 0;
 
        struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
 
 
        inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
       
 
        // 2. Allocate output images (must have same depth, channels as input)
 
        outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
        outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), inputImg1->depth, inputImg1->nChannels);
 
                
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         cvSmooth(inputImg1,outputImg_arm ,CV_GAUSSIAN, 11,11,0.0,0.0);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM cvSmooth function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         C6accel_cvSmooth(hC6accel,inputImg1,outputImg_dsp ,CV_GAUSSIAN, 11,11,(double)0.0,(double)0.0);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP cvSmooth function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
         // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
   
 
        cvSaveImage("./output_arm.png",outputImg_arm , 0);
 
        cvSaveImage("./output_dsp.png",outputImg_dsp , 0);
 
        printf("Test for Smooth/Bluring operation done\n");
 
             
 
       //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
        return 1;
 
 
 
}
 
 
 
 
 
Int C6Accel_test_AdaptiveThreshold(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        IplImage *inputImg1, *outputImg_arm, *outputImg_dsp, *g_gray;
 
        int pos= 0;
 
        struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
 
 
        inputImg1 = cvLoadImage( input_file_name1, CV_LOAD_IMAGE_COLOR);
 
       
 
        // 2. Allocate output images (must have same depth, channels as input)
 
        outputImg_arm = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), IPL_DEPTH_8U,1);
 
        outputImg_dsp = cvCreateImage(cvSize(inputImg1->width, inputImg1->height), IPL_DEPTH_8U,1);
 
        g_gray = cvCreateImage(cvSize(inputImg1->width, inputImg1->height),IPL_DEPTH_8U,1);
 
 
 
       	cvCvtColor( inputImg1, g_gray, CV_BGR2GRAY );
 
                
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         cvAdaptiveThreshold(g_gray,outputImg_arm ,(double)125.0, CV_ADAPTIVE_THRESH_MEAN_C,CV_THRESH_BINARY,7,(double)10.0);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM Adaptive threshold function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
        cvCvtColor( inputImg1, g_gray, CV_BGR2GRAY );
 
 
 
        gettimeofday(&startTime, NULL);
 
        for (i = 0; i < n; i++)
 
         C6accel_cvAdaptiveThreshold(hC6accel,g_gray,outputImg_dsp ,(double)125.0, CV_ADAPTIVE_THRESH_MEAN_C,CV_THRESH_BINARY,7,(double)10.0);
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP Adaptive threshold function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
         // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(outputImg_arm, outputImg_dsp, CV_L2, NULL));
 
   
 
        cvSaveImage("./output_arm.png",outputImg_arm , 0);
 
        cvSaveImage("./output_dsp.png",outputImg_dsp , 0);
 
        printf("Test for Adaptive thresholding operation done\n");
 
             
 
       //7. Free memory allocated to images
 
        cvReleaseImage(&inputImg1);
 
        cvReleaseImage(&g_gray);
 
        cvReleaseImage(&outputImg_arm);
 
        cvReleaseImage(&outputImg_dsp);
 
 
 
        return 1;
 
 
 
}
 
 
 
 
 
Int C6Accel_test_Houghlines2D(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
 
 
 IplImage* src, *dst;
 
 
 
 IplImage* color_dst_arm, *color_dst_dsp;
 
 CvMemStorage* storage_dsp, *storage_arm ;
 
 CvSeq* lines_dsp = NULL, *lines_arm =NULL;
 
 int t_overhead, t_algo, i;
 
 struct timeval startTime, endTime;
 
 float t_avg;
 
 CvPoint pt1,pt2;
 
 float* line, rho, theta;
 
 double a,b, x0,y0;
 
 void *temp_ptr;
 
 
 
 src= cvLoadImage(input_file_name1, 0);
 
 dst= cvCreateImage( cvGetSize(src), 8, 1 );
 
 color_dst_arm = cvCreateImage( cvGetSize(src), 8, 3 );
 
 color_dst_dsp = cvCreateImage( cvGetSize(src), 8, 3 );
 
 
 
 storage_arm = cvCreateMemStorage(0);
 
 temp_ptr = cvMemStorageAlloc(storage_arm, 64);
 
 
 
 cvCanny( src, dst, 50, 200, 3 );
 
 cvCvtColor( dst, color_dst_arm, CV_GRAY2BGR );
 
 cvCvtColor( dst, color_dst_dsp, CV_GRAY2BGR );
 
 
 
 gettimeofday(&startTime, NULL);
 
 /*C6accel_cvHoughLines2( hC6accel, dst,
                               storage,
                               CV_HOUGH_PROBABILISTIC,
                               (double)1.0,
                               (double)(CV_PI/180),
                               80,
                               (double)30.0,
                               (double)10.0,&lines );*/
 
lines_arm = cvHoughLines2(     dst,
 
                               storage_arm,
 
                               CV_HOUGH_PROBABILISTIC,
 
                               (double)1.0,
 
                               (double)(CV_PI/180),
 
                               80,
 
                               (double)30.0,
 
                               (double)10.0);
 
gettimeofday(&endTime, NULL);
 
 
 
t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
t_avg = (float)t_algo / (float)n;
 
printf("Called ARM HoughLines2D function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
 for( i = 0; i < lines_arm->total; i++ )
 
 {
 
    CvPoint* line = (CvPoint*)cvGetSeqElem(lines_arm,i);
 
    cvLine( color_dst_arm, line[0], line[1], CV_RGB(255,0,0), 1, 8,0 );
 
 }
 
cvSaveImage("./output_arm.png",color_dst_arm , 0);
 
 
 
//DSP Processing
 
 storage_dsp = cvCreateMemStorage(0);
 
 temp_ptr = cvMemStorageAlloc(storage_dsp, 64);
 
 gettimeofday(&startTime, NULL);
 
 C6accel_cvHoughLines2( hC6accel, dst,
 
                               storage_dsp,
 
                               CV_HOUGH_PROBABILISTIC,
 
                               (double)1.0,
 
                               (double)(CV_PI/180),
 
                               80,
 
                               (double)30.0,
 
                               (double)10.0,&lines_dsp );
 
 
 
 gettimeofday(&endTime, NULL);
 
 
 
 t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
 t_avg = (float)t_algo / (float)n;
 
 printf("Called DSP HoughLines2D function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
 for( i = 0; i < lines_dsp->total; i++ )
 
 {
 
    CvPoint* line = (CvPoint*)cvGetSeqElem(lines_dsp,i);
 
    cvLine( color_dst_dsp, line[0], line[1], CV_RGB(255,0,0), 1, 8,0 );
 
 }
 
  // 5. Compare outputs
 
 printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(color_dst_arm, color_dst_dsp, CV_L2, NULL));
 
 cvSaveImage("./output_dsp.png",color_dst_dsp , 0);
 
 
 
 
 
 printf("Releasing allocated buffers\n");
 
 //6 Release Memory allocatted for the test
 
 cvReleaseImage( &color_dst_arm );
 
 cvReleaseImage( &color_dst_dsp );
 
 cvReleaseImage( &src);
 
 cvReleaseImage( &dst);
 
 cvReleaseMemStorage( &storage_arm);
 
 cvReleaseMemStorage( &storage_dsp);
 
 return 1;
 
 
 
 
 
}
 
 
 
 
 
 
 
/*Int C6Accel_test_opticalflowHS(C6accel_Handle hC6accel, char *input_file_name1, int n)
{
 int step, x,y;
 float *px, *py;
 int t_overhead, t_algo, i;
 struct timeval startTime, endTime;
 float t_avg;
// Initialize, load two images from the file system, and
    // allocate the images and other structures we will need for
    // results.
    // exit if no input images
    IplImage *imgA = 0, *imgB = 0;
    imgA = cvLoadImage("opencv_images/OpticalFlow0.jpg",0);
    imgB = cvLoadImage("opencv_images/OpticalFlow1.jpg",0);
    if(!(imgA)||!(imgB)){ printf("One of OpticalFlow0.jpg and/or OpticalFlow1.jpg didn't load\n"); return -1;}
    printf("1\n");
    IplImage* velx = cvCreateImage(cvGetSize(imgA),IPL_DEPTH_32F,1);
    IplImage* vely = cvCreateImage(cvGetSize(imgA),IPL_DEPTH_32F,1);
    IplImage* imgC = cvCreateImage(cvGetSize(imgA),IPL_DEPTH_8U,3);
    imgC =  cvLoadImage("opencv_images/OpticalFlow1.jpg",1);
    printf("2\n");
    cvSaveImage( "./OpticalFlow0.png",imgA, 0 );
    cvSaveImage( "./OpticalFlow1.png",imgB, 0 );
    gettimeofday(&startTime, NULL);
    // Call the actual Horn and Schunck algorithm
    //
    cvCalcOpticalFlowHS( 
        imgA, 
        imgB, 
        0,
        velx,
        vely,
        .10,
        cvTermCriteria( 
            CV_TERMCRIT_ITER | CV_TERMCRIT_EPS,
            imgA->width,
            1e-6
        )
    );
    gettimeofday(&endTime, NULL);
 t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 t_avg = (float)t_algo / (float)n;
 printf("Called Optical flow function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
    // Now make some image of what we are looking at:
    //
    gettimeofday(&startTime, NULL);
    step = 4;
    for(  y=0; y<imgC->height; y += step ) {
         px = (float*) ( velx->imageData + y * velx->widthStep );
         py = (float*) ( vely->imageData + y * vely->widthStep );
         for(  x=0; x<imgC->width; x += step ) {
            if( px[x]>1 && py[x]>1 ) {
                cvCircle(
                    imgC,
                    cvPoint( x, y ),
                    2,
                    CVX_GRAY50,
                    -1,8,0
                );
                
                cvLine(
                    imgC,
                    cvPoint( x, y ),
                    cvPoint( x+px[x]/2, y+py[x]/2 ),
                    CV_RGB(255,0,0),
                    1,8,
                    0
                );
              
            }
        }
    }
    gettimeofday(&endTime, NULL);
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
        t_avg = (float)t_algo / (float)n;
        printf("Called ARM cvSmooth function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
    
    // show tracking
    cvSaveImage( "./Flow Results.png",imgC ,0);
    
    // release memory
    cvReleaseImage( &imgA );
    cvReleaseImage( &imgB );
    cvReleaseImage( &imgC );
    cvReleaseImage( &velx);
    cvReleaseImage( &vely);
    return 0;
}*/
 
 
 
 
 
Int C6Accel_test_rotation(C6accel_Handle hC6accel, char *input_file_name1, int n)
 
{
 
        int angle_switch_value = 0;
 
        int angleInt = 0;
 
        int scale_switch_value = 0;
 
        int scaleInt = 0;
 
          struct timeval startTime, endTime;
 
        int t_overhead, t_algo, i;
 
        float t_avg;
 
 
 
 
 
// Set up variables
 
	CvPoint2D32f srcTri[3], dstTri[3];
 
	CvMat* rot_mat = cvCreateMat(2,3,CV_32FC1);
 
        CvMat* rot_mat_dsp = cvCreateMat(2,3,CV_32FC1);
 
	CvMat* warp_mat = cvCreateMat(2,3,CV_32FC1);
 
        CvMat* warp_mat_dsp = cvCreateMat(2,3,CV_32FC1);
 
	IplImage *src, *dst_arm, *dst_dsp;
 
	const char* name = "Affine_Transform";
 
 
 
	// Load image
 
	src=cvLoadImage(input_file_name1,1);
 
	dst_arm = cvLoadImage(input_file_name1,1);
 
        dst_dsp = cvLoadImage(input_file_name1,1);
 
	dst_arm->origin = src->origin;
 
        dst_dsp->origin = src->origin;
 
	cvZero( dst_arm );
 
	cvZero( dst_dsp );
 
       	// Create angle and scale
 
	double angle = 45.0;
 
	double scale = 1.0;
 
	
 
	// Compute warp matrix
 
	srcTri[0].x = 0;
 
	srcTri[0].y = 0;
 
	srcTri[1].x = src->width - 1;
 
	srcTri[1].y = 0;
 
	srcTri[2].x = 0;
 
	srcTri[2].y = src->height - 1;
 
 
 
	dstTri[0].x = src->width*0.0;
 
	dstTri[0].y = src->height*0.25;
 
	dstTri[1].x = src->width*0.90;
 
	dstTri[1].y = src->height*0.15;
 
	dstTri[2].x = src->width*0.10;
 
	dstTri[2].y = src->height*0.75;
 
        
 
        gettimeofday(&startTime, NULL);
 
	   cvGetAffineTransform( srcTri, dstTri, warp_mat );
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM get Affine transform matrix %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
       
 
        gettimeofday(&startTime, NULL);
 
             
 
          C6accel_cvGetAffineTransform( hC6accel, srcTri, dstTri, warp_mat_dsp );
 
 
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP get Affine transform matrix %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        
 
         // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(warp_mat, warp_mat_dsp, CV_L2, NULL));
 
 
 
        gettimeofday(&startTime, NULL);
 
	     cvWarpAffine( src, dst_arm, warp_mat,CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,cvScalarAll(0) );
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM Affine transform function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
 
 
 
 
        gettimeofday(&startTime, NULL);
 
	C6accel_cvWarpAffine( hC6accel,src, dst_dsp, warp_mat_dsp,CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,cvScalarAll(0) );
 
         gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP Affine transform function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
	 // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(dst_arm, dst_dsp, CV_L2, NULL));
 
   
 
	cvSaveImage( "./output_arm_affine.png",dst_arm ,0);
 
        cvSaveImage( "./output_dsp_affine.png",dst_dsp ,0);
 
        cvCopy ( dst_arm, src, NULL );
 
        cvCopy ( dst_dsp, src, NULL );
 
	// Compute rotation matrix
 
	CvPoint2D32f center = cvPoint2D32f( src->width/2, src->height/2 );
 
        gettimeofday(&startTime, NULL);
 
	     cv2DRotationMatrix(center, angle, scale, rot_mat );
 
        gettimeofday(&endTime, NULL);
 
 
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM 2D Rotation Matrix function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
         
 
        gettimeofday(&startTime, NULL);
 
	     C6accel_cv2DRotationMatrix(hC6accel, center, angle, scale, rot_mat_dsp );
 
        gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP 2D Rotation Matrix function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(rot_mat, rot_mat_dsp, CV_L2, NULL));
 
        // Do the transformation
 
         gettimeofday(&startTime, NULL);
 
		cvWarpAffine(src, dst_arm, rot_mat,CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,cvScalarAll(0) );
 
         gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called ARM Rotation using Affine function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
	// Do the transformation
 
         gettimeofday(&startTime, NULL);
 
		C6accel_cvWarpAffine( hC6accel,src, dst_dsp, rot_mat,CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,cvScalarAll(0) );
 
         gettimeofday(&endTime, NULL);
 
        t_algo = (endTime.tv_sec - startTime.tv_sec) * 1000000 + endTime.tv_usec - startTime.tv_usec - t_overhead;
 
        t_avg = (float)t_algo / (float)n;
 
 
 
        printf("Called DSP Rotation using Affine function %i times (average time: %f ms)\n", n, t_avg / 1000.0);
 
         // 5. Compare outputs
 
        printf("Difference (L2 norm) between ARM and DSP outputs: %f\n", cvNorm(dst_arm, dst_dsp, CV_L2, NULL));
 
 
 
	cvSaveImage( "./output_arm_rotated.png",dst_arm ,0);
 
	cvSaveImage( "./output_dsp_rotated.png",dst_dsp ,0);
 
 
 
	cvReleaseImage( &dst_arm );
 
        cvReleaseImage( &dst_dsp );
 
        cvReleaseImage( &src);
 
	cvReleaseMat( &rot_mat );
 
	cvReleaseMat( &warp_mat );
 
        cvReleaseMat( &rot_mat_dsp );
 
	cvReleaseMat( &warp_mat_dsp );
 
	return 0;
 
}