img_corr_gen_d.c

dm642函数库

/* ======================================================================== */
/*  TEXAS INSTRUMENTS, INC.                                                 */
/*                                                                          */
/*  NAME                                                                    */
/*      IMG_corr_gen_d.c -- Example file for IMG_corr_gen                   */
/*                                                                          */
/*  USAGE                                                                   */
/*      This file contains code for demonstrating the C64x IMGLIB           */
/*      IMG_corr_gen function. All inputs to the function contain random    */
/*      data. The assembly version of IMG_corr_gen is called and the        */
/*      output is compared with the reference C code using mem_compare()    */
/*      in support.c.                                                       */
/* ------------------------------------------------------------------------ */
/*          Copyright (C) 2003 Texas Instruments, Incorporated.             */
/*                          All Rights Reserved.                            */
/* ======================================================================== */
    
#include <stdio.h>
#include <stdlib.h>

/* Header file for the memory compare function */
int mem_compare(const void *ptr1, const char *name1,
                const void *ptr2, const char *name2, int len);

/* Header file for the DSPLIB function */
#include "IMG_corr_gen.h"

/* Header file for the C function */
void IMG_corr_gen_c(short * in_data, short * h, short * out_data, int m, int COLS);

/* ======================================================================== */
/*  IMGLIB function-specific alignments. Refer to the                       */
/*  TMS320C64x IMG Library Programmer's Reference for details.              */
/* ======================================================================== */
#pragma DATA_ALIGN(in_data, 4);
#pragma DATA_ALIGN(out_data_asm, 8);
#pragma DATA_ALIGN(out_data_c, 8);

/* ======================================================================== */
/*  Constant dataset.                                                       */
/* ======================================================================== */
#define M    (9)
#define N    (720)


