C++ IODevice::read_uint32方法代码示例

void ZipFileHeader::load(IODevice &input)
{
	signature = input.read_int32();
	if (signature != 0x02014b50)
	{
		throw Exception("Incorrect File Header signature");
	}
	version_made_by = input.read_int16();
	version_needed_to_extract = input.read_int16();
	general_purpose_bit_flag = input.read_int16();
	compression_method = input.read_int16();
	last_mod_file_time = input.read_int16();
	last_mod_file_date = input.read_int16();
	crc32 = input.read_uint32();
	compressed_size = input.read_int32();
	uncompressed_size = input.read_int32();
	file_name_length = input.read_int16();
	extra_field_length = input.read_int16();
	file_comment_length = input.read_int16();
	disk_number_start = input.read_int16();
	internal_file_attributes = input.read_int16();
	external_file_attributes = input.read_int32();
	relative_offset_of_local_header = input.read_int32();
	filename.resize(file_name_length);

	auto str1 = new char[file_name_length];
	auto str2 = new char[extra_field_length];
	auto str3 = new char[file_comment_length];
	try
	{
		input.read(str1, file_name_length);
		input.read(str2, extra_field_length);
		input.read(str3, file_comment_length);
		if (general_purpose_bit_flag & ZIP_USE_UTF8)
		{
			filename = StringHelp::utf8_to_text(std::string(str1, file_name_length));
			file_comment = StringHelp::utf8_to_text(std::string(str3, file_comment_length));
		}
		else
		{
			filename = StringHelp::cp437_to_text(std::string(str1, file_name_length));
			file_comment = StringHelp::cp437_to_text(std::string(str3, file_comment_length));
		}

		extra_field = DataBuffer(str2, extra_field_length);

		delete[] str1;
		delete[] str2;
		delete[] str3;
	}
	catch (...)
	{
		delete[] str1;
		delete[] str2;
		delete[] str3;
		throw;
	}
}

void OutlineProviderFile_Impl::load(IODevice &input_source)
{
	// file type & version identifiers
	int type = input_source.read_uint32();
	unsigned char version = input_source.read_uint8();

	if( type != 0x16082004  )
		throw Exception("File is not a collision outline file" );
	if( version != 1 )
		throw Exception(string_format("Unsupported version of outline format: %1. Supported versions: 1.", version) );

	// read in width and height
	width = input_source.read_int32();
	height = input_source.read_int32();

	// x-pos of enclosing disc
	minimum_enclosing_disc.position.x = input_source.read_float();
	// y-pos of enclosing disc
	minimum_enclosing_disc.position.y = input_source.read_float();
	// radius of enclosing disc
	minimum_enclosing_disc.radius = input_source.read_float();
	
	// num contours
	int num_contours = input_source.read_uint32();

	for( int cc=0; cc < num_contours; ++cc )
	{
		Contour contour;

		int num_points = input_source.read_uint32();

		for( int pp=0; pp < num_points; ++pp )
		{
			Pointf point(0,0);
			point.x = input_source.read_float();
			point.y = input_source.read_float();

			contour.get_points().push_back(point);
		}
		
		contours.push_back(contour);
	}
}

	void SoundProvider_Wave_Impl::load(IODevice &source)
	{
		source.set_little_endian_mode();

		char chunk_id[4];
		source.read(chunk_id, 4);
		if (memcmp(chunk_id, "RIFF", 4))
			throw Exception("Expected RIFF header!");
		uint32_t chunk_size = source.read_uint32();

		char format_id[4];
		source.read(format_id, 4);
		if (memcmp(format_id, "WAVE", 4))
			throw Exception("Expected WAVE header!");

		uint32_t subchunk_pos = source.get_position();
		uint32_t subchunk1_size = find_subchunk("fmt ", source, subchunk_pos, chunk_size);

		uint16_t audio_format = source.read_uint16();
		num_channels = source.read_uint16();
		frequency = source.read_uint32();
		uint32_t byte_rate = source.read_uint32();
		uint16_t block_align = source.read_uint16();
		uint16_t bits_per_sample = source.read_uint16();

		if (bits_per_sample == 16)
			format = sf_16bit_signed;
		else if (bits_per_sample == 8)
			format = sf_8bit_unsigned;
		else
			throw Exception("Unsupported wave sample format");

		uint32_t subchunk2_size = find_subchunk("data", source, subchunk_pos, chunk_size);

		data = new char[subchunk2_size];
		source.read(data, subchunk2_size);

		num_samples = subchunk2_size / block_align;
	}

	unsigned int SoundProvider_Wave_Impl::find_subchunk(const char *chunk, IODevice &source, unsigned int file_offset, unsigned int max_offset)
	{
		char subchunk1_id[4];

		max_offset -= 8;	// Each subchunk must contains at least name and size
		while (file_offset < max_offset)
		{
			source.seek(file_offset);
			source.read(subchunk1_id, 4);
			uint32_t subchunk1_size = source.read_uint32();
			if (!memcmp(subchunk1_id, chunk, 4))
			{
				// Found chunk
				return subchunk1_size;
			}
			file_offset += subchunk1_size + 8;
		}

		throw Exception("Block not found!");
	}