int getbuttonstate()
{
FILE *in;
int ret;
#ifdef HAVE_STORM
ret = read_bit(60);
#elif HAVE_WG302V1
ret = read_bit(13);
#elif HAVE_WG302
ret = read_bit(3);
#elif HAVE_MI424WR
ret = read_bit(10);
#elif HAVE_USR8200
ret = read_bit(12);
#elif HAVE_CAMBRIA
if (isGW2350())
ret = read_bit(4);
else
ret = read_bit(20);
#else
if (isCompex())
ret = read_bit(0);
if (isGW2369())
ret = read_bit(3);
else
ret = read_bit(4);
#endif
#ifdef HAVE_TONZE
return ret == 0 ? 0 : 1;
#else
return ret == 0 ? 1 : 0;
#endif
}
/*!
* \brief Parse PES packet.
* \param *bitstr: The bitstream to use.
* \param *header: A pointer to a PES header structure.
* \param *packet: A pointer to a PES packet structure.
* \return 1 if succeed, 0 otherwise.
*
* From 'ISO/IEC 13818-1' specification:
* 2.4.3.6 PES packet.
* Table 2-17 – PES packet.
*
* Parse both MPEG-1 (ISO/IEC 11172-1) and MPEG-2 (ISO/IEC 13818-1) PES packets.
*/
int parse_pes(Bitstream_t *bitstr, PesHeader_t *header, PesPacket_t *packet)
{
TRACE_2(MPS, "> parse_pes()");
int retcode = SUCCESS;
TRACE_INFO(MPS, "parse_pes() 0x%X @ %lli",
header->start_code, bitstream_get_absolute_byte_offset(bitstr));
// "regular" PES packet?
if ((header->stream_id != SID_PROGRAM_STREAM_MAP) &&
(header->stream_id != SID_PADDING) &&
(header->stream_id != SID_PRIVATE_STREAM_2) &&
(header->stream_id != SID_ECM_STREAM) &&
(header->stream_id != SID_EMM_STREAM) &&
(header->stream_id != SID_PROGRAM_STREAM_DIRECTORY) &&
(header->stream_id != SID_DSMCC_STREAM) &&
(header->stream_id != SID_2221E))
{
unsigned checkversion = next_bits(bitstr, 2);
// Parse MPEG-2 PES header
if ((checkversion & 0x02) == 0x02)
{
packet->mpeg_version = 2;
if (read_bits(bitstr, 2) != 2)
{
TRACE_ERROR(MPS, "wrong 'marker_bits'");
return FAILURE;
}
packet->PES_scrambling_control = read_bits(bitstr, 2);
packet->PES_priority = read_bit(bitstr);
packet->data_alignment_indicator = read_bit(bitstr);
packet->copyright = read_bit(bitstr);
packet->original_or_copy = read_bit(bitstr);
packet->PTS_DTS_flag = read_bits(bitstr, 2);
packet->ESCR_flag = read_bit(bitstr);
packet->ES_rate_flag = read_bit(bitstr);
packet->DSM_trick_mode_flag = read_bit(bitstr);
packet->additional_copy_info_flag = read_bit(bitstr);
packet->PES_CRC_flag = read_bit(bitstr);
packet->PES_extension_flag = read_bit(bitstr);
packet->PES_header_data_length = read_bits(bitstr, 8);
if (packet->PTS_DTS_flag == 2)
{
if (read_bits(bitstr, 4) != 2)
{
TRACE_ERROR(MPS, "wrong 'marker_bit'");
return FAILURE;
}
packet->PTS = read_bits(bitstr, 3) << 30;
MARKER_BIT
packet->PTS += read_bits(bitstr, 15) << 15;
MARKER_BIT
packet->PTS += read_bits(bitstr, 15);
MARKER_BIT
}
else if (packet->PTS_DTS_flag == 3)
void read_chunk_regs(void *fptr, int action)
{
struct user user;
struct cp_sparc_window_regs or;
int stopped;
read_bit(fptr, &user, sizeof(struct user));
read_bit(fptr, &stopped, sizeof(int));
read_bit(fptr, &or, sizeof(struct cp_sparc_window_regs));
/*
if (action & ACTION_PRINT) {
fprintf(stderr, "(registers): Process was %sstopped\n",
stopped?"":"not ");
fprintf(stderr, "\teax: 0x%08lx ebx: 0x%08lx ecx: 0x%08lx edx: 0x%08lx\n",
user.regs.eax, user.regs.ebx, user.regs.ecx, user.regs.edx);
fprintf(stderr, "\tesi: 0x%08lx edi: 0x%08lx ebp: 0x%08lx esp: 0x%08lx\n",
user.regs.esi, user.regs.edi, user.regs.ebp, user.regs.esp);
fprintf(stderr, "\t ds: 0x%08x es: 0x%08x fs: 0x%08x gs: 0x%08x\n",
user.regs.ds, user.regs.es, user.regs.fs, user.regs.gs);
fprintf(stderr, "\teip: 0x%08lx eflags: 0x%08lx",
user.regs.eip, user.regs.eflags);
}
*/
if (action & ACTION_LOAD)
load_chunk_regs(&user, &or, stopped);
}
static void pin_write_handler(ble_lbs_t * p_lbs, uint8_t * pin_state)
{
// Sets motor values for every motor.
twi_set_motor(pin_state);
// Sets the color for every RGB-LED.
uint8_t web_color_data = read_byte(pin_state, 5);
set_rgb_color(web_color_data);
// Shoots IR-signal.
if (read_bit(pin_state, 1, 0))
{
ir_shooting(pin_state);
playNote(536);
nrf_delay_ms(50);
playNote(536);
}
// Turns laser on when game session is active
if(read_bit(pin_state, 1, 1))
{
nrf_gpio_pin_set(LASER_TRANSISTOR);
}
else
nrf_gpio_pin_clear(LASER_TRANSISTOR);
write_car_id(pin_state[19]);
unique_car_ID = pin_state[19];
}
/*!
* \param *dc The current DecodingContext.
* \param *slice structure.
* \return *rplm_t initialized data structure.
*/
static rplm_t *decodeRPLM(DecodingContext_t *dc, slice_t *slice)
{
TRACE_INFO(SLICE, " > " BLD_GREEN "decodeRPLM()\n" CLR_RESET);
// RPLM allocation
////////////////////////////////////////////////////////////////////////////
rplm_t *rplm = (rplm_t*)calloc(1, sizeof(rplm_t));
if (rplm == NULL)
{
TRACE_ERROR(SLICE, "Unable to alloc new RPLM!\n");
}
else
{
// RPLM decoding
////////////////////////////////////////////////////////////////////////
if (slice->slice_type % 5 != 2 && slice->slice_type % 5 != 4)
{
rplm->ref_pic_list_modification_flag_l0 = read_bit(dc->bitstr);
if (rplm->ref_pic_list_modification_flag_l0)
{
do {
rplm->modification_of_pic_nums_idc = read_ue(dc->bitstr);
if (rplm->modification_of_pic_nums_idc == 0 ||
rplm->modification_of_pic_nums_idc == 1)
{
rplm->abs_diff_pic_num_minus1 = read_ue(dc->bitstr);
}
else if (rplm->modification_of_pic_nums_idc == 2)
{
rplm->long_term_pic_num = read_ue(dc->bitstr);
}
} while (rplm->modification_of_pic_nums_idc != 3);
}
}
if (slice->slice_type % 5 == 1)
{
rplm->ref_pic_list_modification_flag_l1 = read_bit(dc->bitstr);
if (rplm->ref_pic_list_modification_flag_l1)
{
do {
rplm->modification_of_pic_nums_idc = read_ue(dc->bitstr);
if (rplm->modification_of_pic_nums_idc == 0 ||
rplm->modification_of_pic_nums_idc == 1)
{
rplm->abs_diff_pic_num_minus1 = read_ue(dc->bitstr);
}
else if (rplm->modification_of_pic_nums_idc == 2)
{
rplm->long_term_pic_num = read_ue(dc->bitstr);
}
} while (rplm->modification_of_pic_nums_idc != 3);
}
}
}
return rplm;
}
AM_ERR CMp4Builder::get_pic_order(unsigned char* pBuffer, int size, int nal_unit_type, int* pic_order_cnt_lsb) {
AM_U8* pSlice_header = pBuffer;
AM_U8 bit_pos = 0;
AM_INT first_mb_in_slice;
AM_INT slice_type;
AM_INT pic_parameter_set_id;
AM_INT frame_num;
pSlice_header += parse_ue(pSlice_header,&first_mb_in_slice,&bit_pos);
pSlice_header += parse_ue(pSlice_header,&slice_type,&bit_pos);
switch (slice_type) {
case SLICE_P_0:
case SLICE_P_1:
if (_last_p_num == -1) {
_last_p_num = mVideoCnt;
} else {
if (mH264Info.M == 0) {
mH264Info.M = mVideoCnt - _last_p_num;
}
}
break;
case SLICE_I_0:
case SLICE_I_1:
if (_last_i_num == -1) {
_last_i_num = mVideoCnt;
} else {
if (mH264Info.N == 0) {
mH264Info.N = mVideoCnt - _last_i_num;
}
}
break;
default:
break;
}
pSlice_header += parse_ue(pSlice_header,&pic_parameter_set_id,&bit_pos);
pSlice_header += read_bit(pSlice_header,&frame_num,&bit_pos,
mSpsInfo.log2_max_frame_num_minus4+4);
if (!mSpsInfo.frame_mbs_only_flag) {
AM_BOOL field_pic_flag;
AM_BOOL bottom_field_flag;
pSlice_header += read_bit(pSlice_header, (AM_INT *)&field_pic_flag,&bit_pos);
if (field_pic_flag)
pSlice_header += read_bit(pSlice_header, (AM_INT *)&bottom_field_flag,&bit_pos);
}
if (nal_unit_type == NAL_IDR) {
AM_INT idr_pic_id;
pSlice_header += parse_ue(pSlice_header,&idr_pic_id,&bit_pos);
}
if( mSpsInfo.pic_order_cnt_type == 0 ) {
pSlice_header += read_bit(pSlice_header,pic_order_cnt_lsb,&bit_pos,
mSpsInfo.log2_max_pic_order_cnt_lsb_minus4+4);
int max_pic_order_cnt_lsb = 1<<(mSpsInfo.log2_max_pic_order_cnt_lsb_minus4+4);
if (*pic_order_cnt_lsb > max_pic_order_cnt_lsb/2) {
*pic_order_cnt_lsb -= max_pic_order_cnt_lsb;
}
}
return ME_OK;
}
/*!
* \brief Parse a program stream directory structure.
* \param *bitstr The bitstream to use.
* \param *packet A program stream directory structure.
* \return 1 if succeed, 0 otherwise.
*
* From 'ISO/IEC 13818-1' specification:
* 2.5.5 Program Stream directory
* Table 2-36 – Program Stream directory packet
*/
static int parse_program_stream_directory(Bitstream_t *bitstr, PesHeader_t *header, ProgramStreamDirectory_t *packet)
{
TRACE_INFO(MPS, BLD_GREEN "parse_program_stream_directory()" CLR_RESET " @ %lli",
header->offset_start);
int retcode = SUCCESS;
packet->number_of_access_units = read_bits(bitstr, 15);
MARKER_BIT
packet->prev_directory_offset = read_bits(bitstr, 15) << 30;
MARKER_BIT
packet->prev_directory_offset += read_bits(bitstr, 15) << 15;
MARKER_BIT
packet->prev_directory_offset += read_bits(bitstr, 15);
MARKER_BIT
packet->next_directory_offset = read_bits(bitstr, 15) << 30;
MARKER_BIT
packet->next_directory_offset += read_bits(bitstr, 15) << 15;
MARKER_BIT
packet->next_directory_offset += read_bits(bitstr, 15);
MARKER_BIT
for (uint16_t i = 0; i < packet->number_of_access_units; i++)
{
// TODO stack it?
packet->packet_stream_id = read_bits(bitstr, 8);
packet->PES_header_position_offset_sign = read_bit(bitstr);
packet->PES_header_position_offset = read_bits(bitstr, 14) << 30;
MARKER_BIT
packet->PES_header_position_offset += read_bits(bitstr, 15) << 15;
MARKER_BIT
packet->PES_header_position_offset += read_bits(bitstr, 15);
MARKER_BIT
packet->reference_offset = read_bits(bitstr, 16);
MARKER_BIT
/*unsigned reserved1 =*/ read_bits(bitstr, 3);
packet->PTS = read_bits(bitstr, 3) << 30;
MARKER_BIT
packet->PTS += read_bits(bitstr, 15) << 15;
MARKER_BIT
packet->PTS += read_bits(bitstr, 15);
MARKER_BIT
packet->byes_to_read = read_bits(bitstr, 15) << 15;
MARKER_BIT
packet->byes_to_read += read_bits(bitstr, 8);
MARKER_BIT
packet->intra_coded_indicator = read_bit(bitstr);
packet->coding_parameters_indicator = read_bits(bitstr, 2);
/*unsigned reserved2 =*/ read_bits(bitstr, 4);
}
return retcode;
}
static int read_result(hx711_task* task)
{
int result;
result = -read_bit(task);
for(int i=0;i<23;i++)
{
result <<= 1;
result |= read_bit(task);
}
return result;
}
static void rebuild_tree(LHAPM2Decoder *decoder)
{
switch (decoder->tree_state) {
// Initial tree build, from start of stream:
case PM2_REBUILD_UNBUILT:
read_code_tree(decoder);
read_offset_tree(decoder, 5);
decoder->tree_state = PM2_REBUILD_BUILD1;
decoder->tree_rebuild_remaining = 1024;
break;
// Tree rebuild after 1KiB of data has been read:
case PM2_REBUILD_BUILD1:
read_offset_tree(decoder, 6);
decoder->tree_state = PM2_REBUILD_BUILD2;
decoder->tree_rebuild_remaining = 1024;
break;
// Tree rebuild after 2KiB of data has been read:
case PM2_REBUILD_BUILD2:
read_offset_tree(decoder, 7);
decoder->tree_state = PM2_REBUILD_BUILD3;
decoder->tree_rebuild_remaining = 2048;
break;
// Tree rebuild after 4KiB of data has been read:
case PM2_REBUILD_BUILD3:
if (read_bit(&decoder->bit_stream_reader) == 1) {
read_code_tree(decoder);
}
read_offset_tree(decoder, 8);
decoder->tree_state = PM2_REBUILD_CONTINUING;
decoder->tree_rebuild_remaining = 4096;
break;
// Tree rebuild after 8KiB of data has been read,
// and every 4KiB after that:
case PM2_REBUILD_CONTINUING:
if (read_bit(&decoder->bit_stream_reader) == 1) {
read_code_tree(decoder);
read_offset_tree(decoder, 8);
}
decoder->tree_rebuild_remaining = 4096;
break;
}
}
void compressed_file_reader::get_next()
{
uint64_t numberBits = 0;
while (status_ == 0 && !read_bit())
++numberBits;
current_value_ = 0;
for (int64_t bit = numberBits - 1; status_ == 0 && bit >= 0; --bit)
{
if (read_bit())
current_value_ |= (1 << bit);
}
current_value_ |= (1 << numberBits);
}
static void clock_setup_pulses(hx711_task* task)
{
int setup_pulses;
switch (task->op)
{
case A128:
setup_pulses = 1;
break;
case A64:
setup_pulses = 3;
break;
case B32:
setup_pulses = 2;
break;
default:
setup_pulses = 1;
}
for (int i=0;i<setup_pulses;i++)
{
read_bit(task);
}
}
static size_t lha_pm2_decoder_read(void *data, uint8_t *buf)
{
LHAPM2Decoder *decoder = data;
size_t result;
int code;
// On first pass through, build initial lookup trees.
if (decoder->tree_state == PM2_REBUILD_UNBUILT) {
// First bit in stream is discarded?
read_bit(&decoder->bit_stream_reader);
rebuild_tree(decoder);
}
result = 0;
code = read_from_tree(&decoder->bit_stream_reader, decoder->code_tree);
if (code < 0) {
return 0;
}
if (code < 8) {
read_single_byte(decoder, (unsigned int) code, buf, &result);
} else {
copy_from_history(decoder, (unsigned int) code - 8,
buf, &result);
}
return result;
}
int BinaryFileReader::read_omega() {
int number = 1;
while (read_bit() == 1) {
number = read_binary(number);
}
return number;
}
int funzip()
{
PHuftree_node p;
unsigned char b,byte;
p=&huftree[512];
while (p->num != 256)
{
b=read_bit(F_SRC);
if (b)
p=&huftree[p->rchild];
else
p=&huftree[p->lchild];
if (p->num < 256)
{
byte=(unsigned char)(p->num);
write_byte(F_DST,&byte);
p=&huftree[512];
}
}
return 0;
}
void compucolor_floppy_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
if (!m_sel && !m_rw)
{
output_rxd(read_bit());
}
}
// write to scratchpad of a SINGLE sensor
void writeSP(int brdNo) {
int i;
int get[8];
ow_reset();
write_byte(0xCC);
write_byte(0x4E);
write_byte(brdNo);
write_byte(0x0);
write_byte(0x7F);
while(read_bit() == 0);
ow_reset();
write_byte(0xCC);
write_byte(0x48);
uDelay(120);
ow_reset();
write_byte(0xCC);
uDelay(120);
write_byte(0xBE);
for (i = 0 ; i < 9 ; i++){
get[i] = read_byte();
}
if(get[2] != brdNo || get[3] != 0 || get[4] != 0x7F) {
UART_printf("BAD CONFIGURATION?\n");
}
}
/*!
* \brief Parse a program stream map structure.
* \param *bitstr The bitstream to use.
* \param *header PES packet header.
* \param *packet A program stream map structure.
* \return 1 if succeed, 0 otherwise.
*
* \todo Parse desciptors.
*
* From 'ISO/IEC 13818-1' specification:
* 2.5.4 Program Stream map
* Table 2-35 – Program Stream map
*/
int parse_program_stream_map(Bitstream_t *bitstr, PesHeader_t *header, ProgramStreamMap_t *packet)
{
TRACE_INFO(MPS, BLD_GREEN "parse_program_stream_map()" CLR_RESET " @ %lli",
header->offset_start);
int retcode = SUCCESS;
int i = 0, N1 = 0, N2 = 0;
packet->current_next_indicator = read_bit(bitstr);
/*int reserved1 =*/ read_bits(bitstr, 2);
packet->program_stream_map_version = read_bits(bitstr, 5);
/*int reserved2 =*/ read_bits(bitstr, 7);
MARKER_BIT
packet->program_stream_map_info_length = read_bits(bitstr, 16);
for (i = 0; i < N1; i++)
{
// descriptor()
}
packet->elementary_stream_map_length = read_bits(bitstr, 16);
for (i = 0; i < N1; i++)
{
// Stack it?
packet->stream_type = read_bits(bitstr, 8);
packet->elementary_stream_id = read_bits(bitstr, 8);
packet->elementary_stream_info_length = read_bits(bitstr, 16);
for (i = 0; i < N2; i++)
{
// descriptor()
}
}
packet->CRC_32 = read_bits(bitstr, 32);
return retcode;
}
char *deflate_decompress(char *data, int data_length, int max_size)
{
char *buf = malloc(max_size * sizeof(char));
int pos = 0;
bitstream_t *bitstream = calloc(1, sizeof(bitstream_t));
bitstream->data = data;
int final, type;
do {
final = read_bit(bitstream);
type = read_bits(bitstream, 2);
if (type == 0) {
pos = deflate_process_uncompressed(buf, pos, bitstream);
} else if (type == 1 || type == 2) {
htree_t *htree_lit, *htree_dist;
if (type == 1) {
deflate_get_fixed_htrees(&htree_lit, &htree_dist);
} else {
deflate_parse_htrees(bitstream, &htree_lit, &htree_dist);
}
pos = deflate_process_huffman(buf, pos, bitstream,
htree_lit, htree_dist);
/* Free the Huffman trees. */
huffman_free_tree(htree_lit);
huffman_free_tree(htree_dist);
} else {
printf("Error: Invalid deflate block type\n");
}
} while (!final);
static int read_code(LHALH1Decoder *decoder, uint16_t *result)
{
unsigned int node_index;
int bit;
// Start from the root node, and traverse down until a leaf is
// reached.
node_index = 0;
//printf("<root ");
while (!decoder->nodes[node_index].leaf) {
bit = read_bit(&decoder->bit_stream_reader);
if (bit < 0) {
return 0;
}
//printf("<%i>", bit);
// Choose one of the two children depending on the
// bit that was read.
node_index = decoder->nodes[node_index].child_index
- (unsigned int) bit;
}
*result = decoder->nodes[node_index].child_index;
//printf(" -> %i!>\n", *result);
increment_for_code(decoder, *result);
return 1;
}
void read_chunk_tls(void *fptr, int action)
{
struct user_desc u;
int ret;
read_bit(fptr, &u, sizeof(struct user_desc));
if (!u.base_addr)
return;
if (action & ACTION_PRINT)
fprintf(stderr, "TLS entry (%d): base_addr = 0x%lx",
u.entry_number, u.base_addr);
if (!(action & ACTION_LOAD))
return;
if (!emulate_tls) {
ret = set_thread_area(NULL);
if (ret == -1) /* some libcs return the actual errno instead of -1 */
ret = -errno;
if (ret == -ENOSYS) {
/* We are not a TLS capable system. Turn on TLS emulation voodoo. */
emulate_tls = 1;
/* We'll need write access to the code segments to do this. */
extra_prot_flags |= PROT_WRITE;
}
}
if (emulate_tls)
tls_base_address = u.base_addr;
else
syscall_check(set_thread_area(&u), 0, "set_thread_area");
}
static int read_length_value(LHANewDecoder *decoder)
{
int i, len;
len = read_bits(&decoder->bit_stream_reader, 3);
if (len < 0) {
return -1;
}
if (len == 7) {
// Read more bits to extend the length until we reach a '0'.
for (;;) {
i = read_bit(&decoder->bit_stream_reader);
if (i < 0) {
return -1;
} else if (i == 0) {
break;
}
++len;
}
}
return len;
}
AM_UINT CMp4Builder::parse_exp_codes(AM_U8* pBuffer, AM_INT* value,
AM_U8* bit_pos=0, AM_U8 type=0)
{
int leadingZeroBits = -1;
AM_UINT i=0;
AM_U8 j=*bit_pos;
for (AM_U8 b = 0; !b; leadingZeroBits ++, j ++) {
if(j == 8) {
i++;
j=0;
}
if (j == 0) {
if ((pBuffer[i] == 0x3) &&
(*(pBuffer+i-1) == 0) &&
(*(pBuffer+i-2) == 0)) {
i++;
}
}
b = pBuffer[i] >> (7 -j) & 0x1;
}
AM_INT codeNum = 0;
i += read_bit(pBuffer+i, &codeNum, &j, leadingZeroBits);
codeNum += (1 << leadingZeroBits) -1;
if (type == 0) { //ue(v)
*value = codeNum;
} else if (type == 1) {//se(v)
*value = (codeNum/2+1);
if (codeNum %2 == 0) {
*value *= -1;
}
}
*bit_pos = j;
return i;
}
/*!
* \brief parse_ebml_element
* \note 'bitstr' pointer is not checked for performance reasons.
*
* https://matroska.org/technical/specs/index.html
* https://matroska.org/technical/specs/rfc/index.html
*/
int parse_ebml_element(Bitstream_t *bitstr, EbmlElement_t *element)
{
TRACE_3(MKV, "parse_ebml_element()");
int retcode = SUCCESS;
if (element == NULL)
{
TRACE_ERROR(MKV, "Invalid EbmlElement_t structure!");
retcode = FAILURE;
}
else
{
// Set element offset
element->offset_start = bitstream_get_absolute_byte_offset(bitstr);
// Read element ID
{
uint32_t ebml_leadingZeroBits = 0;
uint32_t ebml_size = 0;
while (read_bit(bitstr) == 0 && ebml_leadingZeroBits < 4)
ebml_leadingZeroBits++;
ebml_size = (ebml_leadingZeroBits + 1) * 7;
element->eid_size = (ebml_size + ebml_leadingZeroBits + 1) / 8;
element->eid = read_bits_64(bitstr, ebml_size) + pow(2, ebml_size);
}
// Read element size
{
uint32_t ebml_leadingZeroBits = 0;
uint32_t ebml_size = 0;
while (read_bit(bitstr) == 0 && ebml_leadingZeroBits < 8)
ebml_leadingZeroBits++;
ebml_size = (ebml_leadingZeroBits + 1) * 7;
element->size_size = (ebml_size + ebml_leadingZeroBits + 1) / 8;
element->size = read_bits_64(bitstr, ebml_size);
}
// Set end offset
element->offset_end = element->offset_start + (element->eid_size + element->size_size + element->size);
}
return retcode;
}
static int write_byte(struct i2c *base, int byte)
{
int i;
for (i=7; i>=0; i--)
write_bit(base, (byte & (1<<i)) != 0);
return read_bit(base) == 0; // ok (1) if NACK is asserted
}
static boolean send_byte(byte b, boolean mak) {
for (int i=0; i<8; i++) {
rwbit(b&0x80);
b<<=1;
}
rwbit(mak);
return read_bit();
}
int BinaryFileReader::read_binary(int n) {
int number = 1;
for (int i = 0; i < n; ++i) {
number <<= 1;
number |= read_bit();
}
return number;
}
Node * read_header(FILE * fporig)
{//reads the header from the beginning of the .huff file and builds the huffman tree
int donecheck = 0;
int count;
unsigned char readchar;
Node * root = NULL;
Node * newNode = NULL;
Node * head = NULL;
while (!donecheck)
{//while were not done, keep reading header
read_bit(fporig);
if (bit)
{//found a leaf in the header, read in the 8-bit unsigned char
readchar = 0;
read_bit(fporig);
readchar |= bit; //put in first bit
for (count = 0; count < 7; ++count)
{//loop 7 times to save the next 7 bits
readchar <<= 1;
read_bit(fporig);
readchar |= bit;
}
//create a list of nodes where the last two are the lowest in the tree
newNode = create_node(readchar);
head = add_list(head, newNode);
} else
{//we are at a non-leaf node
if (head == NULL)
{
fprintf(stderr, "\nERROR! FIRST BIT IN HEADER SHOULD NOT BE 0. WILL SEGFAULT.\n\n");
}
if (head -> next == NULL)
{//the list has become the tree
root = head;
donecheck = 1;
} else
{//have atleast 2 nodes in the list, merge the 2 furthest to the right
head = merge_two(head);
}
}
}
//done reading the header, root points to our tree, last 0 bits are padding
return (root);
}
char read_char(FILE* input){
int c = 0;
for (int i = 0; i < CHAR_BIT; i++){
int bit = read_bit(input);
bit = bit << (CHAR_BIT - i - 1);
c |= bit;
}
return c;
}
/**
* Transfer bits over SPI bit-bashing bus
*
* @v bus SPI bus
* @v data_out TX data buffer (or NULL)
* @v data_in RX data buffer (or NULL)
* @v len Length of transfer (in @b bits)
* @v endianness Endianness of this data transfer
*
* This issues @c len clock cycles on the SPI bus, shifting out data
* from the @c data_out buffer to the MOSI line and shifting in data
* from the MISO line to the @c data_in buffer. If @c data_out is
* NULL, then the data sent will be all zeroes. If @c data_in is
* NULL, then the incoming data will be discarded.
*/
static void spi_bit_transfer ( struct spi_bit_basher *spibit,
const void *data_out, void *data_in,
unsigned int len, int endianness ) {
struct spi_bus *bus = &spibit->bus;
struct bit_basher *basher = &spibit->basher;
unsigned int sclk = ( ( bus->mode & SPI_MODE_CPOL ) ? 1 : 0 );
unsigned int cpha = ( ( bus->mode & SPI_MODE_CPHA ) ? 1 : 0 );
unsigned int bit_offset;
unsigned int byte_offset;
unsigned int byte_mask;
unsigned int bit;
unsigned int step;
DBGC2 ( spibit, "SPIBIT %p transferring %d bits in mode %#x\n",
spibit, len, bus->mode );
for ( step = 0 ; step < ( len * 2 ) ; step++ ) {
/* Calculate byte offset and byte mask */
bit_offset = ( ( endianness == SPI_BIT_BIG_ENDIAN ) ?
( len - ( step / 2 ) - 1 ) : ( step / 2 ) );
byte_offset = ( bit_offset / 8 );
byte_mask = ( 1 << ( bit_offset % 8 ) );
/* Shift data in or out */
if ( sclk == cpha ) {
const uint8_t *byte;
/* Shift data out */
if ( data_out ) {
byte = ( data_out + byte_offset );
bit = ( *byte & byte_mask );
DBGCP ( spibit, "SPIBIT %p wrote bit %d\n",
spibit, ( bit ? 1 : 0 ) );
} else {
bit = 0;
}
write_bit ( basher, SPI_BIT_MOSI, bit );
} else {
uint8_t *byte;
/* Shift data in */
bit = read_bit ( basher, SPI_BIT_MISO );
if ( data_in ) {
DBGCP ( spibit, "SPIBIT %p read bit %d\n",
spibit, ( bit ? 1 : 0 ) );
byte = ( data_in + byte_offset );
*byte &= ~byte_mask;
*byte |= ( bit & byte_mask );
}
}
/* Toggle clock line */
spi_bit_delay();
sclk ^= 1;
write_bit ( basher, SPI_BIT_SCLK, sclk );
}
}
static int read_byte(struct i2c *base)
{
int i;
u8 byte=0;
for (i=7; i>=0; i--)
byte = (byte << 1) | read_bit(base);
return byte;
}
