int ext4_mbr_scan(struct ext4_blockdev *parent, struct ext4_mbr_bdevs *bdevs) { int r; size_t i; ext4_dbg(DEBUG_MBR, DBG_INFO "ext4_mbr_scan\n"); memset(bdevs, 0, sizeof(struct ext4_mbr_bdevs)); r = ext4_block_init(parent); if (r != EOK) return r; r = ext4_block_readbytes(parent, 0, parent->bdif->ph_bbuf, 512); if (r != EOK) { goto blockdev_fini; } const struct ext4_mbr *mbr = (void *)parent->bdif->ph_bbuf; if (to_le16(mbr->signature) != MBR_SIGNATURE) { ext4_dbg(DEBUG_MBR, DBG_ERROR "ext4_mbr_scan: unknown " "signature: 0x%x\n", to_le16(mbr->signature)); r = ENOENT; goto blockdev_fini; } /*Show bootstrap code*/ ext4_dbg(DEBUG_MBR, "mbr_part: bootstrap:"); for (i = 0; i < sizeof(mbr->bootstrap); ++i) { if (!(i & 0xF)) ext4_dbg(DEBUG_MBR | DEBUG_NOPREFIX, "\n"); ext4_dbg(DEBUG_MBR | DEBUG_NOPREFIX, "%02x, ", mbr->bootstrap[i]); } ext4_dbg(DEBUG_MBR | DEBUG_NOPREFIX, "\n\n"); for (i = 0; i < 4; ++i) { const struct ext4_part_entry *pe = &mbr->part_entry[i]; ext4_dbg(DEBUG_MBR, "mbr_part: %d\n", (int)i); ext4_dbg(DEBUG_MBR, "\tstatus: 0x%x\n", pe->status); ext4_dbg(DEBUG_MBR, "\ttype 0x%x:\n", pe->type); ext4_dbg(DEBUG_MBR, "\tfirst_lba: 0x%"PRIx32"\n", pe->first_lba); ext4_dbg(DEBUG_MBR, "\tsectors: 0x%"PRIx32"\n", pe->sectors); if (!pe->sectors) continue; /*Empty entry*/ if (pe->type != 0x83) continue; /*Unsupported entry. 0x83 - linux native*/ bdevs->partitions[i].bdif = parent->bdif; bdevs->partitions[i].part_offset = (uint64_t)pe->first_lba * parent->bdif->ph_bsize; bdevs->partitions[i].part_size = (uint64_t)pe->sectors * parent->bdif->ph_bsize; } blockdev_fini: ext4_block_fini(parent); return r; }
static void da2013_cmd_setup(uint16_t cmd, uint16_t req, uint16_t arg0, uint16_t arg1, uint8_t foot) { memset(&da2013_cmd, 0, sizeof(struct cmd)); da2013_cmd.command = to_le16(cmd); da2013_cmd.request = to_le16(req); da2013_cmd.arg0 = to_le16(arg0); da2013_cmd.arg1 = to_le16(arg1); da2013_cmd.footer = foot; da2013_ret.report = 0; }
void IDeserializer::NumberI16(const char* name, int16_t& out, int16_t lower, int16_t upper) { int16_t value; Get(name, (u8*)&value, sizeof(uint16_t)); value = (i16)to_le16((u16)value); if (!(lower <= value && value <= upper)) throw PSERROR_Deserialize_OutOfBounds(name); out = value; }
/* Then calculate crc32 checksum against block_group_desc */ checksum = ext4_crc32c(checksum, bitmap, blocks_per_group / 8); } return checksum; } #else #define ext4_balloc_bitmap_csum(...) 0 #endif void ext4_balloc_set_bitmap_csum(struct ext4_sblock *sb, struct ext4_bgroup *bg, void *bitmap __unused) { int desc_size = ext4_sb_get_desc_size(sb); uint32_t checksum = ext4_balloc_bitmap_csum(sb, bitmap); uint16_t lo_checksum = to_le16(checksum & 0xFFFF), hi_checksum = to_le16(checksum >> 16); if (!ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM)) return; /* See if we need to assign a 32bit checksum */ bg->block_bitmap_csum_lo = lo_checksum; if (desc_size == EXT4_MAX_BLOCK_GROUP_DESCRIPTOR_SIZE) bg->block_bitmap_csum_hi = hi_checksum; } #if CONFIG_META_CSUM_ENABLE static bool ext4_balloc_verify_bitmap_csum(struct ext4_sblock *sb,
int main() { char *file2 = "test2.wav"; FILE *f = fopen(file2,"wb"); unsigned int test_channels = 2; unsigned int test_sampleRate = 44000; unsigned int test_sampleByte = 2; unsigned int test_samplesPerChannel = 44000; unsigned int test_seconds = 60; unsigned int test_hertz = 440; write_wav_header(f,test_channels,test_sampleRate,test_sampleByte,test_samplesPerChannel*test_seconds); void *sampleData = malloc(sizeof(char)*test_channels*test_sampleByte*test_seconds); if(sampleData==NULL) return; wav_sample_t sample = { test_channels, test_sampleByte, test_channels*test_sampleByte, NULL }; int i,j; double high,low; for(i=0;i<test_samplesPerChannel*test_seconds;i++) { for(j=0;j<test_channels;j++) { // sin(2*Pi*(Hz / 44000)*i) high = sin( (double) i * ( ((double) (test_hertz + ((double)(i % 1000))/440) * 2 * M_PI) / (double)test_sampleRate)); if((i%(22000))<1100*test_seconds) { low = sin( (double) i * ( ((double) (test_hertz + (50) * 2 * M_PI) / (double)test_sampleRate))); } else { low = sin( (double) i * ( ((double) (test_hertz + (75) * 2 * M_PI) / (double)test_sampleRate))); } *(((short *)sampleData) + j) = to_le16((short)(( high/2 + low*4 )*0xFFF)); } sample.sampleData = sampleData; write_wav_sample(f,&sample); } free(sampleData); fclose(f); wav_header_t *readHeader = malloc(sizeof(wav_header_t)); if(readHeader==NULL) { printf("Something failed :(\n"); return 0; } FILE *f2 = fopen(file2,"rb"); read_wav_header(f2,readHeader); int samplePerChannel = readHeader->Data.Subchunk2Size / (readHeader->Fmt.NumChannels * (readHeader->Fmt.BytesPerSample)); printf("samplePerChannel = %d\n",samplePerChannel); fclose(f2); free(readHeader); return 0; }
void IDeserializer::NumberI16_Unbounded(const char* name, int16_t& out) { int16_t value; Get(name, (u8*)&value, sizeof(int16_t)); out = (i16)to_le16((u16)value); }
void IDeserializer::NumberU16_Unbounded(const char* name, uint16_t& out) { uint16_t value; Get(name, (u8*)&value, sizeof(uint16_t)); out = to_le16(value); }
uint64_t ext4_extent_get_start(struct ext4_extent *extent) { return ((uint64_t)to_le16(extent->start_hi)) << 32 | ((uint64_t)to_le32(extent->start_lo)); }
void ext4_extent_set_block_count(struct ext4_extent *extent, uint16_t count) { extent->block_count = to_le16(count); }
uint16_t ext4_extent_get_block_count(struct ext4_extent *extent) { return to_le16(extent->block_count); }
/**@brief Set current number of index node entries. * @param climit Pointer to counlimit structure * @param count Number of entries in node */ static inline void ext4_dir_dx_countlimit_set_count(struct ext4_directory_dx_countlimit *climit, uint16_t count) { climit->count = to_le16(count); }
/**@brief Get current number of index node entries. * @param climit Pointer to counlimit structure * @return Number of entries in node */ static inline uint16_t ext4_dir_dx_countlimit_get_count(struct ext4_directory_dx_countlimit *climit) { return to_le16(climit->count); }