/* ======================================================================== */
/*  Initialize arrays with random test data.                                */
/* ======================================================================== */
int     test = 0;
short  in_data[N] = 
{
    0x00c7, 0x0027, 0x0023, 0x00d7, 0x007b, 0x0039, 0x00c3, 0x0020,
    0x0086, 0x003a, 0x0004, 0x0055, 0x00fa, 0x005f, 0x0068, 0x00e2,
    0x0015, 0x00e8, 0x0062, 0x0043, 0x00b2, 0x0065, 0x00f8, 0x00ee,
    0x001e, 0x005e, 0x0087, 0x001d, 0x00a6, 0x007d, 0x0082, 0x00ef,
    0x00bf, 0x00f0, 0x007c, 0x001f, 0x00ae, 0x00d8, 0x00e1, 0x00fc,
    0x00f7, 0x000e, 0x00a2, 0x00ad, 0x0040, 0x00c1, 0x008a, 0x002e,
    0x0043, 0x009a, 0x006b, 0x0028, 0x0039, 0x0017, 0x006d, 0x00be,
    0x00fd, 0x00ef, 0x003c, 0x00f5, 0x0009, 0x00fd, 0x008e, 0x002f,
    0x00de, 0x00fb, 0x005e, 0x00ba, 0x0097, 0x0099, 0x0091, 0x00aa,
    0x0094, 0x00a9, 0x00a1, 0x002a, 0x0037, 0x00a9, 0x004a, 0x00f4,
    0x00e4, 0x007a, 0x00fc, 0x00be, 0x0060, 0x00d1, 0x003d, 0x007a,
    0x00b9, 0x00bc, 0x0051, 0x005d, 0x003c, 0x0099, 0x002e, 0x00f5,
    0x000e, 0x00c8, 0x00a8, 0x00f5, 0x00e0, 0x001d, 0x006e, 0x0064,
    0x0096, 0x00bf, 0x006b, 0x0057, 0x0020, 0x0075, 0x00c5, 0x0092,
    0x00d8, 0x0094, 0x00b7, 0x0023, 0x0060, 0x0068, 0x0088, 0x004b,
    0x00ba, 0x008f, 0x00d1, 0x00c7, 0x0091, 0x008d, 0x006a, 0x00f5,
    0x00c2, 0x00e6, 0x0048, 0x0091, 0x0068, 0x0049, 0x00a3, 0x00b3,
    0x002b, 0x00df, 0x0029, 0x003a, 0x0061, 0x0082, 0x001a, 0x0042,
    0x00f5, 0x009e, 0x00de, 0x006a, 0x0091, 0x0049, 0x00aa, 0x00cc,
    0x00d0, 0x005c, 0x0009, 0x0091, 0x0038, 0x00bc, 0x0022, 0x0031,
    0x0092, 0x00ce, 0x00d7, 0x00f9, 0x002a, 0x000e, 0x0035, 0x0049,
    0x00ef, 0x001a, 0x00a4, 0x0044, 0x00b7, 0x00ae, 0x00a7, 0x002a,
    0x00d1, 0x00aa, 0x0041, 0x001a, 0x001c, 0x0070, 0x0037, 0x00e1,
    0x009d, 0x009a, 0x00ae, 0x00d2, 0x005f, 0x00e9, 0x008b, 0x00d2,
    0x00fb, 0x001a, 0x0030, 0x0093, 0x00e0, 0x0036, 0x0010, 0x0082,
    0x0050, 0x00eb, 0x00be, 0x00b5, 0x000c, 0x001c, 0x008a, 0x00fa,
    0x00d4, 0x0043, 0x00b9, 0x0024, 0x00b8, 0x0065, 0x00cf, 0x0021,
    0x001f, 0x00e3, 0x00b6, 0x008e, 0x002f, 0x00aa, 0x000a, 0x00ea,
    0x0046, 0x00ae, 0x0033, 0x00e9, 0x0049, 0x006a, 0x001c, 0x0045,
    0x0000, 0x00d3, 0x008f, 0x00df, 0x000b, 0x007d, 0x0055, 0x002a,
    0x004e, 0x005c, 0x00db, 0x00fd, 0x0052, 0x00f1, 0x00c4, 0x00f2,
    0x00af, 0x008d, 0x00b0, 0x0008, 0x0013, 0x0031, 0x0070, 0x0078,
    0x0032, 0x00dc, 0x007d, 0x0014, 0x003c, 0x0007, 0x00a3, 0x0024,
    0x00c6, 0x007f, 0x00c2, 0x0078, 0x0075, 0x00b0, 0x00e6, 0x00d7,
    0x0087, 0x0029, 0x003b, 0x00e0, 0x0083, 0x0027, 0x0092, 0x004c,
    0x0014, 0x0000, 0x002c, 0x00ec, 0x00d6, 0x00ca, 0x00f6, 0x007f,
    0x00da, 0x007f, 0x007b, 0x002c, 0x00d5, 0x00c5, 0x0083, 0x00d5,
    0x00dd, 0x0022, 0x00ad, 0x0092, 0x0026, 0x000a, 0x00ba, 0x0098,
    0x0089, 0x000f, 0x0028, 0x007c, 0x000c, 0x003c, 0x00fc, 0x00c2,
    0x009d, 0x00f8, 0x0084, 0x00b7, 0x006e, 0x0042, 0x007d, 0x00c8,
    0x00de, 0x0019, 0x0074, 0x0085, 0x0093, 0x0041, 0x0077, 0x00e1,
    0x0007, 0x00cc, 0x0036, 0x0048, 0x0054, 0x00ce, 0x0084, 0x006f,
    0x0012, 0x00a4, 0x0090, 0x00d5, 0x0089, 0x00c1, 0x006a, 0x003f,
    0x00c9, 0x0049, 0x00c7, 0x0065, 0x0065, 0x0067, 0x00b5, 0x00fb,
    0x0024, 0x0041, 0x007d, 0x0099, 0x00dc, 0x00c8, 0x00f1, 0x00c5,
    0x0004, 0x00bc, 0x00e2, 0x0031, 0x00ad, 0x0011, 0x004c, 0x00c0,
    0x00cd, 0x00f3, 0x0099, 0x0094, 0x00d2, 0x008b, 0x0040, 0x00d1,
    0x00f0, 0x001a, 0x00da, 0x0020, 0x0013, 0x00d3, 0x00b4, 0x001b,
    0x0063, 0x00e6, 0x00ec, 0x0017, 0x005e, 0x00a7, 0x0015, 0x00a1,
    0x0080, 0x00a2, 0x00d7, 0x003b, 0x00af, 0x0012, 0x0039, 0x00d5,
    0x00ea, 0x00e1, 0x00f7, 0x00cc, 0x006d, 0x00e4, 0x0075, 0x0087,
    0x002a, 0x002d, 0x003d, 0x003a, 0x00ea, 0x00ff, 0x0001, 0x009e,
    0x00ae, 0x0036, 0x009b, 0x002d, 0x00d7, 0x0014, 0x00ff, 0x004b,
    0x0007, 0x0029, 0x00d0, 0x0081, 0x0058, 0x00ea, 0x006f, 0x00b8,
    0x0079, 0x00e9, 0x0027, 0x001a, 0x003f, 0x00b0, 0x00cd, 0x000a,
    0x000a, 0x00f8, 0x0019, 0x0093, 0x00f6, 0x00f8, 0x0045, 0x00b5,
    0x0002, 0x003c, 0x003f, 0x007d, 0x00d0, 0x0054, 0x004e, 0x00dd,
    0x0077, 0x00ee, 0x0043, 0x0061, 0x0065, 0x00dd, 0x00bf, 0x00b4,
    0x0019, 0x006d, 0x0046, 0x00ac, 0x0027, 0x00cb, 0x0077, 0x00c8,
    0x0093, 0x009e, 0x006c, 0x0086, 0x0009, 0x006d, 0x0055, 0x001c,
    0x0014, 0x0089, 0x003b, 0x0081, 0x0040, 0x00d3, 0x0041, 0x00e5,
    0x0019, 0x0009, 0x00d2, 0x0078, 0x009b, 0x00e8, 0x0000, 0x00bf,
    0x0029, 0x00dc, 0x0062, 0x00d5, 0x0000, 0x00f7, 0x00ef, 0x0043,
    0x0075, 0x0043, 0x00b0, 0x0099, 0x00cf, 0x00e0, 0x00c2, 0x00a0,
    0x00dd, 0x00a8, 0x0035, 0x00a7, 0x001c, 0x00e3, 0x00a7, 0x00cf,
    0x00e7, 0x00f5, 0x008c, 0x00fa, 0x007c, 0x00b3, 0x006f, 0x00dd,
    0x00f4, 0x0072, 0x0031, 0x00ed, 0x00cb, 0x00eb, 0x006f, 0x00db,
    0x00d9, 0x00f2, 0x00aa, 0x00f0, 0x00a0, 0x00c4, 0x0011, 0x007d,
    0x00da, 0x0063, 0x0050, 0x00fd, 0x00e7, 0x00bd, 0x00f8, 0x0061,
    0x0049, 0x00fa, 0x00c4, 0x00ff, 0x0057, 0x00b3, 0x0024, 0x003f,
    0x00e8, 0x00d8, 0x000b, 0x009f, 0x001b, 0x00f6, 0x006d, 0x007d,
    0x0029, 0x0000, 0x003a, 0x0096, 0x00e4, 0x0011, 0x00c4, 0x009a,
    0x00f4, 0x008e, 0x00e2, 0x0061, 0x0053, 0x0086, 0x00a9, 0x004a,
    0x0061, 0x007f, 0x0077, 0x00f5, 0x0025, 0x0065, 0x00a2, 0x002d,
    0x000a, 0x004a, 0x006e, 0x00aa, 0x002e, 0x0031, 0x0044, 0x0017,
    0x00a2, 0x006e, 0x0020, 0x0089, 0x00f0, 0x009e, 0x0063, 0x0063,
    0x00d2, 0x0066, 0x0045, 0x00c2, 0x0035, 0x0091, 0x0094, 0x00a3,
    0x0051, 0x007d, 0x0033, 0x0029, 0x00a9, 0x0061, 0x0099, 0x00e2,
    0x00ee, 0x00fe, 0x002a, 0x0051, 0x0094, 0x001b, 0x00b2, 0x0081,
    0x0034, 0x0093, 0x00ca, 0x0096, 0x0031, 0x003d, 0x0074, 0x00ae,
    0x00bf, 0x00b7, 0x000b, 0x000c, 0x008c, 0x0085, 0x00fe, 0x00eb,
    0x0014, 0x00c3, 0x0074, 0x00d1, 0x0033, 0x0071, 0x00b3, 0x007e,
    0x008a, 0x00c9, 0x0085, 0x0069, 0x00dc, 0x000d, 0x00b5, 0x00f3,
    0x00ec, 0x00df, 0x00ba, 0x0024, 0x003d, 0x007e, 0x0036, 0x00a5,
    0x00bd, 0x0071, 0x0035, 0x007c, 0x00c0, 0x0019, 0x006c, 0x0032,
    0x0006, 0x00a5, 0x00a9, 0x0045, 0x00e9, 0x0028, 0x0020, 0x00cf,
    0x00fc, 0x00ce, 0x003e, 0x002c, 0x0004, 0x00da, 0x0033, 0x0012,
    0x00e4, 0x00c7, 0x002d, 0x008d, 0x004a, 0x005a, 0x00dc, 0x002a,
    0x00ef, 0x0002, 0x00c7, 0x007e, 0x00f2, 0x00c9, 0x006b, 0x0034,
    0x0013, 0x0027, 0x0032, 0x00a0, 0x00ef, 0x0054, 0x0078, 0x00f0
};

