static void __init rb2011_wlan_init(void)
{
u8 *hard_cfg = (u8 *) KSEG1ADDR(0x1f000000 + RB_HARD_CFG_OFFSET);
u16 tag_len;
u8 *tag;
char *art_buf;
u8 wlan_mac[ETH_ALEN];
int err;
err = routerboot_find_tag(hard_cfg, RB_HARD_CFG_SIZE, RB_ID_WLAN_DATA,
&tag, &tag_len);
if (err) {
pr_err("no calibration data found\n");
return;
}
art_buf = kmalloc(RB_ART_SIZE, GFP_KERNEL);
if (art_buf == NULL) {
pr_err("no memory for calibration data\n");
return;
}
err = rle_decode((char *) tag, tag_len, art_buf, RB_ART_SIZE,
NULL, NULL);
if (err) {
pr_err("unable to decode calibration data\n");
goto free;
}
ath79_init_mac(wlan_mac, ath79_mac_base, 11);
ath79_register_wmac(art_buf + 0x1000, wlan_mac);
free:
kfree(art_buf);
}
static void __init rb751_wlan_setup(void)
{
u8 *hardconfig = (u8 *) KSEG1ADDR(RB751_HARDCONFIG);
struct ath9k_platform_data *wmac_data;
u16 tag_len;
u8 *tag;
u16 mac_len;
u8 *mac;
int err;
wmac_data = ap9x_pci_get_wmac_data(0);
if (!wmac_data) {
pr_err("rb75x: unable to get address of wlan data\n");
return;
}
ap9x_pci_setup_wmac_led_pin(0, 9);
err = routerboot_find_tag(hardconfig, RB751_HARDCONFIG_SIZE,
RB_ID_WLAN_DATA, &tag, &tag_len);
if (err) {
pr_err("rb75x: no calibration data found\n");
return;
}
err = rle_decode(tag, tag_len, (unsigned char *) wmac_data->eeprom_data,
sizeof(wmac_data->eeprom_data), NULL, NULL);
if (err) {
pr_err("rb75x: unable to decode wlan eeprom data\n");
return;
}
err = routerboot_find_tag(hardconfig, RB751_HARDCONFIG_SIZE,
RB_ID_MAC_ADDRESS_PACK, &mac, &mac_len);
if (err) {
pr_err("rb75x: no mac address found\n");
return;
}
ap91_pci_init(NULL, mac);
}
bitimage_t *scanlines2bitimage(scanline_t *slimg)
{
bitimage_t *img= 0;
scanline_t *sl;
int w= 0;
int y0= -1;
int y= 0;
int h;
for (sl=slimg; sl!=0; sl=sl->next) {
if (sl->width) {
if (w<sl->osize) w= sl->osize;
if (y0<0) y0= sl->y;
y= sl->y;
}
}
h= y-y0+1;
if ((!w) || (!h))
return 0;
img= bitimage_new();
img->buf= (unsigned char*) stp_malloc(h*w);
memset(img->buf,0,h*w);
img->width= w;
img->height= h;
img->y0= y0;
for (sl=slimg; sl!=0; sl=sl->next) {
y= sl->y- y0;
if ((y>=0) && (y<h)) {
rle_decode(sl->buf,sl->size,img->buf+y*w,w);
}
}
return img;
}
static int
f_decode (size_t z, unsigned char *bz, size_t n, unsigned char *bp)
{
/* bp buffer provided
| bz buffer "zipped", compressed
| n len of buffer provided
| z len of buffer zipped
\*---------------------------------------------------------------*/
/*
unsigned char *ib = intermediate_block;
unsigned int m;
return huff_decode (bz, z, ib, &m, MAXBLOCK) && rle_decode (ib, m, bp, &n, MAXBLOCK);
*/
#if defined(HUFFMAN)
if (CP_SCHEME == CP1) {
/* HUFFMAN */
return huff_decode (bz, z, bp, &n, MAXBLOCK);
} else
#endif
#if defined(LIBLZF)
if (CP_SCHEME == CP2) {
/* LZF */
return lzf_decode (bz, z, bp, &n, MAXBLOCK);
} else
#endif
#if defined (ZLIB)
if (CP_SCHEME == CP3) {
/* ZLIB */
return zlib_decode (bz, z, bp, &n, MAXBLOCK);
} else
#endif
if (CP_SCHEME == CP4) {
/* LZMA86 */
return lzma_decode (bz, z, bp, &n, n); /* maximum needs to be the exact number that it will produce */
} else if (CP_SCHEME == CP7) {
/* RLE */
return rle_decode (bz, z, bp, &n, MAXBLOCK);
#if defined (LIBBZIP2)
} else if (CP_SCHEME == CP8) {
/* BZIP2 */
return bzip2_decode (bz, z, bp, &n, MAXBLOCK);
#endif
} else if (CP_SCHEME == CP9) {
return justcopy_decode (bz, z, bp, &n, MAXBLOCK);
} else {
return FALSE;
}
}
/* Entry point for the program. Opens the file, and executes the mode specified by command line args */
int main(int argc, char* argv[])
{
if(argc != 3 || (strcmp(argv[1], "-c") != 0 && strcmp(argv[1], "-d") != 0 && strcmp(argv[1], "-t") != 0))
{
printf("usage: huff [-c | -d | -t] file\n");
return -1;
}
/* Execute the correct mode */
if(strcmp(argv[1], "-c") == 0)
{
//append the extension to the name
const char * extension = ".temp";
char *tempFile = malloc(strlen(argv[2])+strlen(extension) + 1);
strncpy(tempFile, argv[2], strlen(argv[2]));
strcat(tempFile, extension);
//RLE encode the file
rle_encode(argv[2], tempFile);
//create a vairiable to hold hold the file length
unsigned long long fileLength = 0;
//get a buffer of the contents of the file as a unsigned char*
unsigned char *file_pointer = openFile(tempFile, &fileLength);
//huff compress the output.
compress(file_pointer, fileLength, argv[2]);
free(file_pointer);
//free(tempFile);
remove(tempFile);
}
else if(strcmp(argv[1], "-d") == 0)
{
unsigned long long fileLength = 0;
unsigned char *file_pointer = openFile(argv[2], &fileLength);
decompress(file_pointer, fileLength, argv[2]);
//remove the .hurl extension from the fileName;
char *tempFileName = calloc(strlen(argv[2]), sizeof(char));
strncpy(tempFileName, argv[2], strlen(argv[2]) - strlen(".hurl"));
strncat(tempFileName, ".temp", sizeof(".temp"));
char *outputFileName = calloc(sizeof(char), strlen(argv[2]));
strncpy(outputFileName, argv[2], strlen(argv[2]));
outputFileName[strlen(outputFileName) -5] = '\0';
rle_decode(tempFileName, outputFileName);
free(file_pointer);
remove(tempFileName);
}
else if(strcmp(argv[1], "-t") == 0)
{
unsigned long long fileLength = 0;
unsigned char *file_pointer = openFile(argv[2], &fileLength);
print_table(file_pointer, fileLength, argv[2]);
free(file_pointer);
}
// free(file_pointer);
return 0;
}
int main (int argc, char** argv)
{
FILE* file;
char* filename;
int filesize;
char filedata [327680];
char* rle_output;
int rle_length;
char* rld_output;
int rld_length;
unsigned int i,j;
if (argc < 2)
{
printf ("This program requires a filename...\n");
return -1;
}
filename = argv [1];
file = fopen (filename, "rb");
if (! file) {
printf ("Could not open file: '%s'!\n", filename);
return -1;
}
fseek (file, 0, SEEK_END);
filesize = ftell (file);
rewind (file);
fread (filedata, filesize, 1, file);
fclose (file);
rle_output = rle_encode (filedata, filesize, &rle_length);
printf ("Size before: %d\n"
"Size after: %d\n"
"Space saved: %2.2f%%\n",
filesize,
rle_length,
100.0f * (1.0f - ((float)rle_length / (float)filesize)));
// dump (rle_output, rle_length);
rld_output = rle_decode (rle_output, rle_length, &rld_length);
printf ("Runlength Decode Size: %d\n", rld_length);
j = 0;
for (i = 0; i < filesize; i++) {
j += (unsigned int)filedata [i];
}
printf ("Checksum Before: %X\n", j);
j = 0;
for (i = 0; i < rld_length; i++) {
j += (unsigned int)rld_output [i];
}
printf ("Checksum After: %X\n", j);
return 0;
}
/*
* Given a valid huffman mode, this function will generate the compression table that lists the codes for each
* of the ascii characters that the compression scheme uses. That table is placed into the pOutTable passed
* in by the caller.
*
* Table will have 256 entries and look like:
* 01001
* 001
* 0111
* ...
* 00001
*/
eFileCode GenerateTableAndCompressOrDecompress(eMode huffmanMode, const char *fileName)
{
eFileCode fileCode; // And error code which tells if the operation was successful or not.
FILE *pFile = fopen(fileName, "r"); // Open file for reading.
fileCode = FILE_SUCCESS;
// Check that file was successfully opened. If not, return an error code.
if (pFile == NULL)
{
return FILE_MISSING;
}
switch(huffmanMode)
{
case DECOMPRESS_MODE:
{
// If the file is a compressed huffman file, then use the get table for huff function to open it.
char huffmanEncodings[ENTRIES * ENTRY_LENGTH];
unsigned long long lengthOfFile =
huffmanEncodingsFromFile(pFile, huffmanEncodings);
huffResult resultArray[ENTRIES];
createHuffResultArrayFromFileEncodings(huffmanEncodings, resultArray);
huffNode huffmanTree[ENTRIES + ENTRIES - 1];
createDecodeTreeFromResultArray(resultArray, huffmanTree);
FILE *rle_file = xtmpfile();
writeCompressedFileToNonCompressedOutput(pFile, rle_file, lengthOfFile, &huffmanTree[0]);
rewind(rle_file);
int nameLength = strlen(fileName) - strlen(".hurl");
char newFileName[nameLength + 1];
strncpy(newFileName, fileName, nameLength);
newFileName[nameLength] = 0;
FILE *pNewFile = xfopen(newFileName, "w");
rle_decode(rle_file, pNewFile);
fclose(rle_file);
fclose(pNewFile);
break;
}
case TABLE_MODE_HURL:
{
// If we want a table and the file is .hurl, it may or may not be the same .hurl we want it to be.
// We'll try to treat it as a .hurl but if it's the wrong format, we will treat it like a generic
// file.
char huffmanEncodings[ENTRIES * ENTRY_LENGTH];
huffmanEncodingsFromFile(pFile, huffmanEncodings);
if (huffmanEncodings[0] != 0)
{
huffResult resultArray[ENTRIES];
createHuffResultArrayFromFileEncodings(huffmanEncodings, resultArray);
printHuffResultArray(resultArray);
}
else
{
// File was a .hurl, but internally format doesn't fit. Oh well, we can still generate a compression table.
// Maybe someone else in the world created their own .hurl file format. We need to handle that format.
fseek(pFile, 0, SEEK_SET);
// The frequency of occurrence of each character in the uncompressed file.
unsigned long long pFrequencies[ENTRIES];
memset(pFrequencies, 0, sizeof(pFrequencies));
if (GenerateFrequenciesForGeneric(pFile, pFrequencies) == FILE_SUCCESS)
{
huffResult resultArray[ENTRIES];
fileCode = GetTableForGeneric(pFrequencies, resultArray);
}
else
{
fileCode = FILE_INVALID_FORMAT;
}
}
break;
}
case TABLE_MODE_GENERIC:
{
// If the file is not a .hurl, then generate frequencies and then a table for the file.
// The frequency of occurrence of each character in the uncompressed file.
unsigned long long pFrequencies[ENTRIES];
memset(pFrequencies, 0, sizeof(pFrequencies));
if (GenerateFrequenciesForGeneric(pFile, pFrequencies) == FILE_SUCCESS)
{
huffResult resultArray[ENTRIES];
fileCode = GetTableForGeneric(pFrequencies, resultArray);
printHuffResultArray(resultArray);
}
else
{
fileCode = FILE_INVALID_FORMAT;
}
break;
}
case COMPRESS_MODE:
{
FILE *rle_file = xtmpfile();
rle_encode(pFile, rle_file);
rewind(rle_file);
unsigned long long pFrequencies[ENTRIES];
memset(pFrequencies, 0, sizeof(pFrequencies));
if (GenerateFrequenciesForGeneric(rle_file, pFrequencies) != FILE_SUCCESS)
{
fileCode = FILE_INVALID_FORMAT;
break;
}
huffResult resultArray[ENTRIES];
fileCode = GetTableForGeneric(pFrequencies, resultArray);
char newFileName[strlen(fileName) + 6];
strcpy(newFileName, fileName);
FILE *pNewFile = fopen(strcat(newFileName, ".hurl"), "w+");
if (pNewFile == NULL)
{
fileCode = FILE_INVALID_FORMAT;
break;
}
writeNonCompressedFileToCompressedOutput(rle_file, pNewFile, resultArray);
fclose(rle_file);
fclose(pNewFile);
break;
}
default:
{
// File must not be valid for the specified commandline options if we get this far.
fileCode = FILE_INVALID_FORMAT;
break;
}
}
fclose(pFile);
return fileCode;
}
SPREXPORT Sprite *
sprite_open_from_data (const unsigned char *data, unsigned int size, SpriteError *error)
{
Sprite *sprite;
unsigned char palette[1024], buf[4];
int i, pos, palette_size;
/* Check buffer size; a valid sprite file is at least:
Magic header 4 bytes
Number of frames 2 bytes
Palette 1024 bytes
--------------------------
Total 1030 bytes
*/
if (size < 1030) {
if (error) *error = SE_INVALID;
return NULL;
}
/* Check file's "magic header", which is 4 bytes */
if (memcmp (data, "SP\001\002", 4) != 0) {
if (error) *error = SE_INVALID;
return NULL;
}
/* Read the number of sprites */
sprite = (Sprite *) calloc (sizeof (Sprite), 1);
sprite->nimages = (data[5] << 8) + data[4];
/* Read palette */
memcpy (&palette, data + size - 1024, 1024);
sprite->palette = (SpritePalette *) reverse_palette (palette, 1024, &palette_size);
sprite->palette_size = palette_size;
/* Now read the actual sprite data */
sprite->images = (SpriteImage *) calloc (sizeof (SpriteImage), sprite->nimages);
pos = 8;
for (i = 0; i < sprite->nimages; i++) {
int width, height, compressed_len, pixels_size;
unsigned char *pixels;
buf[0] = data[pos];
buf[1] = data[pos + 1];
pos += 2;
width = (buf[1] << 8) + buf[0];
buf[0] = data[pos];
buf[1] = data[pos + 1];
pos += 2;
height = (buf[1] << 8) + buf[0];
buf[0] = data[pos];
buf[1] = data[pos + 1];
pos += 2;
compressed_len = (buf[1] << 8) + buf[0];
pixels = rle_decode ((unsigned char *) data + pos, compressed_len, width, &pixels_size);
pos += compressed_len;
sprite->images[i].data = pixels;
sprite->images[i].len = pixels_size;
sprite->images[i].width = width;
sprite->images[i].height = height;
}
return sprite;
}
int rle_decoded_size(unsigned char* inbuffer, unsigned int inlen){
return rle_decode(inbuffer, inlen,NULL, 0);
}
TEST(rle, encode_decode)
{
const uint8_t decode_data_0[] = {
0x01, 0x32, 0x32, 0x32, 0x32, 0x32, 0x55, 0x37, 0x11, 0xAC, 0x8E, 0x97,
0xC9, 0xC9, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0x88
};
const uint8_t encode_data_0[] = {
0x01, 0x01, 0x05, 0x32, 0x00, 0x06, 0x55, 0x37, 0x11, 0xAC, 0x8E, 0x97,
0x02, 0xC9, 0x08, 0xA0, 0x01, 0x88
};
const uint8_t decode_data_1[] = {
0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3
};
const uint8_t encode_data_1[] = {
0x0C, 0xB3
};
const uint8_t decode_data_2[] = {
0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF
};
const uint8_t encode_data_2[] = {
0x00, 0x08, 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF
};
const uint8_t decode_data_3[] = {
0x12, 0x12, 0x12, 0x78, 0x90, 0xAB, 0xAB, 0xAB, 0xAB
};
const uint8_t encode_data_3[] = {
0x03, 0x12, 0x00, 0x02, 0x78, 0x90, 0x04, 0xAB
};
struct rle_test_data_s {
const uint8_t *decode_data;
const uint8_t *encode_data;
size_t numof_decode_data;
size_t numof_encode_data;
} rtd[] = {
{ decode_data_0, encode_data_0, sizeof(decode_data_0), sizeof(encode_data_0) },
{ decode_data_1, encode_data_1, sizeof(decode_data_1), sizeof(encode_data_1) },
{ decode_data_2, encode_data_2, sizeof(decode_data_2), sizeof(encode_data_2) },
{ decode_data_3, encode_data_3, sizeof(decode_data_3), sizeof(encode_data_3) }
};
size_t numof_rle_data = sizeof(rtd)/sizeof(rtd[0]);
int32_t i;
for (i=0; i<(int32_t)numof_rle_data; i++) {
struct rle_test_data_s *p = &rtd[i];
uint8_t work[32];
memset(work, 0, sizeof(work));
size_t act_len = rle_encode(p->decode_data, p->numof_decode_data, work, sizeof(work));
/* printf("<encode>\n"); */
dump(p->decode_data, p->numof_decode_data);
dump(work, act_len);
/* printf("\n"); */
TEST_ASSERT_EQUAL(p->numof_encode_data, act_len);
TEST_ASSERT_EQUAL_UINT8_ARRAY(p->encode_data, work, act_len);
memset(work, 0, sizeof(work));
act_len = rle_decode(p->encode_data, p->numof_encode_data, work, sizeof(work));
/* printf("<decode>\n"); */
dump(p->encode_data, p->numof_encode_data);
dump(work, act_len);
/* printf("\n"); */
TEST_ASSERT_EQUAL(p->numof_decode_data, act_len);
TEST_ASSERT_EQUAL_UINT8_ARRAY(p->decode_data, work, act_len);
}
}
SPREXPORT Sprite *
sprite_load (const char *fname, SpriteError *error)
{
Sprite *sprite;
FILE *f;
unsigned char palette[1024], magic[5], buf[4];
unsigned char *rpalette;
int i, size;
if (!fname) {
if (error) *error = SE_BADARGS;
return NULL;
}
f = fopen ("4_deviruchi.spr", "rb");
if (!f) {
if (error) *error = SE_CANTOPEN;
return NULL;
}
/* Check file's "magic header" */
magic[4] = '\0';
fread (magic, 4, 1, f);
if (strcmp (magic, "SP\001\002") != 0) {
if (error) *error = SE_INVALID;
fclose (f);
return NULL;
}
/* Read the number of sprites */
fread (buf, 2, 1, f);
sprite = (Sprite *) calloc (sizeof (Sprite), 1);
sprite->nimages = (buf[1] << 8) + buf[0];
/* Read palette */
memset (&palette, 0, sizeof (palette));
fseek (f, -1024, SEEK_END);
fread (&palette, 1, 1024, f);
sprite->palette = rpalette = reverse_palette (palette, 1024, &size);
sprite->palette_size = size;
/* Now read the actual sprite data */
sprite->images = (SpriteImage *) calloc (sizeof (SpriteImage), sprite->nimages);
fseek (f, 8, SEEK_SET);
for (i = 0; i < sprite->nimages; i++) {
int width, height, compressed_len;
unsigned char *data, *ddata;
fread (buf, 2, 1, f);
width = (buf[1] << 8) + buf[0];
fread (buf, 2, 1, f);
height = (buf[1] << 8) + buf[0];
fread (buf, 2, 1, f);
compressed_len = (buf[1] << 8) + buf[0];
data = calloc (compressed_len, 1);
fread (data, compressed_len, 1, f);
ddata = rle_decode (data, compressed_len, width, &size);
free (data);
sprite->images[i].data = ddata;
sprite->images[i].len = size;
sprite->images[i].width = width;
sprite->images[i].height = height;
}
sprite->filename = strdup (fname);
return sprite;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
register int m, n, state, N, P, direct;
register double *rle, *X, *T;
//-----------------------
// INPUT
//-----------------------
//--
// run-length code
//--
rle = mxGetPr(prhs[0]);
// size of image
m = *(rle);
n = *(rle + 1);
// initial state of decoder
state = (int) *(rle + 2);
// run-length encoding
rle = rle + 3;
N = mxGetM(prhs[0]) * mxGetN(prhs[0]) - 3;
//-----------------------
// OUTPUT
//-----------------------
// decoded image
X = mxGetPr(plhs[0] = mxCreateDoubleMatrix(m, n, mxREAL));
//--
// COMPUTATION
//--
if (nrhs < 2) {
//--
// run-length decode
//--
rle_decode (X, state, rle, N);
} else {
//--
// get label table and table type
//--
T = mxGetPr(prhs[1]);
P = mxGetM(prhs[1]) * mxGetN(prhs[1]);
direct = (int) mxGetScalar(prhs[2]);
// check length of table if each run has a direct label
if (direct && (N != P)) {
mexErrMsgTxt("Table length must match run-length code length.");
}
//--
// run-length decoding and labelling
//--
if (direct) {
rle_decode_label(X, state, rle, N, T, 0);
} else {
rle_decode_label(X, state, rle, N, T, P);
}
}
}
