uint8_t CompactQik2s9v1::getError()
{
	sendByte(ERRORPACKET);
	_errByte = readByte();
	return _errByte;
}
/** Read a single bit from an 8-bit device register.
 * @param devAddr I2C slave device address
 * @param regAddr Register regAddr to read from
 * @param bitNum Bit position to read (0-7)
 * @param data Container for single bit value
 * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
 * @return Status of read operation (true = success)
 */
int8_t I2Cdev::readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout) {
    uint8_t b;
    uint8_t count = readByte(devAddr, regAddr, &b, timeout);
    *data = b & (1 << bitNum);
    return count;
}
Beispiel #3
0
unsigned short PacketBuffer::readShort(){
	unsigned char shrtC[] = {readByte(), readByte()};
	return (shrtC[0]<<8)|(shrtC[1]);
}
Beispiel #4
0
unsigned int PacketBuffer::readInt(){
	unsigned char intC[] = {readByte(), readByte(), readByte(), readByte()};
	return (intC[0]<<24)|(intC[1]<<16)|(intC[2]<<8)|(intC[3]);
}
Beispiel #5
0
uint16 readUint16BE(FILE *file) {
	uint16 x = readByte(file) << 8;
	return x | readByte(file);
}
Beispiel #6
0
uint16 File::readUint16BE() {
	uint8 hi = readByte();
	uint8 lo = readByte();

	return (hi << 8) | lo;
}
bool JpegFrameParser::parse(const unsigned char* src, const std::size_t src_size)
{
    std::size_t scan_data_begin_offset = 0;
    std::size_t scan_data_end_offset = 0;

    const unsigned char* data = src;
    std::size_t offset = 0;

    while (offset < src_size)
    {
        unsigned char one_byte_data = '0';
        readByte(data, offset, one_byte_data);

        if (one_byte_data == START_MARKER)
        {
            unsigned char marker = '0';
            readByte(data, offset, marker);

            switch (marker)
            {
            case SOI_MARKER:
                {
                    // start of image
                    break;
                }
            case JFIF_MARKER:
                {
                    parseApp0(data, offset);
                    break;
                }
            case DQT_MARKER:
                {
                    parseDqt(data, offset);
                    break;
                }
            case SOF0_MARKER:   m_start_of_frame.dct_mode = 0x00;
            case SOF1_MARKER:   m_start_of_frame.dct_mode = 0x01;
            case SOF2_MARKER:   m_start_of_frame.dct_mode = 0x02;
            case SOF3_MARKER:   m_start_of_frame.dct_mode = 0x03;
            case SOF5_MARKER:   m_start_of_frame.dct_mode = 0x05;
            case SOF6_MARKER:   m_start_of_frame.dct_mode = 0x06;
            case SOF7_MARKER:   m_start_of_frame.dct_mode = 0x07;
            case SOF9_MARKER:   m_start_of_frame.dct_mode = 0x09;
            case SOFA_MARKER:   m_start_of_frame.dct_mode = 0x0a;
            case SOFB_MARKER:   m_start_of_frame.dct_mode = 0x0b;
            case SOFD_MARKER:   m_start_of_frame.dct_mode = 0x0d;
            case SOFE_MARKER:   m_start_of_frame.dct_mode = 0x0e;
            case SOFF_MARKER:   m_start_of_frame.dct_mode = 0x0f;
                {
                    parseSof(data, offset);
                    break;
                }
            case DHT_MARKER:
                {
                    // define huffman table
                    break;
                }
            case SOS_MARKER:
                {
                    parseSos(data, offset);

                    scan_data_begin_offset = offset;
                    break;
                }
            case DRI_MARKER:
                {
                    parseDri(data, offset);
                    break;
                }
            case RST0_MARKER:
            case RST1_MARKER:
            case RST2_MARKER:
            case RST3_MARKER:
            case RST4_MARKER:
            case RST5_MARKER:
            case RST6_MARKER:
            case RST7_MARKER:
                {
                    break;
                }
            case DNL_MARKER:
                {
                    break;
                }
            case EOI_MARKER:
                {
                    // end of image
                    size_t eoi_marker_size = 2; //  0xFFD9
                    scan_data_end_offset = (offset - eoi_marker_size);
                    break;
                }
            case COM_MARKER:
                {
                    // comment
                    break;
                }
            }
        }
    }

    BOOST_ASSERT(scan_data_begin_offset != 0);
    BOOST_ASSERT(scan_data_end_offset != 0);

    m_scan_data_size = scan_data_end_offset - scan_data_begin_offset;
    m_scan_data = new unsigned char[m_scan_data_size];
    memcpy(m_scan_data, src + scan_data_begin_offset, m_scan_data_size);

    return true;
}
Beispiel #8
0
char *SeekableReadStream::readLine(char *buf, size_t bufSize) {
	assert(buf != 0 && bufSize > 1);
	char *p = buf;
	size_t len = 0;
	char c = 0;

	// If end-of-file occurs before any characters are read, return NULL
	// and the buffer contents remain unchanged.
	if (eos() || err()) {
		return 0;
	}

	// Loop as long as there is still free space in the buffer,
	// and the line has not ended
	while (len + 1 < bufSize && c != LF) {
		c = readByte();

		if (eos()) {
			// If end-of-file occurs before any characters are read, return
			// NULL and the buffer contents remain unchanged.
			if (len == 0)
				return 0;

			break;
		}

		// If an error occurs, return NULL and the buffer contents
		// are indeterminate.
		if (err())
			return 0;

		// Check for CR or CR/LF
		// * DOS and Windows use CRLF line breaks
		// * Unix and OS X use LF line breaks
		// * Macintosh before OS X used CR line breaks
		if (c == CR) {
			// Look at the next char -- is it LF? If not, seek back
			c = readByte();

			if (err()) {
				return 0; // error: the buffer contents are indeterminate
			}
			if (eos()) {
				// The CR was the last character in the file.
				// Reset the eos() flag since we successfully finished a line
				clearErr();
			} else if (c != LF) {
				seek(-1, SEEK_CUR);
			}

			// Treat CR & CR/LF as plain LF
			c = LF;
		}

		*p++ = c;
		len++;
	}

	// We always terminate the buffer if no error occurred
	*p = 0;
	return buf;
}
void JpegFrameParser::parseSof(const unsigned char*& data, std::size_t& offset)
{
    boost::uint16_t frame_header_size = 0;
    {
        readByte(data, offset, frame_header_size);
        boost::endian::big_to_native_inplace(frame_header_size);
    }

    boost::uint8_t frame_precision = 0;
    {
        readByte(data, offset, frame_precision);
    }

    boost::uint16_t height = 0;
    {
        readByte(data, offset, height);
        boost::endian::big_to_native_inplace(height);
    }

    boost::uint16_t width = 0;
    {
        readByte(data, offset, width);
        boost::endian::big_to_native_inplace(width);
    }

    boost::uint8_t component_count = 0;
    {
        readByte(data, offset, component_count);
    }

    std::vector<StartOfFrame::Component> component_vec;
    for (int i = 0; i < component_count; ++i)
    {
        boost::uint8_t component_number = 0;
        {
            readByte(data, offset, component_number);
        }

        boost::uint8_t horizontal_sample_factor = 0;
        boost::uint8_t vertical_sample_factor = 0;
        {
            boost::uint8_t chunk = 0;
            readByte(data, offset, chunk);

            horizontal_sample_factor = util::getMost4Bit(chunk);
            vertical_sample_factor = util::getLeast4Bit(chunk);
        }

        boost::uint8_t quantization_table_number = 0;
        {
            readByte(data, offset, quantization_table_number);
        }

        StartOfFrame::Component component;
        component.component_number = component_number;
        component.horizontal_sampling_factor = horizontal_sample_factor;
        component.vertical_sampling_factor = vertical_sample_factor;
        component.quantization_table_number = quantization_table_number;

        component_vec.push_back(component);
    }

    m_start_of_frame.header_length = frame_header_size;
    m_start_of_frame.precision = frame_precision;
    m_start_of_frame.height = height;
    m_start_of_frame.width = width;
    m_start_of_frame.component_count = component_count;
    m_start_of_frame.component_vec = component_vec;
}
void JpegFrameParser::parseSos(const unsigned char*& data, std::size_t& offset)
{
    boost::uint16_t header_size = 0;
    {
        readByte(data, offset, header_size);
        boost::endian::big_to_native_inplace(header_size);
    }

    boost::uint8_t component_count = 0;
    {
        readByte(data, offset, component_count);
    }

    std::vector<StartOfScan::Component> component_vec;
    for (int i = 0; i < component_count; ++i)
    {
        boost::uint8_t component_number = 0;
        {
            readByte(data, offset, component_number);
        }

        boost::uint8_t dc_huffman_table_number = 0;
        boost::uint8_t ac_huffman_table_number = 0;
        {
            boost::uint8_t chunk = 0;
            readByte(data, offset, chunk);

            dc_huffman_table_number = util::getMost4Bit(chunk);
            ac_huffman_table_number = util::getLeast4Bit(chunk);
        }

        StartOfScan::Component component;
        component.component_number = component_number;
        component.dc_huffman_table_number = dc_huffman_table_number;
        component.ac_huffman_table_number = ac_huffman_table_number;

        component_vec.push_back(component);
    }

    boost::uint8_t spectral_selection_start = 0;
    {
        readByte(data, offset, spectral_selection_start);
    }

    boost::uint8_t spectral_selection_end = 0;
    {
        readByte(data, offset, spectral_selection_end);
    }

    boost::uint8_t successive_approximation_high = 0;
    boost::uint8_t successive_approximation_low = 0;
    {
        boost::uint8_t chunk = 0;
        readByte(data, offset, chunk);

        successive_approximation_high = util::getMost4Bit(chunk);
        successive_approximation_low = util::getLeast4Bit(chunk);
    }

    m_start_of_scan.header_length = header_size;
    m_start_of_scan.component_count = component_count;
    m_start_of_scan.component_vec = component_vec;
    m_start_of_scan.spectral_selection_start = spectral_selection_start;
    m_start_of_scan.spectral_selection_end = spectral_selection_end;
    m_start_of_scan.successive_approximation_high = successive_approximation_high;
    m_start_of_scan.successive_approximation_low = successive_approximation_low;
}
Beispiel #11
0
/**
 * Read a single byte
 * This function performs as readByte and is added to be similar to the EEPROM library
 */