short  h[M] = 
{
    0x0005, 0x0004, 0x0004, 0x0003, 0x0003, 0x0000, 0x0004, 0x0001, 0x0005
};

short  out_data_asm[N-M+8];
short  out_data_c[N-M+8];



int main()
{   
/* ======================================================================== */
/*  Clear output arrays.                                                    */ 
/* ======================================================================== */   
    memset(out_data_asm, 0, sizeof(out_data_asm));
    memset(out_data_c,   0, sizeof(out_data_c)  );
    
/* ======================================================================== */
/*  Call hand-coded assembly version (located in IMG64x.lib library         */ 
/*  archive - see Project -> Build Options -> Linker -> Include Libraries)  */
/* ======================================================================== */   
    IMG_corr_gen(in_data, h, out_data_asm, M, N);
    
/* ======================================================================== */
/*  Call natural-C version                                                  */
/* ======================================================================== */
    IMG_corr_gen_c(in_data, h, out_data_c, M, N);

/* ======================================================================== */
/*  Compare outputs using mem_compare() in support.c.  If different,        */
/*  mem_compare() displays location of failures.                            */
/* ======================================================================== */
    test = mem_compare(out_data_asm, "out_data_asm", out_data_c, "out_data_c", sizeof(out_data_c));
    if (test == 0) 
    {
      printf("out_data_asm vs. out_data_c");
      printf("\nVerification successful.\n");
    }

}

/* ======================================================================== */
/*  End of file:  img_corr_gen_d.c                                          */
/* ------------------------------------------------------------------------ */
/*          Copyright (C) 2003 Texas Instruments, Incorporated.             */
/*                          All Rights Reserved.                            */
/* ======================================================================== */