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); } } }