uint8_t EEPROMClassEx::read(int address)
{
	return readByte(address);
}
Beispiel #12
0
int Path::read(std::ifstream &in, std::string &msg)
{
	msg = "";
	bool finished = false;
	while (!finished)
	{
		short record_size;
		Byte record_type, record_dt;
		if (!readShort(in, record_size)
			|| !readByte(in, record_type)
			|| !readByte(in, record_dt))
			return FILE_ERROR;
		switch (record_type)
		{
		case ENDEL:
			finished = true;
			break;
		case EFLAGS:
			if (record_size != 6)
			{
				std::stringstream ss;
				ss << "Wrong record size of EFLAGS (";
				ss << std::hex << record_size << record_type << record_dt;
				ss << ").";
				msg = ss.str();
				return FORMAT_ERROR;
			}
			if (!readShort(in, Eflags))
				return FILE_ERROR;
			break;
		case LAYER:
			if (record_size != 6)
			{
				std::stringstream ss;
				ss << "Wrong record size of LAYER (";
				ss << std::hex << record_size << record_type << record_dt;
				ss << ").";
				msg = ss.str();
				return FORMAT_ERROR;
			}
			if (!readShort(in, Layer))
				return FILE_ERROR;
			break;
		case DATATYPE:
			if (record_size != 6)
			{
				std::stringstream ss;
				ss << "Wrong record size of DATATYPE (";
				ss << std::hex << record_size << record_type << record_dt;
				ss << ").";
				msg = ss.str();
				return FORMAT_ERROR;
			}
			if (!readShort(in, Data_type))
				return FILE_ERROR;
			break;
		case XY:
		{
			record_size -= 4;
			int num = record_size / 8;
			if (record_size % 8 != 0 || num < 2)
			{
				std::stringstream ss;
				ss << "wrong record size of XY for PATH (";
				ss << std::hex << record_size << record_type << record_dt;
				ss << "). ";
				msg = ss.str();
				return FORMAT_ERROR;
			}
			for (int i = 0; i < num; i++)
			{
				int x, y;
				if (!readInteger(in, x)
					|| !readInteger(in, y))
					return FILE_ERROR;
				Pts.push_back(Point(x, y));
			}
			break;
		}
		case WIDTH:
			if (record_size != 8)
			{
				std::stringstream ss;
				ss << "Wrong record size of WIDTH (";
				ss << std::hex << record_size << record_type << record_dt;
				ss << "). ";
				msg = ss.str();
				return FORMAT_ERROR;
			}
			if (!readInteger(in, Width))
				return FILE_ERROR;
			break;
		case PATHTYPE:
			if (record_size != 6)
			{
				std::stringstream ss;
				ss << "Wrong record size of PATHTYPE (";
				ss << std::hex << record_size << record_type << record_dt;
				ss << "). ";
				msg = ss.str();
				return FORMAT_ERROR;
			}
			if (!readShort(in, Path_type))
				return FILE_ERROR;
			break;
		default:
			break;
		}
	}

	return 0;
}
Beispiel #13
0
static int
readPacket (BrailleDisplay *brl, InputPacket *packet) {
  typedef enum {
    IPG_PRODUCT,
    IPG_KEY,
    IPG_DEFAULT
  } InputPacketGroup;
  InputPacketGroup group = IPG_DEFAULT;

  int length = 1;
  int offset = 0;

  while (1) {
    unsigned char byte;

    {
      int started = offset > 0;
      if (!readByte(&byte, started)) {
        if (started) logPartialPacket(packet->bytes, offset);
        return 0;
      }
    }

  gotByte:
    if (!offset) {
      switch (byte) {
        case IPT_KEY_NAVIGATION:
        case IPT_KEY_SIMULATION:
        case IPT_KEY_ROUTING:
          group = IPG_KEY;
          length = 4;
          break;

        default:
          if (byte == productPrefix[0]) {
            group = IPG_PRODUCT;
            length = sizeof(packet->product) - 1;
          } else {
            logIgnoredByte(byte);
            continue;
          }
          break;
      }
    } else {
      int unexpected = 0;

      switch (group) {
        case IPG_PRODUCT:
          if (offset < productPrefixLength) {
            if (byte != productPrefix[offset]) unexpected = 1;
          } else if (byte == '@') {
            length = offset + 1;
          }
          break;

        case IPG_KEY:
          if (offset == 1) {
            if (byte != packet->bytes[0]) unexpected = 1;
          } else if (offset == 3) {
            if (byte != 0X19) unexpected = 1;
          }
          break;

        default:
          break;
      }

      if (unexpected) {
        logShortPacket(packet->bytes, offset);
        group = IPG_DEFAULT;
        offset = 0;
        length = 1;
        goto gotByte;
      }
    }

    packet->bytes[offset++] = byte;
    if (offset == length) {
      if (group == IPG_PRODUCT) {
        packet->bytes[length] = 0;
      }

      logInputPacket(packet->bytes, offset);
      return length;
    }
  }
}
Beispiel #14
0
bool SaveGame::readBool() {
	return readByte() != 0;
}
Beispiel #15
0
bool InputStream::readBool()
{
    return readByte() != 0;
}