954 lines
48 KiB
C
954 lines
48 KiB
C
/*
|
|
|
|
This program is part of the TACLeBench benchmark suite.
|
|
Version V 2.0
|
|
|
|
Name: epic
|
|
|
|
Author: Designed by Eero P. Simoncelli and Edward H. Adelson
|
|
Written by Eero P. Simoncelli
|
|
Developed at the Vision Science Group, The Media Laboratory
|
|
Copyright 1989, Massachusetts Institute of Technology
|
|
All rights reserved.
|
|
|
|
Function: Efficient Pyramid Image Coder
|
|
|
|
Source: MediaBench
|
|
|
|
|
|
Original name: epic
|
|
|
|
Changes: no major functional changes
|
|
|
|
License:
|
|
Permission to use, copy, or modify this software and its documentation
|
|
for educational and research purposes only and without fee is hereby
|
|
granted, provided that this copyright notice appear on all copies and
|
|
supporting documentation. For any other uses of this software, in
|
|
original or modified form, including but not limited to distribution
|
|
in whole or in part, specific prior permission must be obtained from
|
|
M.I.T. and the authors. These programs shall not be used, rewritten,
|
|
or adapted as the basis of a commercial software or hardware product
|
|
without first obtaining appropriate licenses from M.I.T. M.I.T. makes
|
|
no representations about the suitability of this software for any
|
|
purpose. It is provided "as is" without express or implied warranty.
|
|
*/
|
|
|
|
#include "epic.h"
|
|
|
|
// Wasm loop bounds
|
|
|
|
|
|
|
|
|
|
__attribute__((import_module("__pragma"), import_name("loopbound"))) extern void
|
|
__pragma_loopbound(unsigned int min_bound, unsigned int max_bound);
|
|
|
|
#define X_SIZE 64
|
|
#define Y_SIZE 64
|
|
|
|
float epic_image[] = {
|
|
0x89, 0x88, 0x87, 0x86, 0x89, 0x87, 0x84, 0x86, 0x83, 0x89, 0x82, 0x83,
|
|
0x84, 0x81, 0x80, 0x80, 0x81, 0x83, 0x88, 0x8A, 0x8E, 0x90, 0x96, 0x98,
|
|
0x95, 0x92, 0x93, 0x88, 0x78, 0x7B, 0x60, 0x52, 0x41, 0x3F, 0x3A, 0x46,
|
|
0x46, 0x48, 0x49, 0x48, 0x4F, 0x4A, 0x49, 0x50, 0x4C, 0x4B, 0x4D, 0x4C,
|
|
0x4E, 0x4E, 0x4A, 0x49, 0x4D, 0x54, 0x50, 0x59, 0x51, 0x5A, 0x5E, 0x5A,
|
|
0x5D, 0x61, 0x59, 0x65, 0x63, 0x65, 0x60, 0x62, 0x68, 0x67, 0x64, 0x61,
|
|
0x64, 0x5E, 0x66, 0x63, 0x63, 0x61, 0x67, 0x68, 0x62, 0x64, 0x66, 0x67,
|
|
0x64, 0x63, 0x66, 0x64, 0x67, 0x66, 0x65, 0x64, 0x64, 0x6A, 0x66, 0x65,
|
|
0x68, 0x66, 0x69, 0x67, 0x6A, 0x66, 0x68, 0x66, 0x6C, 0x65, 0x69, 0x64,
|
|
0x65, 0x64, 0x66, 0x62, 0x63, 0x68, 0x68, 0x65, 0x64, 0x64, 0x62, 0x63,
|
|
0x68, 0x65, 0x66, 0x69, 0x66, 0x65, 0x61, 0x66, 0x6E, 0x69, 0x64, 0x61,
|
|
0x63, 0x63, 0x66, 0x63, 0x62, 0x64, 0x60, 0x68, 0x63, 0x61, 0x62, 0x65,
|
|
0x60, 0x63, 0x60, 0x62, 0x60, 0x5E, 0x61, 0x62, 0x5D, 0x5C, 0x57, 0x5B,
|
|
0x58, 0x53, 0x54, 0x47, 0x49, 0x54, 0x5C, 0x6B, 0x6F, 0x77, 0x7F, 0x80,
|
|
0x88, 0x8A, 0x8C, 0x85, 0x7A, 0x7D, 0x7F, 0x7D, 0x80, 0x80, 0x81, 0x80,
|
|
0x85, 0x82, 0x81, 0x7E, 0x80, 0x7F, 0x7F, 0x7E, 0x7D, 0x7E, 0x83, 0x7F,
|
|
0x81, 0x83, 0x87, 0x82, 0x83, 0x88, 0x84, 0x82, 0x82, 0x8A, 0xB3, 0xC5,
|
|
0xCD, 0xCF, 0xD4, 0xD3, 0xD6, 0xCC, 0xB5, 0x80, 0x4E, 0x48, 0x4D, 0x4D,
|
|
0x57, 0x5A, 0x59, 0x5C, 0x62, 0x58, 0x5C, 0x5B, 0x5B, 0x62, 0x5D, 0x5C,
|
|
0x59, 0x5C, 0x5A, 0x59, 0x5D, 0x5F, 0x5B, 0x5F, 0x60, 0x5E, 0x5E, 0x57,
|
|
0x5F, 0x5F, 0x60, 0x61, 0x5C, 0x61, 0x60, 0x5B, 0x56, 0x56, 0x57, 0x58,
|
|
0x6E, 0x91, 0x96, 0x7E, 0x89, 0x88, 0x87, 0x86, 0x8A, 0x87, 0x84, 0x87,
|
|
0x83, 0x89, 0x82, 0x83, 0x84, 0x81, 0x80, 0x80, 0x81, 0x83, 0x88, 0x8A,
|
|
0x8E, 0x90, 0x96, 0x98, 0x94, 0x93, 0x93, 0x88, 0x78, 0x7B, 0x60, 0x52,
|
|
0x41, 0x3F, 0x39, 0x46, 0x46, 0x48, 0x49, 0x47, 0x50, 0x4A, 0x49, 0x50,
|
|
0x4D, 0x4B, 0x4D, 0x4C, 0x4E, 0x4E, 0x4A, 0x49, 0x4E, 0x54, 0x4F, 0x59,
|
|
0x51, 0x5A, 0x5E, 0x5A, 0x5D, 0x61, 0x59, 0x65, 0x63, 0x65, 0x5F, 0x62,
|
|
0x68, 0x67, 0x64, 0x61, 0x64, 0x5E, 0x66, 0x63, 0x63, 0x61, 0x67, 0x69,
|
|
0x61, 0x63, 0x66, 0x67, 0x65, 0x63, 0x66, 0x64, 0x67, 0x67, 0x65, 0x64,
|
|
0x64, 0x6A, 0x66, 0x65, 0x68, 0x66, 0x69, 0x67, 0x6A, 0x67, 0x69, 0x66,
|
|
0x6C, 0x65, 0x69, 0x64, 0x65, 0x64, 0x66, 0x62, 0x63, 0x68, 0x68, 0x66,
|
|
0x64, 0x64, 0x62, 0x63, 0x68, 0x65, 0x66, 0x6A, 0x67, 0x65, 0x60, 0x66,
|
|
0x6F, 0x6A, 0x64, 0x61, 0x64, 0x63, 0x66, 0x63, 0x62, 0x64, 0x60, 0x69,
|
|
0x64, 0x61, 0x62, 0x65, 0x60, 0x63, 0x60, 0x62, 0x60, 0x5E, 0x61, 0x62,
|
|
0x5D, 0x5C, 0x57, 0x5B, 0x59, 0x53, 0x54, 0x47, 0x49, 0x54, 0x5C, 0x6B,
|
|
0x6F, 0x77, 0x7F, 0x80, 0x88, 0x8A, 0x8C, 0x85, 0x7A, 0x7D, 0x7F, 0x7C,
|
|
0x80, 0x80, 0x81, 0x80, 0x85, 0x82, 0x81, 0x7E, 0x80, 0x7F, 0x7F, 0x7E,
|
|
0x7D, 0x7E, 0x83, 0x7F, 0x81, 0x83, 0x87, 0x81, 0x83, 0x88, 0x84, 0x82,
|
|
0x82, 0x8A, 0xB5, 0xC5, 0xCD, 0xCF, 0xD4, 0xD3, 0xD6, 0xCC, 0xB4, 0x7E,
|
|
0x4D, 0x48, 0x4E, 0x4D, 0x57, 0x5A, 0x59, 0x5C, 0x62, 0x58, 0x5C, 0x5B,
|
|
0x5B, 0x62, 0x5D, 0x5C, 0x59, 0x5C, 0x5A, 0x59, 0x5D, 0x5F, 0x5B, 0x5F,
|
|
0x60, 0x5E, 0x5E, 0x57, 0x5F, 0x5F, 0x60, 0x61, 0x5C, 0x61, 0x60, 0x5B,
|
|
0x56, 0x56, 0x57, 0x58, 0x6F, 0x94, 0x9A, 0x82, 0x88, 0x89, 0x87, 0x86,
|
|
0x88, 0x86, 0x84, 0x85, 0x82, 0x87, 0x82, 0x81, 0x83, 0x81, 0x7F, 0x80,
|
|
0x82, 0x82, 0x87, 0x8A, 0x8F, 0x90, 0x95, 0x98, 0x95, 0x92, 0x92, 0x88,
|
|
0x79, 0x77, 0x5F, 0x51, 0x41, 0x3E, 0x3B, 0x44, 0x44, 0x46, 0x49, 0x4A,
|
|
0x4C, 0x49, 0x49, 0x4E, 0x4A, 0x4A, 0x4E, 0x4A, 0x4D, 0x4D, 0x48, 0x4A,
|
|
0x4C, 0x52, 0x52, 0x58, 0x52, 0x59, 0x5E, 0x5A, 0x5D, 0x5F, 0x59, 0x64,
|
|
0x64, 0x64, 0x62, 0x61, 0x66, 0x66, 0x64, 0x60, 0x62, 0x5F, 0x65, 0x63,
|
|
0x62, 0x62, 0x65, 0x66, 0x62, 0x65, 0x67, 0x66, 0x64, 0x64, 0x65, 0x65,
|
|
0x66, 0x65, 0x65, 0x63, 0x63, 0x67, 0x65, 0x64, 0x67, 0x67, 0x68, 0x66,
|
|
0x6A, 0x66, 0x67, 0x66, 0x6C, 0x65, 0x6A, 0x64, 0x64, 0x63, 0x66, 0x62,
|
|
0x63, 0x67, 0x69, 0x65, 0x64, 0x63, 0x62, 0x63, 0x68, 0x65, 0x66, 0x69,
|
|
0x66, 0x65, 0x61, 0x65, 0x6C, 0x69, 0x64, 0x61, 0x62, 0x62, 0x64, 0x63,
|
|
0x61, 0x63, 0x60, 0x66, 0x63, 0x61, 0x62, 0x65, 0x60, 0x62, 0x60, 0x62,
|
|
0x60, 0x5E, 0x60, 0x61, 0x5C, 0x5C, 0x59, 0x5B, 0x57, 0x53, 0x52, 0x47,
|
|
0x48, 0x54, 0x5C, 0x69, 0x6E, 0x77, 0x7D, 0x80, 0x88, 0x89, 0x8C, 0x84,
|
|
0x7B, 0x7D, 0x7E, 0x7D, 0x7F, 0x80, 0x81, 0x7F, 0x85, 0x82, 0x80, 0x7E,
|
|
0x7F, 0x7E, 0x7F, 0x7F, 0x7E, 0x7F, 0x82, 0x7F, 0x81, 0x83, 0x86, 0x82,
|
|
0x83, 0x87, 0x84, 0x82, 0x81, 0x88, 0xB0, 0xC5, 0xCD, 0xCF, 0xD4, 0xD4,
|
|
0xD6, 0xCD, 0xB8, 0x86, 0x51, 0x47, 0x4B, 0x4D, 0x56, 0x59, 0x59, 0x5B,
|
|
0x5F, 0x59, 0x5C, 0x5D, 0x5B, 0x62, 0x5D, 0x5B, 0x5B, 0x5C, 0x5B, 0x5A,
|
|
0x5E, 0x5F, 0x5D, 0x5F, 0x60, 0x5D, 0x5F, 0x58, 0x5E, 0x5F, 0x5F, 0x5F,
|
|
0x5B, 0x60, 0x60, 0x5C, 0x57, 0x56, 0x59, 0x5B, 0x6E, 0x8A, 0x87, 0x6C,
|
|
0x84, 0x88, 0x86, 0x84, 0x87, 0x85, 0x84, 0x82, 0x80, 0x84, 0x82, 0x7E,
|
|
0x82, 0x7F, 0x7C, 0x80, 0x84, 0x80, 0x84, 0x8B, 0x90, 0x92, 0x93, 0x95,
|
|
0x97, 0x91, 0x8E, 0x86, 0x79, 0x6F, 0x5B, 0x4F, 0x41, 0x3A, 0x3D, 0x3F,
|
|
0x40, 0x42, 0x48, 0x4B, 0x46, 0x48, 0x47, 0x4A, 0x46, 0x49, 0x4D, 0x48,
|
|
0x48, 0x4D, 0x46, 0x4C, 0x4B, 0x4F, 0x55, 0x55, 0x54, 0x58, 0x5D, 0x5B,
|
|
0x5D, 0x5C, 0x5A, 0x61, 0x62, 0x60, 0x65, 0x61, 0x63, 0x65, 0x64, 0x5F,
|
|
0x60, 0x61, 0x63, 0x63, 0x61, 0x63, 0x61, 0x63, 0x64, 0x66, 0x67, 0x66,
|
|
0x64, 0x65, 0x65, 0x67, 0x64, 0x64, 0x66, 0x63, 0x62, 0x64, 0x63, 0x62,
|
|
0x65, 0x67, 0x66, 0x65, 0x68, 0x65, 0x64, 0x64, 0x69, 0x63, 0x69, 0x65,
|
|
0x63, 0x61, 0x63, 0x61, 0x63, 0x68, 0x6B, 0x65, 0x63, 0x61, 0x62, 0x64,
|
|
0x66, 0x64, 0x65, 0x66, 0x63, 0x63, 0x63, 0x65, 0x65, 0x67, 0x65, 0x60,
|
|
0x60, 0x5E, 0x60, 0x64, 0x5E, 0x63, 0x60, 0x61, 0x5F, 0x60, 0x61, 0x63,
|
|
0x62, 0x62, 0x5E, 0x60, 0x61, 0x60, 0x5E, 0x5D, 0x5C, 0x5D, 0x5C, 0x5A,
|
|
0x54, 0x51, 0x4E, 0x4A, 0x46, 0x50, 0x59, 0x62, 0x6A, 0x75, 0x79, 0x80,
|
|
0x86, 0x86, 0x8B, 0x83, 0x7F, 0x7E, 0x7E, 0x7E, 0x7E, 0x81, 0x81, 0x7E,
|
|
0x83, 0x82, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x81, 0x81, 0x81, 0x7F, 0x7E,
|
|
0x80, 0x82, 0x84, 0x83, 0x81, 0x84, 0x83, 0x82, 0x7F, 0x82, 0x9D, 0xBD,
|
|
0xC9, 0xCE, 0xD2, 0xD4, 0xD6, 0xD2, 0xC4, 0xA1, 0x68, 0x49, 0x48, 0x4D,
|
|
0x54, 0x56, 0x59, 0x5A, 0x5A, 0x5B, 0x5B, 0x60, 0x5B, 0x60, 0x5B, 0x5B,
|
|
0x5C, 0x5C, 0x5D, 0x5D, 0x60, 0x5C, 0x5E, 0x5E, 0x5E, 0x5B, 0x5E, 0x5C,
|
|
0x5D, 0x5E, 0x5F, 0x5C, 0x5C, 0x60, 0x61, 0x5E, 0x5A, 0x58, 0x5F, 0x62,
|
|
0x5F, 0x5D, 0x48, 0x32, 0x81, 0x85, 0x85, 0x81, 0x86, 0x83, 0x84, 0x80,
|
|
0x7F, 0x84, 0x83, 0x7E, 0x80, 0x7E, 0x7D, 0x80, 0x82, 0x7F, 0x85, 0x8D,
|
|
0x91, 0x93, 0x92, 0x95, 0x95, 0x8F, 0x8C, 0x84, 0x76, 0x6B, 0x5D, 0x50,
|
|
0x41, 0x38, 0x39, 0x3B, 0x41, 0x41, 0x46, 0x47, 0x45, 0x47, 0x44, 0x47,
|
|
0x45, 0x4A, 0x49, 0x48, 0x45, 0x4C, 0x48, 0x4C, 0x4E, 0x4E, 0x51, 0x56,
|
|
0x56, 0x59, 0x5A, 0x5C, 0x5C, 0x5E, 0x5A, 0x60, 0x5D, 0x60, 0x62, 0x61,
|
|
0x63, 0x64, 0x62, 0x5F, 0x61, 0x62, 0x64, 0x62, 0x61, 0x64, 0x61, 0x64,
|
|
0x63, 0x65, 0x65, 0x67, 0x63, 0x66, 0x65, 0x64, 0x63, 0x65, 0x66, 0x61,
|
|
0x60, 0x67, 0x64, 0x62, 0x63, 0x65, 0x64, 0x65, 0x65, 0x63, 0x62, 0x63,
|
|
0x63, 0x61, 0x67, 0x66, 0x63, 0x5F, 0x5E, 0x60, 0x63, 0x66, 0x6A, 0x64,
|
|
0x62, 0x60, 0x64, 0x63, 0x65, 0x62, 0x62, 0x62, 0x60, 0x62, 0x63, 0x63,
|
|
0x61, 0x64, 0x65, 0x60, 0x60, 0x5D, 0x61, 0x62, 0x5D, 0x61, 0x5E, 0x60,
|
|
0x5C, 0x60, 0x5F, 0x60, 0x61, 0x61, 0x5F, 0x60, 0x61, 0x61, 0x5E, 0x5D,
|
|
0x5D, 0x5B, 0x5A, 0x58, 0x52, 0x51, 0x4E, 0x4D, 0x47, 0x4A, 0x51, 0x5B,
|
|
0x66, 0x70, 0x76, 0x7C, 0x81, 0x84, 0x8A, 0x85, 0x81, 0x80, 0x7F, 0x7C,
|
|
0x7F, 0x82, 0x82, 0x81, 0x82, 0x82, 0x81, 0x84, 0x80, 0x82, 0x81, 0x80,
|
|
0x81, 0x81, 0x80, 0x80, 0x81, 0x82, 0x81, 0x82, 0x7F, 0x81, 0x80, 0x81,
|
|
0x7F, 0x7D, 0x86, 0xAB, 0xC1, 0xCB, 0xCF, 0xD2, 0xD3, 0xD5, 0xCF, 0xBA,
|
|
0x8A, 0x57, 0x48, 0x4D, 0x51, 0x52, 0x55, 0x5A, 0x5A, 0x5B, 0x59, 0x5F,
|
|
0x59, 0x5C, 0x59, 0x5C, 0x5A, 0x5A, 0x5B, 0x5C, 0x5F, 0x5C, 0x5D, 0x5B,
|
|
0x5D, 0x5C, 0x5C, 0x5E, 0x5C, 0x5D, 0x61, 0x5E, 0x5D, 0x5F, 0x62, 0x61,
|
|
0x61, 0x5F, 0x60, 0x5A, 0x3D, 0x28, 0x19, 0x13, 0x82, 0x84, 0x83, 0x7F,
|
|
0x84, 0x83, 0x83, 0x81, 0x80, 0x83, 0x84, 0x82, 0x7F, 0x7F, 0x80, 0x7F,
|
|
0x81, 0x83, 0x87, 0x8E, 0x92, 0x91, 0x93, 0x94, 0x91, 0x8F, 0x8E, 0x83,
|
|
0x72, 0x6A, 0x60, 0x4F, 0x3F, 0x36, 0x37, 0x3D, 0x42, 0x3F, 0x43, 0x47,
|
|
0x45, 0x45, 0x46, 0x46, 0x47, 0x4B, 0x44, 0x46, 0x44, 0x47, 0x48, 0x4B,
|
|
0x51, 0x4D, 0x4F, 0x56, 0x56, 0x5A, 0x5A, 0x5B, 0x5B, 0x5D, 0x5B, 0x5F,
|
|
0x5C, 0x62, 0x5D, 0x61, 0x62, 0x63, 0x60, 0x63, 0x62, 0x63, 0x64, 0x60,
|
|
0x61, 0x64, 0x60, 0x66, 0x5F, 0x63, 0x65, 0x67, 0x63, 0x63, 0x63, 0x63,
|
|
0x63, 0x65, 0x63, 0x61, 0x62, 0x66, 0x63, 0x63, 0x62, 0x63, 0x61, 0x62,
|
|
0x64, 0x61, 0x64, 0x63, 0x61, 0x64, 0x66, 0x63, 0x63, 0x5E, 0x5D, 0x5E,
|
|
0x63, 0x61, 0x64, 0x63, 0x63, 0x60, 0x63, 0x62, 0x64, 0x62, 0x63, 0x61,
|
|
0x62, 0x61, 0x63, 0x60, 0x61, 0x61, 0x63, 0x63, 0x61, 0x62, 0x62, 0x60,
|
|
0x5E, 0x5F, 0x5F, 0x61, 0x5D, 0x61, 0x5F, 0x5F, 0x5F, 0x5E, 0x61, 0x60,
|
|
0x5F, 0x5F, 0x62, 0x61, 0x5D, 0x5A, 0x56, 0x58, 0x54, 0x52, 0x51, 0x4F,
|
|
0x4C, 0x47, 0x4B, 0x57, 0x61, 0x6C, 0x72, 0x79, 0x7E, 0x82, 0x89, 0x87,
|
|
0x82, 0x82, 0x7F, 0x7E, 0x80, 0x82, 0x86, 0x84, 0x85, 0x84, 0x83, 0x85,
|
|
0x82, 0x82, 0x82, 0x80, 0x81, 0x83, 0x82, 0x80, 0x80, 0x83, 0x80, 0x81,
|
|
0x7F, 0x81, 0x7F, 0x81, 0x83, 0x7A, 0x7D, 0x95, 0xB7, 0xC6, 0xCD, 0xD0,
|
|
0xD3, 0xD5, 0xD4, 0xC9, 0xA9, 0x73, 0x4B, 0x48, 0x4D, 0x50, 0x53, 0x57,
|
|
0x59, 0x5A, 0x57, 0x5C, 0x5B, 0x5A, 0x59, 0x5B, 0x59, 0x58, 0x58, 0x5A,
|
|
0x5F, 0x5D, 0x5B, 0x58, 0x5D, 0x5A, 0x5C, 0x5D, 0x5D, 0x5E, 0x5E, 0x5F,
|
|
0x5C, 0x5D, 0x62, 0x65, 0x66, 0x65, 0x55, 0x3D, 0x20, 0x13, 0x12, 0x17,
|
|
0x83, 0x83, 0x80, 0x81, 0x84, 0x82, 0x81, 0x81, 0x81, 0x83, 0x81, 0x83,
|
|
0x7F, 0x80, 0x80, 0x7E, 0x83, 0x8A, 0x8A, 0x90, 0x93, 0x91, 0x92, 0x92,
|
|
0x8F, 0x90, 0x8D, 0x83, 0x71, 0x69, 0x5D, 0x4D, 0x41, 0x37, 0x37, 0x3F,
|
|
0x3C, 0x3F, 0x42, 0x48, 0x44, 0x46, 0x49, 0x4B, 0x4A, 0x4A, 0x41, 0x45,
|
|
0x45, 0x44, 0x44, 0x48, 0x50, 0x4C, 0x51, 0x53, 0x57, 0x57, 0x5A, 0x5A,
|
|
0x5D, 0x5B, 0x5D, 0x5D, 0x5C, 0x5E, 0x5E, 0x62, 0x5E, 0x62, 0x60, 0x65,
|
|
0x63, 0x63, 0x61, 0x5F, 0x61, 0x63, 0x5E, 0x65, 0x5E, 0x61, 0x66, 0x63,
|
|
0x63, 0x61, 0x63, 0x65, 0x61, 0x62, 0x62, 0x64, 0x64, 0x63, 0x62, 0x62,
|
|
0x60, 0x63, 0x62, 0x61, 0x64, 0x61, 0x64, 0x63, 0x62, 0x66, 0x66, 0x63,
|
|
0x64, 0x5E, 0x60, 0x5F, 0x63, 0x62, 0x60, 0x63, 0x62, 0x60, 0x62, 0x62,
|
|
0x64, 0x66, 0x66, 0x63, 0x65, 0x61, 0x65, 0x61, 0x60, 0x61, 0x61, 0x64,
|
|
0x61, 0x63, 0x63, 0x61, 0x61, 0x5F, 0x61, 0x61, 0x5F, 0x62, 0x5E, 0x60,
|
|
0x5F, 0x5B, 0x5F, 0x61, 0x5E, 0x5F, 0x65, 0x60, 0x5A, 0x5B, 0x58, 0x59,
|
|
0x56, 0x53, 0x52, 0x50, 0x4E, 0x4B, 0x47, 0x51, 0x5A, 0x67, 0x6E, 0x77,
|
|
0x7B, 0x7F, 0x87, 0x87, 0x86, 0x84, 0x82, 0x83, 0x83, 0x83, 0x86, 0x87,
|
|
0x89, 0x88, 0x87, 0x84, 0x84, 0x83, 0x80, 0x80, 0x81, 0x84, 0x81, 0x81,
|
|
0x80, 0x81, 0x7F, 0x7F, 0x7F, 0x82, 0x80, 0x81, 0x84, 0x7C, 0x7E, 0x82,
|
|
0xA5, 0xC0, 0xCA, 0xCF, 0xD3, 0xD5, 0xD5, 0xD2, 0xBF, 0x96, 0x5C, 0x47,
|
|
0x4B, 0x4E, 0x50, 0x55, 0x55, 0x58, 0x57, 0x5A, 0x5D, 0x5A, 0x5C, 0x59,
|
|
0x5C, 0x55, 0x57, 0x5B, 0x60, 0x5B, 0x5B, 0x59, 0x5B, 0x5B, 0x5F, 0x5B,
|
|
0x5D, 0x5E, 0x5B, 0x5D, 0x5D, 0x5D, 0x65, 0x68, 0x63, 0x5A, 0x3A, 0x23,
|
|
0x19, 0x12, 0x17, 0x19, 0x83, 0x83, 0x81, 0x84, 0x82, 0x80, 0x82, 0x81,
|
|
0x81, 0x81, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x82, 0x86, 0x8C, 0x90, 0x91,
|
|
0x91, 0x92, 0x91, 0x92, 0x90, 0x8F, 0x87, 0x82, 0x72, 0x69, 0x5D, 0x4E,
|
|
0x42, 0x39, 0x37, 0x3E, 0x3A, 0x42, 0x44, 0x43, 0x46, 0x4B, 0x49, 0x4E,
|
|
0x4A, 0x49, 0x42, 0x48, 0x48, 0x44, 0x42, 0x45, 0x4C, 0x4D, 0x51, 0x51,
|
|
0x55, 0x56, 0x5A, 0x5C, 0x5E, 0x5C, 0x5C, 0x5F, 0x5D, 0x5C, 0x60, 0x60,
|
|
0x5C, 0x62, 0x62, 0x64, 0x63, 0x61, 0x61, 0x60, 0x61, 0x61, 0x60, 0x63,
|
|
0x61, 0x61, 0x65, 0x62, 0x62, 0x65, 0x65, 0x65, 0x61, 0x62, 0x64, 0x65,
|
|
0x66, 0x63, 0x64, 0x5F, 0x5F, 0x62, 0x65, 0x64, 0x64, 0x63, 0x62, 0x65,
|
|
0x63, 0x64, 0x65, 0x62, 0x65, 0x60, 0x63, 0x60, 0x61, 0x66, 0x61, 0x64,
|
|
0x5F, 0x60, 0x63, 0x62, 0x64, 0x67, 0x66, 0x67, 0x66, 0x61, 0x65, 0x64,
|
|
0x60, 0x65, 0x61, 0x62, 0x61, 0x60, 0x64, 0x5F, 0x63, 0x61, 0x60, 0x5F,
|
|
0x5F, 0x5E, 0x5D, 0x60, 0x61, 0x5D, 0x60, 0x61, 0x60, 0x60, 0x62, 0x5F,
|
|
0x59, 0x5D, 0x5B, 0x5A, 0x57, 0x54, 0x51, 0x56, 0x4E, 0x4E, 0x48, 0x4C,
|
|
0x55, 0x60, 0x6E, 0x75, 0x79, 0x7D, 0x84, 0x87, 0x89, 0x89, 0x87, 0x85,
|
|
0x84, 0x86, 0x87, 0x8A, 0x89, 0x8A, 0x8A, 0x85, 0x82, 0x84, 0x82, 0x81,
|
|
0x83, 0x83, 0x7D, 0x80, 0x80, 0x7E, 0x7F, 0x7C, 0x7E, 0x7F, 0x80, 0x80,
|
|
0x7F, 0x80, 0x7F, 0x7B, 0x8D, 0xB5, 0xC5, 0xCC, 0xD2, 0xD4, 0xD5, 0xD6,
|
|
0xCC, 0xB4, 0x7F, 0x4E, 0x4C, 0x4B, 0x4F, 0x51, 0x56, 0x55, 0x54, 0x59,
|
|
0x5C, 0x59, 0x5D, 0x59, 0x5B, 0x57, 0x57, 0x5D, 0x5D, 0x58, 0x5D, 0x5D,
|
|
0x5A, 0x5F, 0x61, 0x5D, 0x5F, 0x5E, 0x5D, 0x60, 0x60, 0x63, 0x69, 0x62,
|
|
0x50, 0x38, 0x1D, 0x1A, 0x1C, 0x17, 0x19, 0x18, 0x81, 0x82, 0x83, 0x82,
|
|
0x81, 0x7E, 0x83, 0x83, 0x80, 0x82, 0x82, 0x80, 0x80, 0x7D, 0x80, 0x88,
|
|
0x8A, 0x8D, 0x93, 0x8F, 0x91, 0x91, 0x90, 0x8F, 0x90, 0x8C, 0x84, 0x81,
|
|
0x71, 0x69, 0x5E, 0x4B, 0x40, 0x3A, 0x38, 0x3B, 0x3B, 0x45, 0x44, 0x3E,
|
|
0x46, 0x4B, 0x4A, 0x4B, 0x45, 0x47, 0x45, 0x49, 0x44, 0x45, 0x42, 0x47,
|
|
0x4A, 0x4F, 0x52, 0x51, 0x53, 0x57, 0x59, 0x5D, 0x5B, 0x5E, 0x5A, 0x60,
|
|
0x5F, 0x5F, 0x5F, 0x61, 0x5C, 0x61, 0x64, 0x63, 0x62, 0x60, 0x62, 0x62,
|
|
0x63, 0x60, 0x61, 0x60, 0x64, 0x64, 0x66, 0x63, 0x61, 0x68, 0x65, 0x65,
|
|
0x63, 0x66, 0x65, 0x63, 0x65, 0x63, 0x64, 0x61, 0x60, 0x60, 0x62, 0x66,
|
|
0x64, 0x61, 0x63, 0x65, 0x64, 0x62, 0x66, 0x60, 0x67, 0x63, 0x61, 0x5E,
|
|
0x5D, 0x66, 0x65, 0x63, 0x60, 0x60, 0x61, 0x62, 0x66, 0x68, 0x66, 0x6B,
|
|
0x65, 0x62, 0x65, 0x63, 0x63, 0x64, 0x63, 0x62, 0x60, 0x61, 0x62, 0x5D,
|
|
0x62, 0x62, 0x61, 0x5E, 0x5F, 0x5A, 0x5E, 0x5E, 0x61, 0x60, 0x62, 0x60,
|
|
0x62, 0x5E, 0x5F, 0x60, 0x5E, 0x5F, 0x59, 0x5B, 0x56, 0x54, 0x51, 0x59,
|
|
0x4E, 0x4E, 0x49, 0x47, 0x52, 0x5B, 0x6B, 0x72, 0x76, 0x7C, 0x82, 0x86,
|
|
0x87, 0x8E, 0x89, 0x85, 0x85, 0x87, 0x88, 0x8D, 0x89, 0x89, 0x8A, 0x89,
|
|
0x82, 0x84, 0x85, 0x86, 0x86, 0x80, 0x7E, 0x7E, 0x7E, 0x7F, 0x81, 0x7D,
|
|
0x7F, 0x7C, 0x7E, 0x7D, 0x7E, 0x80, 0x7D, 0x7C, 0x7B, 0x9F, 0xBD, 0xC9,
|
|
0xD0, 0xD3, 0xD5, 0xD6, 0xD3, 0xC6, 0xA3, 0x64, 0x4C, 0x47, 0x50, 0x4D,
|
|
0x58, 0x53, 0x52, 0x58, 0x59, 0x5A, 0x5C, 0x59, 0x5B, 0x5E, 0x58, 0x5E,
|
|
0x5B, 0x5D, 0x5F, 0x5C, 0x5B, 0x60, 0x63, 0x5F, 0x62, 0x62, 0x60, 0x64,
|
|
0x65, 0x68, 0x63, 0x4F, 0x30, 0x17, 0x14, 0x13, 0x17, 0x1A, 0x15, 0x17,
|
|
0x82, 0x83, 0x83, 0x80, 0x82, 0x7F, 0x83, 0x86, 0x83, 0x86, 0x81, 0x81,
|
|
0x80, 0x7F, 0x85, 0x88, 0x8C, 0x8F, 0x92, 0x8E, 0x93, 0x8F, 0x8E, 0x8B,
|
|
0x8E, 0x8A, 0x85, 0x7E, 0x71, 0x68, 0x5E, 0x4F, 0x42, 0x3E, 0x38, 0x39,
|
|
0x3D, 0x45, 0x42, 0x42, 0x44, 0x47, 0x4B, 0x49, 0x45, 0x46, 0x47, 0x46,
|
|
0x42, 0x45, 0x44, 0x48, 0x4A, 0x50, 0x52, 0x51, 0x55, 0x54, 0x57, 0x5A,
|
|
0x5A, 0x5D, 0x57, 0x5F, 0x5E, 0x60, 0x5D, 0x61, 0x5E, 0x61, 0x64, 0x62,
|
|
0x60, 0x62, 0x62, 0x63, 0x63, 0x62, 0x62, 0x61, 0x63, 0x62, 0x65, 0x63,
|
|
0x60, 0x65, 0x64, 0x63, 0x64, 0x66, 0x64, 0x61, 0x62, 0x64, 0x63, 0x63,
|
|
0x63, 0x5F, 0x61, 0x67, 0x62, 0x61, 0x64, 0x63, 0x63, 0x62, 0x65, 0x61,
|
|
0x68, 0x61, 0x63, 0x61, 0x5D, 0x65, 0x68, 0x62, 0x60, 0x5E, 0x5E, 0x63,
|
|
0x67, 0x69, 0x68, 0x69, 0x69, 0x64, 0x65, 0x64, 0x65, 0x61, 0x64, 0x64,
|
|
0x64, 0x62, 0x62, 0x5C, 0x60, 0x62, 0x63, 0x61, 0x61, 0x5B, 0x5C, 0x5C,
|
|
0x60, 0x60, 0x61, 0x5F, 0x63, 0x5B, 0x5D, 0x60, 0x61, 0x5F, 0x5B, 0x5C,
|
|
0x5A, 0x53, 0x52, 0x56, 0x4E, 0x4C, 0x48, 0x44, 0x4E, 0x5A, 0x65, 0x6F,
|
|
0x74, 0x7C, 0x81, 0x85, 0x85, 0x8E, 0x88, 0x87, 0x88, 0x87, 0x88, 0x8E,
|
|
0x89, 0x8A, 0x8A, 0x8B, 0x86, 0x83, 0x84, 0x87, 0x86, 0x83, 0x80, 0x7F,
|
|
0x7F, 0x81, 0x80, 0x7F, 0x7F, 0x7E, 0x7E, 0x7F, 0x80, 0x7D, 0x7C, 0x7C,
|
|
0x78, 0x84, 0xAD, 0xC3, 0xCC, 0xD2, 0xD4, 0xD6, 0xD6, 0xCF, 0xB9, 0x87,
|
|
0x54, 0x47, 0x51, 0x4D, 0x56, 0x53, 0x54, 0x59, 0x57, 0x5B, 0x5E, 0x5B,
|
|
0x5E, 0x61, 0x5A, 0x5E, 0x5A, 0x63, 0x5D, 0x5D, 0x5F, 0x5E, 0x62, 0x5F,
|
|
0x62, 0x65, 0x63, 0x68, 0x6A, 0x63, 0x4D, 0x33, 0x17, 0x12, 0x1B, 0x11,
|
|
0x16, 0x18, 0x14, 0x16, 0x84, 0x83, 0x82, 0x7F, 0x83, 0x81, 0x82, 0x86,
|
|
0x86, 0x85, 0x80, 0x83, 0x7E, 0x80, 0x85, 0x86, 0x8C, 0x90, 0x8F, 0x8E,
|
|
0x93, 0x8C, 0x8C, 0x8B, 0x88, 0x88, 0x84, 0x7C, 0x74, 0x68, 0x62, 0x5B,
|
|
0x45, 0x3F, 0x38, 0x3A, 0x3F, 0x42, 0x41, 0x45, 0x4D, 0x46, 0x49, 0x48,
|
|
0x44, 0x47, 0x45, 0x43, 0x47, 0x46, 0x45, 0x45, 0x4B, 0x51, 0x50, 0x52,
|
|
0x57, 0x54, 0x55, 0x57, 0x59, 0x5B, 0x57, 0x5E, 0x5B, 0x5E, 0x5E, 0x60,
|
|
0x61, 0x60, 0x63, 0x61, 0x5E, 0x63, 0x61, 0x63, 0x62, 0x63, 0x63, 0x62,
|
|
0x61, 0x61, 0x63, 0x64, 0x60, 0x60, 0x64, 0x61, 0x63, 0x61, 0x63, 0x61,
|
|
0x61, 0x61, 0x63, 0x62, 0x64, 0x60, 0x61, 0x64, 0x60, 0x61, 0x61, 0x62,
|
|
0x63, 0x60, 0x61, 0x62, 0x65, 0x5F, 0x66, 0x63, 0x61, 0x63, 0x65, 0x62,
|
|
0x5E, 0x5E, 0x5F, 0x62, 0x65, 0x66, 0x67, 0x67, 0x6D, 0x64, 0x62, 0x63,
|
|
0x65, 0x61, 0x62, 0x62, 0x69, 0x61, 0x64, 0x5C, 0x5F, 0x61, 0x61, 0x60,
|
|
0x61, 0x5C, 0x5B, 0x5E, 0x60, 0x5F, 0x60, 0x60, 0x60, 0x5B, 0x5E, 0x5E,
|
|
0x60, 0x5C, 0x5D, 0x5C, 0x60, 0x57, 0x53, 0x53, 0x4E, 0x4D, 0x49, 0x44,
|
|
0x4C, 0x55, 0x61, 0x6C, 0x74, 0x7B, 0x80, 0x84, 0x86, 0x8B, 0x89, 0x89,
|
|
0x89, 0x87, 0x87, 0x8D, 0x89, 0x8C, 0x89, 0x8A, 0x89, 0x83, 0x83, 0x83,
|
|
0x85, 0x86, 0x7F, 0x81, 0x80, 0x82, 0x7E, 0x7F, 0x7D, 0x80, 0x7F, 0x81,
|
|
0x7F, 0x7C, 0x7D, 0x7B, 0x7B, 0x76, 0x95, 0xBA, 0xC7, 0xD0, 0xD2, 0xD5,
|
|
0xD7, 0xD4, 0xC8, 0xAA, 0x70, 0x48, 0x4F, 0x4D, 0x54, 0x52, 0x55, 0x58,
|
|
0x56, 0x59, 0x5A, 0x5C, 0x5F, 0x5E, 0x59, 0x5D, 0x5A, 0x5D, 0x5D, 0x62,
|
|
0x63, 0x61, 0x61, 0x62, 0x63, 0x66, 0x68, 0x6D, 0x65, 0x4A, 0x31, 0x1C,
|
|
0x12, 0x1B, 0x22, 0x16, 0x1B, 0x16, 0x16, 0x18, 0x84, 0x83, 0x7E, 0x82,
|
|
0x83, 0x81, 0x82, 0x85, 0x87, 0x84, 0x83, 0x84, 0x7D, 0x80, 0x83, 0x88,
|
|
0x8E, 0x90, 0x90, 0x8C, 0x8F, 0x8D, 0x8C, 0x88, 0x85, 0x86, 0x83, 0x7C,
|
|
0x78, 0x6A, 0x63, 0x5A, 0x43, 0x3A, 0x39, 0x3D, 0x3F, 0x3E, 0x42, 0x43,
|
|
0x57, 0x45, 0x48, 0x44, 0x43, 0x4B, 0x43, 0x44, 0x48, 0x46, 0x46, 0x46,
|
|
0x4C, 0x52, 0x4D, 0x52, 0x56, 0x59, 0x55, 0x58, 0x57, 0x5A, 0x5B, 0x5B,
|
|
0x5D, 0x5C, 0x5D, 0x60, 0x63, 0x62, 0x60, 0x61, 0x60, 0x5F, 0x62, 0x63,
|
|
0x5F, 0x60, 0x62, 0x62, 0x61, 0x61, 0x63, 0x64, 0x61, 0x60, 0x64, 0x63,
|
|
0x62, 0x60, 0x64, 0x63, 0x60, 0x5F, 0x63, 0x62, 0x61, 0x64, 0x5E, 0x61,
|
|
0x60, 0x60, 0x5E, 0x62, 0x60, 0x5F, 0x60, 0x60, 0x61, 0x5F, 0x61, 0x61,
|
|
0x61, 0x61, 0x61, 0x61, 0x5D, 0x60, 0x5E, 0x5F, 0x63, 0x62, 0x66, 0x66,
|
|
0x69, 0x64, 0x61, 0x62, 0x64, 0x62, 0x63, 0x61, 0x65, 0x61, 0x60, 0x5F,
|
|
0x5E, 0x63, 0x5E, 0x5D, 0x5D, 0x5D, 0x5B, 0x60, 0x5F, 0x5F, 0x5D, 0x5F,
|
|
0x5B, 0x5B, 0x5F, 0x5E, 0x5D, 0x5A, 0x5C, 0x5B, 0x5C, 0x58, 0x52, 0x51,
|
|
0x4E, 0x51, 0x4A, 0x47, 0x4D, 0x51, 0x5E, 0x69, 0x74, 0x7B, 0x7E, 0x82,
|
|
0x86, 0x89, 0x8B, 0x89, 0x88, 0x8A, 0x86, 0x88, 0x88, 0x8C, 0x88, 0x89,
|
|
0x89, 0x88, 0x85, 0x7F, 0x83, 0x84, 0x80, 0x80, 0x80, 0x81, 0x7C, 0x7E,
|
|
0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7B, 0x7D, 0x7C, 0x78, 0x74, 0x7F, 0xA8,
|
|
0xC1, 0xCB, 0xD1, 0xD4, 0xD6, 0xD6, 0xD2, 0xC1, 0x94, 0x57, 0x49, 0x4C,
|
|
0x52, 0x53, 0x57, 0x5A, 0x57, 0x59, 0x53, 0x5A, 0x5E, 0x5C, 0x5A, 0x5A,
|
|
0x5A, 0x57, 0x60, 0x63, 0x65, 0x64, 0x63, 0x64, 0x66, 0x69, 0x6A, 0x67,
|
|
0x4E, 0x30, 0x1C, 0x12, 0x15, 0x19, 0x1F, 0x1A, 0x1A, 0x16, 0x1A, 0x1B,
|
|
0x81, 0x81, 0x7D, 0x83, 0x85, 0x81, 0x84, 0x84, 0x86, 0x83, 0x84, 0x83,
|
|
0x7E, 0x84, 0x86, 0x8B, 0x8F, 0x8F, 0x94, 0x8D, 0x8D, 0x8B, 0x8C, 0x85,
|
|
0x85, 0x85, 0x84, 0x7D, 0x79, 0x6B, 0x5C, 0x4F, 0x3F, 0x36, 0x36, 0x3A,
|
|
0x3E, 0x3B, 0x43, 0x44, 0x4E, 0x45, 0x47, 0x42, 0x45, 0x4B, 0x44, 0x44,
|
|
0x48, 0x44, 0x46, 0x4A, 0x4B, 0x4F, 0x4D, 0x50, 0x56, 0x5A, 0x57, 0x59,
|
|
0x56, 0x58, 0x5E, 0x5C, 0x5F, 0x5F, 0x5C, 0x5F, 0x5D, 0x65, 0x5D, 0x62,
|
|
0x5F, 0x5C, 0x61, 0x60, 0x5F, 0x5E, 0x61, 0x62, 0x61, 0x61, 0x63, 0x60,
|
|
0x5F, 0x61, 0x63, 0x63, 0x61, 0x61, 0x64, 0x62, 0x60, 0x61, 0x66, 0x63,
|
|
0x62, 0x64, 0x5E, 0x61, 0x60, 0x5F, 0x5C, 0x5F, 0x5C, 0x60, 0x5E, 0x5D,
|
|
0x5E, 0x5E, 0x5B, 0x5F, 0x60, 0x5D, 0x5E, 0x60, 0x5E, 0x60, 0x5B, 0x5E,
|
|
0x61, 0x60, 0x63, 0x64, 0x64, 0x65, 0x63, 0x61, 0x63, 0x61, 0x64, 0x64,
|
|
0x60, 0x62, 0x5C, 0x5F, 0x5D, 0x63, 0x5E, 0x5C, 0x5D, 0x5D, 0x5B, 0x5F,
|
|
0x5E, 0x60, 0x5D, 0x5D, 0x5B, 0x5D, 0x5E, 0x5E, 0x5C, 0x5B, 0x5D, 0x59,
|
|
0x5A, 0x58, 0x52, 0x4D, 0x4F, 0x4F, 0x4A, 0x4B, 0x50, 0x54, 0x5C, 0x66,
|
|
0x71, 0x79, 0x7C, 0x83, 0x85, 0x89, 0x8B, 0x8A, 0x87, 0x8D, 0x86, 0x84,
|
|
0x87, 0x89, 0x88, 0x88, 0x87, 0x89, 0x86, 0x81, 0x83, 0x84, 0x82, 0x80,
|
|
0x82, 0x80, 0x7C, 0x7D, 0x7F, 0x7D, 0x7D, 0x7C, 0x7F, 0x7C, 0x7C, 0x7D,
|
|
0x78, 0x75, 0x75, 0x91, 0xB7, 0xC7, 0xCF, 0xD4, 0xD5, 0xD6, 0xD7, 0xCE,
|
|
0xB2, 0x7C, 0x4A, 0x4A, 0x4F, 0x53, 0x58, 0x5B, 0x5B, 0x5C, 0x57, 0x59,
|
|
0x5E, 0x5C, 0x5A, 0x58, 0x59, 0x5B, 0x5E, 0x60, 0x61, 0x62, 0x63, 0x64,
|
|
0x69, 0x6B, 0x63, 0x50, 0x2B, 0x27, 0x19, 0x11, 0x13, 0x15, 0x15, 0x17,
|
|
0x14, 0x18, 0x1E, 0x1A, 0x7F, 0x7F, 0x81, 0x82, 0x84, 0x82, 0x85, 0x83,
|
|
0x83, 0x83, 0x85, 0x82, 0x81, 0x89, 0x8A, 0x8D, 0x8F, 0x90, 0x92, 0x8E,
|
|
0x8A, 0x87, 0x89, 0x85, 0x87, 0x87, 0x85, 0x7D, 0x78, 0x6C, 0x58, 0x4B,
|
|
0x3B, 0x33, 0x30, 0x36, 0x3E, 0x3D, 0x43, 0x46, 0x43, 0x46, 0x46, 0x45,
|
|
0x48, 0x47, 0x46, 0x44, 0x49, 0x42, 0x46, 0x4A, 0x4B, 0x4B, 0x4F, 0x4F,
|
|
0x56, 0x5B, 0x57, 0x58, 0x57, 0x5A, 0x5B, 0x5E, 0x5F, 0x61, 0x5C, 0x5E,
|
|
0x5D, 0x61, 0x5E, 0x62, 0x5D, 0x5E, 0x5F, 0x5E, 0x61, 0x61, 0x60, 0x62,
|
|
0x61, 0x61, 0x60, 0x5F, 0x5D, 0x60, 0x5F, 0x61, 0x61, 0x60, 0x62, 0x5E,
|
|
0x60, 0x64, 0x65, 0x63, 0x66, 0x65, 0x65, 0x60, 0x5F, 0x5C, 0x59, 0x5B,
|
|
0x5B, 0x5D, 0x59, 0x5C, 0x5B, 0x5D, 0x5E, 0x5F, 0x5F, 0x5A, 0x5C, 0x5E,
|
|
0x5E, 0x5F, 0x5A, 0x60, 0x5D, 0x5F, 0x5F, 0x63, 0x62, 0x64, 0x63, 0x61,
|
|
0x61, 0x63, 0x64, 0x66, 0x60, 0x61, 0x5E, 0x5D, 0x5D, 0x5F, 0x5E, 0x5D,
|
|
0x60, 0x5C, 0x5D, 0x5F, 0x5D, 0x5E, 0x5E, 0x5D, 0x5C, 0x60, 0x5E, 0x5D,
|
|
0x5D, 0x5B, 0x5C, 0x59, 0x5C, 0x5B, 0x53, 0x4E, 0x50, 0x4A, 0x48, 0x4B,
|
|
0x50, 0x56, 0x5C, 0x63, 0x6E, 0x74, 0x7E, 0x83, 0x84, 0x88, 0x8B, 0x89,
|
|
0x89, 0x8B, 0x85, 0x85, 0x87, 0x86, 0x88, 0x85, 0x86, 0x87, 0x86, 0x85,
|
|
0x82, 0x84, 0x82, 0x81, 0x83, 0x80, 0x7F, 0x7E, 0x7D, 0x7F, 0x7F, 0x7C,
|
|
0x7F, 0x7C, 0x7E, 0x7D, 0x7A, 0x78, 0x75, 0x7C, 0xA4, 0xC2, 0xCC, 0xD3,
|
|
0xD4, 0xD7, 0xD9, 0xD5, 0xC7, 0xA2, 0x60, 0x46, 0x4E, 0x50, 0x54, 0x57,
|
|
0x5C, 0x5E, 0x5D, 0x5A, 0x5D, 0x5A, 0x5A, 0x59, 0x59, 0x5E, 0x5E, 0x5D,
|
|
0x5E, 0x61, 0x63, 0x67, 0x69, 0x64, 0x4C, 0x2D, 0x12, 0x1C, 0x1B, 0x10,
|
|
0x0E, 0x14, 0x11, 0x13, 0x12, 0x1B, 0x1D, 0x1A, 0x82, 0x81, 0x85, 0x82,
|
|
0x83, 0x82, 0x85, 0x85, 0x84, 0x84, 0x87, 0x85, 0x84, 0x8C, 0x8C, 0x90,
|
|
0x91, 0x91, 0x8E, 0x8E, 0x87, 0x84, 0x85, 0x85, 0x86, 0x89, 0x86, 0x7F,
|
|
0x76, 0x69, 0x59, 0x4D, 0x3A, 0x35, 0x31, 0x36, 0x3F, 0x40, 0x42, 0x45,
|
|
0x45, 0x46, 0x49, 0x44, 0x49, 0x47, 0x48, 0x44, 0x47, 0x43, 0x46, 0x49,
|
|
0x4B, 0x4B, 0x50, 0x52, 0x54, 0x5A, 0x58, 0x58, 0x59, 0x5E, 0x5B, 0x5C,
|
|
0x5F, 0x5E, 0x5B, 0x5D, 0x62, 0x5F, 0x5F, 0x5F, 0x5D, 0x5E, 0x60, 0x5F,
|
|
0x63, 0x63, 0x5E, 0x62, 0x61, 0x60, 0x5E, 0x61, 0x60, 0x60, 0x5E, 0x62,
|
|
0x62, 0x5F, 0x5F, 0x5C, 0x60, 0x61, 0x60, 0x65, 0x67, 0x68, 0x68, 0x61,
|
|
0x5F, 0x5A, 0x58, 0x5A, 0x5A, 0x58, 0x57, 0x59, 0x5A, 0x5D, 0x5F, 0x60,
|
|
0x5D, 0x5C, 0x5C, 0x5C, 0x5B, 0x5D, 0x5C, 0x5F, 0x5E, 0x5F, 0x60, 0x60,
|
|
0x61, 0x62, 0x63, 0x65, 0x62, 0x64, 0x64, 0x64, 0x61, 0x60, 0x60, 0x5C,
|
|
0x5E, 0x5F, 0x5E, 0x60, 0x5E, 0x5D, 0x5C, 0x5E, 0x5D, 0x5B, 0x5D, 0x5D,
|
|
0x5B, 0x61, 0x5F, 0x5C, 0x5F, 0x5C, 0x5B, 0x5B, 0x57, 0x59, 0x56, 0x52,
|
|
0x50, 0x4C, 0x49, 0x4B, 0x4E, 0x55, 0x5E, 0x65, 0x6D, 0x73, 0x7F, 0x81,
|
|
0x85, 0x85, 0x8A, 0x89, 0x8A, 0x88, 0x86, 0x86, 0x88, 0x84, 0x89, 0x83,
|
|
0x88, 0x84, 0x84, 0x84, 0x82, 0x82, 0x82, 0x81, 0x83, 0x80, 0x80, 0x7F,
|
|
0x7F, 0x85, 0x80, 0x7E, 0x7D, 0x7D, 0x7E, 0x7D, 0x79, 0x79, 0x77, 0x73,
|
|
0x8B, 0xB6, 0xC7, 0xD0, 0xD3, 0xD5, 0xD8, 0xD8, 0xD2, 0xBC, 0x86, 0x4A,
|
|
0x48, 0x50, 0x52, 0x56, 0x58, 0x5A, 0x58, 0x5C, 0x5C, 0x59, 0x5B, 0x5B,
|
|
0x5A, 0x5E, 0x5E, 0x5E, 0x5F, 0x64, 0x66, 0x69, 0x62, 0x49, 0x27, 0x13,
|
|
0x0D, 0x14, 0x18, 0x10, 0x12, 0x12, 0x12, 0x14, 0x14, 0x1C, 0x19, 0x21,
|
|
0x82, 0x83, 0x86, 0x83, 0x83, 0x84, 0x84, 0x86, 0x86, 0x85, 0x85, 0x89,
|
|
0x8A, 0x8F, 0x8F, 0x91, 0x92, 0x8F, 0x8E, 0x8D, 0x86, 0x85, 0x84, 0x84,
|
|
0x85, 0x8A, 0x88, 0x83, 0x76, 0x69, 0x5E, 0x4E, 0x3D, 0x39, 0x34, 0x38,
|
|
0x3F, 0x40, 0x42, 0x45, 0x48, 0x47, 0x4C, 0x45, 0x4B, 0x49, 0x46, 0x44,
|
|
0x46, 0x43, 0x45, 0x48, 0x4A, 0x4A, 0x4F, 0x51, 0x53, 0x55, 0x59, 0x59,
|
|
0x5A, 0x5D, 0x5B, 0x59, 0x5F, 0x5C, 0x5D, 0x5C, 0x61, 0x61, 0x5F, 0x5D,
|
|
0x5D, 0x5B, 0x5F, 0x60, 0x61, 0x62, 0x5E, 0x60, 0x60, 0x60, 0x5F, 0x61,
|
|
0x61, 0x61, 0x60, 0x61, 0x61, 0x5F, 0x60, 0x5E, 0x61, 0x5C, 0x60, 0x65,
|
|
0x65, 0x64, 0x65, 0x62, 0x60, 0x5F, 0x5B, 0x58, 0x59, 0x55, 0x59, 0x57,
|
|
0x5B, 0x5A, 0x5C, 0x5F, 0x5E, 0x5C, 0x5C, 0x5D, 0x5D, 0x5A, 0x5C, 0x5D,
|
|
0x5E, 0x5F, 0x64, 0x5E, 0x60, 0x62, 0x61, 0x65, 0x67, 0x62, 0x64, 0x60,
|
|
0x60, 0x5D, 0x5F, 0x5E, 0x60, 0x61, 0x60, 0x60, 0x61, 0x5E, 0x58, 0x5E,
|
|
0x5C, 0x5A, 0x5D, 0x5B, 0x5B, 0x60, 0x5E, 0x5F, 0x5F, 0x61, 0x5A, 0x59,
|
|
0x55, 0x55, 0x57, 0x54, 0x4F, 0x4D, 0x4B, 0x4A, 0x4A, 0x55, 0x5F, 0x66,
|
|
0x6A, 0x74, 0x7B, 0x7D, 0x84, 0x84, 0x86, 0x89, 0x88, 0x87, 0x86, 0x84,
|
|
0x88, 0x82, 0x88, 0x84, 0x88, 0x84, 0x83, 0x83, 0x83, 0x82, 0x81, 0x81,
|
|
0x84, 0x81, 0x7F, 0x7F, 0x82, 0x88, 0x81, 0x83, 0x7D, 0x7F, 0x7D, 0x7D,
|
|
0x7A, 0x7A, 0x77, 0x72, 0x79, 0x9D, 0xBB, 0xCA, 0xD0, 0xD4, 0xD7, 0xD8,
|
|
0xD8, 0xCD, 0xAE, 0x6D, 0x49, 0x50, 0x50, 0x57, 0x55, 0x58, 0x54, 0x5B,
|
|
0x59, 0x5B, 0x5C, 0x5C, 0x5E, 0x5D, 0x5C, 0x61, 0x62, 0x66, 0x67, 0x65,
|
|
0x51, 0x27, 0x10, 0x0D, 0x15, 0x14, 0x15, 0x10, 0x16, 0x13, 0x15, 0x17,
|
|
0x17, 0x18, 0x19, 0x23};
|
|
|
|
/*
|
|
Macro definitions
|
|
*/
|
|
|
|
#define abs(x) (x >= 0 ? x : -(x))
|
|
#define FILTER 0
|
|
#define EXPAND 1
|
|
#define IS ==
|
|
#define ISNT !=
|
|
#define AND &&
|
|
#define OR ||
|
|
|
|
#define NUM_LEVELS 4
|
|
|
|
/*
|
|
Forward declaration of functions
|
|
*/
|
|
|
|
__attribute__((always_inline)) static inline void epic_init(void);
|
|
__attribute__((always_inline)) static inline void
|
|
epic_build_pyr(float *image, int x_size, int y_size, int num_levels,
|
|
float *lo_filter, float *hi_filter, int filter_size);
|
|
__attribute__((always_inline)) static inline void
|
|
epic_build_level(float *image, int level_x_size, int level_y_size,
|
|
float *lo_filter, float *hi_filter, int filter_size,
|
|
float *result_block);
|
|
__attribute__((always_inline)) static inline void
|
|
epic_internal_transpose(float *mat, int rows, int cols);
|
|
__attribute__((always_inline)) static inline void
|
|
epic_internal_filter(float *image, int x_dim, int y_dim, float *filt,
|
|
float *temp, int x_fdim, int y_fdim, int xgrid_start,
|
|
int xgrid_step, int ygrid_start, int ygrid_step,
|
|
float *result);
|
|
__attribute__((always_inline)) static inline void
|
|
epic_reflect1(float *filt, int x_dim, int y_dim, int x_pos, int y_pos,
|
|
float *result, int f_or_e);
|
|
__attribute__((noinline)) __attribute__((export_name("entrypoint")))
|
|
__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
|
|
epic_main(void);
|
|
__attribute__((noinline)) __attribute__((export_name("main")))
|
|
__attribute__((noinline)) __attribute__((export_name("main"))) int
|
|
main(void);
|
|
|
|
/*
|
|
Declaration of global variables
|
|
*/
|
|
|
|
float epic_filtertemp[FILTER_SIZE];
|
|
float epic_hi_imagetemp[X_SIZE * Y_SIZE / 2];
|
|
float epic_lo_imagetemp[X_SIZE * Y_SIZE / 2];
|
|
|
|
static float epic_lo_filter[FILTER_SIZE] = {
|
|
-0.0012475221, -0.0024950907, 0.0087309530, 0.0199579580, -0.0505290000,
|
|
-0.1205509700, 0.2930455800, 0.7061761600, 0.2930455800, -0.1205509700,
|
|
-0.0505290000, 0.0199579580, 0.0087309530, -0.0024950907, -0.0012475221};
|
|
|
|
static float epic_hi_filter[FILTER_SIZE] = {
|
|
0.0012475221, -0.0024950907, -0.0087309530, 0.0199579580, 0.0505290000,
|
|
-0.1205509700, -0.2930455800, 0.7061761600, -0.2930455800, -0.1205509700,
|
|
0.0505290000, 0.0199579580, -0.0087309530, -0.0024950907, 0.0012475221};
|
|
|
|
/*
|
|
Initialization function
|
|
*/
|
|
|
|
__attribute__((always_inline)) static inline void
|
|
epic_init(void) {
|
|
int i;
|
|
|
|
__pragma_loopbound(4096, 4096);
|
|
for (i = 0; i < X_SIZE * Y_SIZE; ++i)
|
|
epic_image[i] *= SCALE_FACTOR;
|
|
}
|
|
|
|
/*
|
|
Algorithm core functions
|
|
*/
|
|
|
|
/*
|
|
======================================================================
|
|
epic_build_pyr() -- builds a separable QMF-style pyramid. The pyramid
|
|
is written over the original image. NOTE: the image size must be
|
|
divisible by 2^num_levels, but we do not check this here.
|
|
======================================================================
|
|
*/
|
|
__attribute__((always_inline)) static inline void
|
|
epic_build_pyr(float *image, int x_size, int y_size, int num_levels,
|
|
float *lo_filter, float *hi_filter, int filter_size) {
|
|
int x_level, y_level, level;
|
|
|
|
x_level = x_size;
|
|
y_level = y_size;
|
|
|
|
__pragma_loopbound(4, 4);
|
|
for (level = 0; level < num_levels; ++level) {
|
|
epic_build_level(image, x_level, y_level, lo_filter, hi_filter,
|
|
filter_size, image);
|
|
x_level /= 2;
|
|
y_level /= 2;
|
|
}
|
|
}
|
|
|
|
/*
|
|
======================================================================
|
|
epic_build_level() -- builds a level of the pyramid by computing 4
|
|
filtered and subsampled images. Since the convolution is separable,
|
|
image and result-block can point to the same place! Image order is
|
|
lowpass, horizontal, vertical (transposed), and diagonal.
|
|
======================================================================
|
|
*/
|
|
__attribute__((always_inline)) static inline void
|
|
epic_build_level(float *image, int level_x_size, int level_y_size,
|
|
float *lo_filter, float *hi_filter, int filter_size,
|
|
float *result_block) {
|
|
int total_size = level_x_size * level_y_size;
|
|
|
|
/* filter and subsample in the X direction */
|
|
epic_internal_filter(image, level_x_size, level_y_size, lo_filter,
|
|
epic_filtertemp, filter_size, 1, 0, 2, 0, 1,
|
|
epic_lo_imagetemp);
|
|
epic_internal_filter(image, level_x_size, level_y_size, hi_filter,
|
|
epic_filtertemp, filter_size, 1, 1, 2, 0, 1,
|
|
epic_hi_imagetemp);
|
|
|
|
level_x_size /= 2;
|
|
/* now filter and subsample in the Y direction */
|
|
epic_internal_filter(
|
|
epic_lo_imagetemp, level_x_size, level_y_size, /* lowpass */
|
|
lo_filter, epic_filtertemp, 1, filter_size, 0, 1, 0, 2, result_block);
|
|
epic_internal_filter(epic_lo_imagetemp, level_x_size,
|
|
level_y_size, /* horizontal */
|
|
hi_filter, epic_filtertemp, 1, filter_size, 0, 1, 1, 2,
|
|
(result_block += (total_size / 4)));
|
|
epic_internal_filter(epic_hi_imagetemp, level_x_size,
|
|
level_y_size, /* vertical */
|
|
lo_filter, epic_filtertemp, 1, filter_size, 0, 1, 0, 2,
|
|
(result_block += (total_size / 4)));
|
|
/* transpose the vertical band for more efficient scanning */
|
|
epic_internal_transpose(result_block, level_y_size / 2, level_x_size);
|
|
epic_internal_filter(epic_hi_imagetemp, level_x_size,
|
|
level_y_size, /* diagonal */
|
|
hi_filter, epic_filtertemp, 1, filter_size, 0, 1, 1, 2,
|
|
(result_block += (total_size / 4)));
|
|
}
|
|
|
|
/*
|
|
======================================================================
|
|
In-place matrix tranpose algorithm. Handles non-square matrices,
|
|
too! Is there a faster algorithm??
|
|
======================================================================
|
|
*/
|
|
__attribute__((always_inline)) static inline void
|
|
epic_internal_transpose(float *mat, int rows, int cols) {
|
|
register int swap_pos;
|
|
register int modulus = rows * cols - 1;
|
|
register int current_pos;
|
|
register float swap_val;
|
|
|
|
/* loop, ignoring first and last elements */
|
|
__pragma_loopbound(14, 2399);
|
|
for (current_pos = 1; current_pos < modulus; ++current_pos) {
|
|
/* Compute swap position */
|
|
swap_pos = current_pos;
|
|
|
|
__pragma_loopbound(1, 2);
|
|
do {
|
|
swap_pos = (swap_pos * cols) % modulus;
|
|
} while (swap_pos < current_pos);
|
|
|
|
if (current_pos != swap_pos) {
|
|
swap_val = mat[swap_pos];
|
|
mat[swap_pos] = mat[current_pos];
|
|
mat[current_pos] = swap_val;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------------------------------------------------------------
|
|
Correlate FILT with IMAGE, subsampling according to GRID parameters,
|
|
with values placed into result array. TEMP is a temporary
|
|
array the size of the filter. EDGES is a string -- see convolve.h.
|
|
The convolution is done in 9 sections, where the border sections use
|
|
specially computed edge-handling filters (see edges.c). The origin
|
|
of the filter is assumed to be (floor(x_fdim/2), floor(y_fdim/2)).
|
|
10/6/89 - approximately optimized the choice of register vars on SPARCS.
|
|
------------------------------------------------------------------------ */
|
|
__attribute__((always_inline)) static inline void
|
|
epic_internal_filter(float *image, int x_dim, int y_dim, float *filt,
|
|
float *temp, int x_fdim, int y_fdim, int xgrid_start,
|
|
int xgrid_step, int ygrid_start, int ygrid_step,
|
|
float *result) {
|
|
// register double sum;
|
|
register float sum;
|
|
register int x_filt, im_pos, y_filt_lin;
|
|
register int y_im_lin, x_pos, filt_size = x_fdim * y_fdim;
|
|
register int y_pos, res_pos;
|
|
register int last_ctr_col = x_dim - x_fdim;
|
|
int last_ctr_row = (y_dim - y_fdim) * x_dim;
|
|
int first_row, first_col;
|
|
int x_fmid = x_fdim / 2;
|
|
int y_fmid = y_fdim / 2;
|
|
int x_stop = x_fdim - x_fmid + 1;
|
|
int y_stop = y_fdim - y_fmid + 1;
|
|
int ygrid_step_full = ygrid_step * x_dim;
|
|
int prev_res_pos,
|
|
x_res_dim = (x_dim - xgrid_start + xgrid_step - 1) / xgrid_step;
|
|
int rt_edge_res_pos = x_res_dim;
|
|
|
|
res_pos = 0;
|
|
first_col = xgrid_start - x_fmid + xgrid_step;
|
|
|
|
__pragma_loopbound(1, 4);
|
|
for (y_pos = ygrid_start - y_fmid - 1; y_pos < 0; y_pos += ygrid_step) {
|
|
__pragma_loopbound(1, 4);
|
|
for (x_pos = xgrid_start - x_fmid; /* top-left corner */
|
|
x_pos < 0; x_pos += xgrid_step) {
|
|
epic_reflect1(filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER);
|
|
sum = 0.0f;
|
|
x_filt = y_im_lin = 0;
|
|
__pragma_loopbound(1, 15);
|
|
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
|
|
y_filt_lin += x_fdim) {
|
|
im_pos = y_im_lin;
|
|
|
|
__pragma_loopbound(1, 15);
|
|
for (; x_filt < y_filt_lin; ++x_filt) {
|
|
sum += image[im_pos] * temp[x_filt];
|
|
++im_pos;
|
|
}
|
|
y_im_lin += x_dim;
|
|
}
|
|
result[res_pos] = sum;
|
|
++res_pos;
|
|
}
|
|
first_col = x_pos + 1;
|
|
epic_reflect1(filt, x_fdim, y_fdim, 0, y_pos, temp, FILTER);
|
|
__pragma_loopbound(41, 46);
|
|
for (x_pos = first_col; /* top edge */
|
|
x_pos < last_ctr_col; x_pos += xgrid_step) {
|
|
sum = 0.0f;
|
|
x_filt = y_im_lin = 0;
|
|
__pragma_loopbound(1, 15);
|
|
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
|
|
y_filt_lin += x_fdim) {
|
|
im_pos = x_pos + y_im_lin;
|
|
__pragma_loopbound(1, 15);
|
|
for (; x_filt < y_filt_lin; ++x_filt) {
|
|
sum += image[im_pos] * temp[x_filt];
|
|
++im_pos;
|
|
}
|
|
y_im_lin += x_dim;
|
|
}
|
|
result[res_pos] = sum;
|
|
++res_pos;
|
|
}
|
|
rt_edge_res_pos = res_pos + x_res_dim; /* save this for later ... */
|
|
_Pragma(
|
|
"loopbound min 1 max 4") for (x_pos +=
|
|
(1 -
|
|
last_ctr_col); /* top-right corner */
|
|
x_pos < x_stop; x_pos += xgrid_step) {
|
|
epic_reflect1(filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER);
|
|
sum = 0.0f;
|
|
x_filt = y_im_lin = 0;
|
|
__pragma_loopbound(1, 15);
|
|
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
|
|
y_filt_lin += x_fdim) {
|
|
im_pos = y_im_lin + last_ctr_col;
|
|
|
|
__pragma_loopbound(1, 15);
|
|
for (; x_filt < y_filt_lin; ++x_filt) {
|
|
sum += image[im_pos] * temp[x_filt];
|
|
++im_pos;
|
|
}
|
|
y_im_lin += x_dim;
|
|
}
|
|
result[res_pos] = sum;
|
|
++res_pos;
|
|
}
|
|
} /* end top */
|
|
|
|
first_row = x_dim * (y_pos + 1); /* need this to go down the sides */
|
|
prev_res_pos = res_pos;
|
|
__pragma_loopbound(1, 4);
|
|
for (x_pos = xgrid_start - x_fmid; /* left edge */
|
|
x_pos < 1; x_pos += xgrid_step) {
|
|
res_pos = prev_res_pos;
|
|
epic_reflect1(filt, x_fdim, y_fdim, x_pos, 0, temp, FILTER);
|
|
__pragma_loopbound(41, 97);
|
|
for (y_pos = first_row; y_pos < last_ctr_row;
|
|
y_pos += ygrid_step_full) {
|
|
sum = 0.0f;
|
|
x_filt = 0, y_im_lin = y_pos;
|
|
__pragma_loopbound(1, 15);
|
|
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
|
|
y_filt_lin += x_fdim) {
|
|
im_pos = y_im_lin;
|
|
__pragma_loopbound(1, 15);
|
|
for (; x_filt < y_filt_lin; x_filt++) {
|
|
sum += image[im_pos] * temp[x_filt];
|
|
++im_pos;
|
|
}
|
|
y_im_lin += x_dim;
|
|
}
|
|
result[res_pos] = sum;
|
|
res_pos += x_res_dim;
|
|
}
|
|
prev_res_pos++;
|
|
}
|
|
epic_reflect1(filt, x_fdim, y_fdim, 0, 0, temp, FILTER);
|
|
__pragma_loopbound(41, 97);
|
|
for (y_pos = first_row; /* center region
|
|
of image */
|
|
y_pos < last_ctr_row; y_pos += ygrid_step_full) {
|
|
res_pos = prev_res_pos;
|
|
__pragma_loopbound(41, 46);
|
|
for (x_pos = first_col; x_pos < last_ctr_col; x_pos += xgrid_step) {
|
|
sum = 0.0f;
|
|
x_filt = 0, y_im_lin = y_pos;
|
|
__pragma_loopbound(1, 15);
|
|
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
|
|
y_filt_lin += x_fdim) {
|
|
im_pos = x_pos + y_im_lin;
|
|
__pragma_loopbound(1, 15);
|
|
for (; x_filt < y_filt_lin; ++x_filt) {
|
|
sum += image[im_pos] * temp[x_filt];
|
|
++im_pos;
|
|
}
|
|
y_im_lin += x_dim;
|
|
}
|
|
result[res_pos] = sum;
|
|
++res_pos;
|
|
}
|
|
prev_res_pos += x_res_dim;
|
|
}
|
|
prev_res_pos = rt_edge_res_pos;
|
|
__pragma_loopbound(1, 4);
|
|
for (x_pos += (1 - last_ctr_col); /* right edge */
|
|
x_pos < x_stop; x_pos += xgrid_step) {
|
|
res_pos = prev_res_pos;
|
|
epic_reflect1(filt, x_fdim, y_fdim, x_pos, 0, temp, FILTER);
|
|
__pragma_loopbound(41, 97);
|
|
for (y_pos = first_row; y_pos < last_ctr_row;
|
|
y_pos += ygrid_step_full) {
|
|
sum = 0.0f;
|
|
x_filt = 0, y_im_lin = y_pos;
|
|
__pragma_loopbound(1, 15);
|
|
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
|
|
y_filt_lin += x_fdim) {
|
|
__pragma_loopbound(1, 15);
|
|
for (im_pos = y_im_lin + last_ctr_col; x_filt < y_filt_lin;
|
|
++x_filt) {
|
|
sum += image[im_pos] * temp[x_filt];
|
|
++im_pos;
|
|
}
|
|
y_im_lin += x_dim;
|
|
}
|
|
result[res_pos] = sum;
|
|
res_pos += x_res_dim;
|
|
}
|
|
prev_res_pos++;
|
|
} /* end mid */
|
|
|
|
res_pos -= (x_res_dim - 1); /* go to lower left corner */
|
|
__pragma_loopbound(1, 4);
|
|
for (y_pos = ((y_pos - last_ctr_row) / x_dim) + 1; /* bottom */
|
|
y_pos < y_stop; y_pos += ygrid_step) {
|
|
_Pragma(
|
|
"loopbound min 1 max 4") for (x_pos =
|
|
xgrid_start -
|
|
x_fmid; /* bottom-left corner */
|
|
x_pos < 1; x_pos += xgrid_step) {
|
|
epic_reflect1(filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER);
|
|
sum = 0.0f;
|
|
x_filt = 0, y_im_lin = last_ctr_row;
|
|
__pragma_loopbound(1, 15);
|
|
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
|
|
y_filt_lin += x_fdim) {
|
|
__pragma_loopbound(1, 15);
|
|
for (im_pos = y_im_lin; x_filt < y_filt_lin; ++x_filt) {
|
|
sum += image[im_pos] * temp[x_filt];
|
|
++im_pos;
|
|
}
|
|
y_im_lin += x_dim;
|
|
}
|
|
result[res_pos] = sum;
|
|
++res_pos;
|
|
}
|
|
epic_reflect1(filt, x_fdim, y_fdim, 0, y_pos, temp, FILTER);
|
|
__pragma_loopbound(41, 46);
|
|
for (x_pos = first_col; /* bottom edge */
|
|
x_pos < last_ctr_col; x_pos += xgrid_step) {
|
|
sum = 0.0f;
|
|
x_filt = 0, y_im_lin = last_ctr_row;
|
|
__pragma_loopbound(1, 15);
|
|
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
|
|
y_filt_lin += x_fdim) {
|
|
__pragma_loopbound(1, 15);
|
|
for (im_pos = x_pos + y_im_lin; x_filt < y_filt_lin; ++x_filt) {
|
|
sum += image[im_pos] * temp[x_filt];
|
|
++im_pos;
|
|
}
|
|
y_im_lin += x_dim;
|
|
}
|
|
result[res_pos] = sum;
|
|
++res_pos;
|
|
}
|
|
__pragma_loopbound(1, 4);
|
|
for (x_pos += 1 - last_ctr_col; /* bottom-right
|
|
corner */
|
|
x_pos < x_stop; x_pos += xgrid_step) {
|
|
epic_reflect1(filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER);
|
|
sum = 0.0f;
|
|
x_filt = 0, y_im_lin = last_ctr_row;
|
|
__pragma_loopbound(1, 15);
|
|
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
|
|
y_filt_lin += x_fdim) {
|
|
__pragma_loopbound(1, 15);
|
|
for (im_pos = y_im_lin + last_ctr_col; x_filt < y_filt_lin;
|
|
++x_filt) {
|
|
sum += image[im_pos] * temp[x_filt];
|
|
++im_pos;
|
|
}
|
|
y_im_lin += x_dim;
|
|
}
|
|
result[res_pos] = sum;
|
|
++res_pos;
|
|
}
|
|
} /* end bottom */
|
|
|
|
} /* end of epic_internal_filter */
|
|
|
|
/*
|
|
The following function determine how edges are to be handled
|
|
when performing convolutions of images with linear filters.
|
|
Any edge handling function which is local and linear may be defined,
|
|
except (unfortunately) constants cannot be added. So to treat the
|
|
edges as if the image is surrounded by a gray field, you must paste it
|
|
into a gray image, convolve, and crop it out...
|
|
The main convolution function is called epic_internal_filter. The idea
|
|
is that the convolution function calls the edge handling function which
|
|
computes a new filter based on the old filter and the distance to the
|
|
edge of the image. For example, reflection is done by reflecting the
|
|
filter through the appropriate axis and summing.
|
|
*/
|
|
|
|
/*
|
|
---------------- EDGE HANDLER ARGUMENTS ------------------------
|
|
filt - floating point array of filter taps.
|
|
x_dim, y_dim - x and y dimensions of filt.
|
|
x_pos - position of filter relative to the horizontal image edges. Negative
|
|
values indicate left edge, positive indicate right edge. Zero
|
|
indicates that the filter is not touching either edge. An absolute
|
|
value of 1 indicates that the edge tap of the filter is over the
|
|
edge pixel of the image.
|
|
y_pos - analogous to x_pos.
|
|
result - floating point array where the resulting filter will go. The edge
|
|
of this filter will be aligned with the image for application...
|
|
f_or_e - equal to one of the two constants EXPAND or FILTER.
|
|
--------------------------------------------------------------------
|
|
*/
|
|
|
|
/* --------------------------------------------------------------------
|
|
epic_reflect1() - Reflection through the edge pixels. This is the right
|
|
thing to do if you are subsampling by 2, since it maintains parity (even
|
|
pixels positions remain even, odd ones remain odd). (note: procedure differs
|
|
depending on f_or_e parameter). */
|
|
__attribute__((always_inline)) static inline void
|
|
epic_reflect1(float *filt, int x_dim, int y_dim, int x_pos, int y_pos,
|
|
float *result, int f_or_e) {
|
|
int filt_sz = x_dim * y_dim;
|
|
register int x_start = 0, y_start = 0, x_stop = x_dim, y_stop = filt_sz;
|
|
register int y_filt, x_filt, y_edge, x_edge;
|
|
register int x_base = (x_pos > 0) ? (x_dim - 1) : 0;
|
|
register int y_base = (y_pos > 0) ? (x_dim * (y_dim - 1)) : 0;
|
|
int x_edge_dist =
|
|
(x_pos > 0) ? (x_pos - x_dim) : ((x_pos < -1) ? (x_pos + 1) : 0);
|
|
int y_edge_dist = x_dim * ((y_pos > 0) ? (y_pos - y_dim)
|
|
: ((y_pos < -1) ? (y_pos + 1) : 0));
|
|
int i;
|
|
int mx_pos = (x_dim / 2) + 1;
|
|
int my_pos = (y_dim / 2) + 1;
|
|
|
|
__pragma_loopbound(15, 15);
|
|
for (i = 0; i < filt_sz; ++i)
|
|
result[i] = 0.0f;
|
|
|
|
/* if EXPAND and filter is centered on image edge, do not reflect */
|
|
if (f_or_e IS EXPAND) {
|
|
if (x_pos IS mx_pos)
|
|
x_stop = (x_dim + 1) / 2;
|
|
else if (x_pos IS - mx_pos) {
|
|
x_start = x_dim / 2;
|
|
x_edge_dist = 0;
|
|
}
|
|
|
|
if (y_pos IS my_pos)
|
|
y_stop = x_dim * ((y_dim + 1) / 2);
|
|
else if (y_pos IS - my_pos) {
|
|
y_start = x_dim * (y_dim / 2);
|
|
y_edge_dist = 0;
|
|
}
|
|
}
|
|
|
|
y_edge = y_edge_dist;
|
|
/* reflect at boundary of image */
|
|
__pragma_loopbound(1, 15);
|
|
for (y_filt = y_start; y_filt < y_stop; y_filt += x_dim) {
|
|
x_edge = x_edge_dist;
|
|
__pragma_loopbound(1, 15);
|
|
for (x_filt = y_filt + x_start; x_filt < y_filt + x_stop; ++x_filt) {
|
|
result[abs(y_base - abs(y_edge)) + abs(x_base - abs(x_edge))] +=
|
|
filt[x_filt];
|
|
++x_edge;
|
|
}
|
|
y_edge += x_dim;
|
|
}
|
|
|
|
/* if EXPAND and filter is not centered on image edge, mult edge by 2 */
|
|
if (f_or_e IS EXPAND) {
|
|
if ((abs(x_pos) ISNT mx_pos) AND(x_pos ISNT 0))
|
|
__pragma_loopbound(0, 0);
|
|
for (y_filt = x_base; y_filt < filt_sz; y_filt += x_dim)
|
|
result[y_filt] += result[y_filt];
|
|
if ((abs(y_pos) ISNT my_pos) AND(y_pos ISNT 0))
|
|
__pragma_loopbound(0, 0);
|
|
for (x_filt = y_base; x_filt < y_base + x_dim; ++x_filt)
|
|
result[x_filt] += result[x_filt];
|
|
}
|
|
}
|
|
|
|
/*
|
|
Main functions
|
|
*/
|
|
|
|
__attribute__((noinline)) __attribute__((export_name("entrypoint")))
|
|
__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
|
|
epic_main(void) {
|
|
epic_build_pyr(epic_image, X_SIZE, Y_SIZE, NUM_LEVELS, epic_lo_filter,
|
|
epic_hi_filter, FILTER_SIZE);
|
|
}
|
|
|
|
__attribute__((always_inline)) static inline int
|
|
epic_return() {
|
|
int i;
|
|
int checksum = 0;
|
|
__pragma_loopbound(64, 64);
|
|
for (i = 0; i < X_SIZE * Y_SIZE; i += Y_SIZE + 1)
|
|
checksum += epic_image[i];
|
|
return (checksum == 43968 ? 0 : 1);
|
|
}
|
|
|
|
__attribute__((noinline)) __attribute__((export_name("main")))
|
|
__attribute__((noinline)) __attribute__((export_name("main"))) int
|
|
main(void) {
|
|
epic_init();
|
|
epic_main();
|
|
|
|
return epic_return();
|
|
}
|