void LightEncoder::encode_msg(char* msg) {
// Zero padding
put_bit('0');
put_bit('0');
put_bit('0');
put_bit('0');
char preamble = 0xFE;
encode_char(preamble);
unsigned char msg_len = strlen(msg);
unsigned char checksum = 0xFF;
int i;
for (i = 0; i < msg_len; i++) {
checksum = crc_8(checksum, msg[i]);
encode_char(msg[i]);
}
// CRC8
//encode_char(e, checksum);
// Zero padding
put_bit('0');
put_bit('0');
put_bit('0');
put_bit('0');
put_bit('0');
put_bit('0');
}
void LightEncoder::encode_bit(char bit) {
if (bit) {
put_bit('0');
put_bit('1');
} else {
put_bit('1');
put_bit('0');
}
}
static int fj_flist(NOTUSED char id,jed_ctx *c)
{
int startfuse;
int v;
size_t i;
int bit;
int running=1;
//fuse list field L
if((c->flist==NULL)||(c->num_fuses==0))
return 1;
if(100<=get_num_s(c->f,&startfuse))
return 1;
i=startfuse;
do
{
v=fgetc(c->f);
if(v=='*')
running=0;
else if(!isspace(v))
{
if(v=='0')
bit=0;
else if(v=='1')
bit=1;
else return 1;
if(put_bit(bit,&i,c->flist,c->num_fuses))
return 1;
}
}while(running);
return 0;
}
/*
* Puts dominant-pass and subordinate-pass codes in the output stream.
*/
void output_code(int code)
{
//对于一个已经量化且编码后的数据，来判断它的类型。其类型有6种，正如在头文件中定义的那样
switch (code)
{
case ZERO:
put_bit('0'); //如果是二进制数0，则输出一个比特位，值不变
#ifdef debug
printf("0");
#endif
break;
case ONE:
put_bit('1'); //如果是二进制数1, 则输出一个比特位，值不变
#ifdef debug
printf("1");
#endif
break;
case POS:
put_bit('0'); //如果是正大系数，则按顺序输出两个比特位，值依次为0,1
put_bit('1');
#ifdef debug
printf("p");
#endif
break;
case NEG:
put_bit('1'); //如果是负大系数，则按顺序输出两个比特位，值依次为1,1
put_bit('1');
#ifdef debug
printf("n");
#endif
break;
case ZTR:
put_bit('0'); //如果是零树根，则按顺序输出两个比特位，值依次为0,0
put_bit('0');
#ifdef debug
printf("t");
#endif
break;
case IZ:
put_bit('1'); //如果是孤独零，则按顺序输出两个比特位，值依次为1,0
put_bit('0');
#ifdef debug
printf("z");
#endif
break;
}
}
void
write_rice_code (unsigned value, unsigned rice_k, bitfile_t *output)
/*
* Write 'value' to the stream 'output' using Rice coding with base 'rice_k'.
*
* No return value.
*/
{
unsigned unary; /* unary part of Rice Code */
assert (output);
for (unary = value >> rice_k; unary; unary--)
put_bit (output, 1);
put_bit (output, 0);
put_bits (output, value & ((1 << rice_k) - 1), rice_k);
}
static void encode_position(struct bitstream *bs,struct shannon_fano *sf,
int position)
{
int position_min = 0;
int position_max = sf->nb_evenements;
int sep = -1;
while(sep != trouve_separation(sf, position_min, position_max))
{
if (sep > position)
{
position_max = sep;
put_bit(bs, 0);
}
else
{
position_min = sep;
put_bit(bs, 1);
}
}
}
/* Encodes block data and returns k parameter for block */
int encode(char *input_data, int *output_data, int size)
{
int n = 0;
int k = 0;
int z = 0;
int bit_mask = 0;
char num_bits = 0;
/* Clear buf */
memset(output_data, 0x00, size);
/* Get k parameter given average sum squared error (input_data) */
k = get_k(get_sse(input_data, size)/size);
write_byte((char)k, "Output/compressed.out");
for(n=0;n<size;n++)
{
/* Get last k bits */
bit_mask = 0xFF >> (8-k);
output_data[n] = (int)input_data[n];
output_data[n] &= bit_mask;
/* Add |1| after kth bit */
output_data[n] |= (0x01 << k);
/* Buffer error and get last Z remaining bits */
bit_mask = 0xFF << k;
z = (int)input_data[n];
z &= bit_mask;
/* Align Z with bit 0 */
z >>= k;
/* How many bits to write */
num_bits = k+1+z+1;
/* Prefix sign bit and Z amount of zeroes */
output_data[n] |= (0x02 << (k+z));
/* Start putting bits from sign bit */
bit_mask = 0x01 << (num_bits-1);
/* Code generated, write out */
while(num_bits > 0){
put_bit(output_data[n] & bit_mask);
bit_mask >>= 1;
num_bits--;
}
}
return k;
}
void
put_bits (bitfile_t *bitfile, unsigned value, unsigned bits)
/*
* Put #'bits' bits of integer 'value' to the bitfile buffer 'bitfile'.
*
* No return value.
*
* Side effects:
* Buffer of 'bitfile' is modified.
*/
{
while (bits--)
put_bit (bitfile, value & mask [bits]);
}
static int fj_flisth(NOTUSED char id,jed_ctx *c)
{
int startfuse;
int v;
size_t i;
int nibble;
int running=1;
//hex fuse list field K
if((c->flist==NULL)||(c->num_fuses==0))
return 1;
if(100<=get_num_s(c->f,&startfuse))
return 1;
i=startfuse;
do
{
v=fgetc(c->f);
if(v=='*')
running=0;
else if(!isspace(v))
{
char buf[2];
int j;
buf[0]=v;
buf[1]='\0';
errno=0;
nibble=strtol(buf,NULL,16);
if(errno)
{
perror("strtol");
return 1;
}
for(j=0;j<4;j++)
{
if(put_bit(nibble&(1<<(3-j)),&i,c->flist,c->num_fuses))
return 1;
}
}
}while(running);
return 0;
}
/****************************************************************************
* 関数名 : flush_bits
* 作成日 :
* 作成者 : S.Kobayashi
* 更新日 :
* 機能 : 残ってしまったbitを0で埋めて出力する関数
* 引数 : 対象ファイル:fp
* 戻り値 : なし
****************************************************************************/
void flush_bits(FILE *fp){
while(put_bit(fp,1) != 8);
}
