自学教程：C++ GetBlockSize函数代码示例

/** * @public * @brief	Mounts and Image with FullFAT. * * **/DLL_EXPORT int FFC_MountImage(char *szFilename, unsigned long ulBlockSize, unsigned long ulPartitionNumber) {	FF_ERROR Error = FF_ERR_NONE;	if(g_pIoman || g_hDisk) {		return FFD_ERR_IMAGE_ALREADY_MOUNTED;	}	g_hDisk = fnOpen(szFilename, ulBlockSize);	if(!g_hDisk) {		return FFD_ERR_COULD_NOT_OPEN_IMAGE;	}		g_pIoman = FF_CreateIOMAN(NULL, 8192, GetBlockSize(g_hDisk), &Error);	// Using the BlockSize from the Device Driver (see blkdev_win32.c)	if(!g_pIoman) {		return FFD_ERR_COULD_NOT_INITIALISE_FULLFAT;	} else {		Error = FF_RegisterBlkDevice(g_pIoman, GetBlockSize(g_hDisk), (FF_WRITE_BLOCKS) fnWrite, (FF_READ_BLOCKS) fnRead, g_hDisk);		if(Error) {			printError(Error);			FF_DestroyIOMAN(g_pIoman);			fnClose(g_hDisk);			return -1;		}		// Attempt to mount!		Error = FF_MountPartition(g_pIoman, (FF_T_UINT8) ulPartitionNumber);		if(Error) {			if(g_hDisk) {				fnClose(g_hDisk);			}			FF_DestroyIOMAN(g_pIoman);			g_pIoman = NULL;			return -1;		}		g_Env.pIoman = g_pIoman;		strcpy(g_Env.WorkingDir, "//");	// Reset working dir!	}	return FFD_ERR_NONE;}

void GDALRasterBlock::Detach_unlocked(){    if( poOldest == this )        poOldest = poPrevious;    if( poNewest == this )    {        poNewest = poNext;    }    if( poPrevious != NULL )        poPrevious->poNext = poNext;    if( poNext != NULL )        poNext->poPrevious = poPrevious;    poPrevious = NULL;    poNext = NULL;    bMustDetach = FALSE;    if( pData )        nCacheUsed -= GetBlockSize();#ifdef ENABLE_DEBUG    Verify();#endif}

void CItemField::Get(unsigned char *value, size_t &length, Fish *bf) const{  // Sanity check: length is 0 iff data ptr is NULL  ASSERT((m_Length == 0 && m_Data == NULL) ||         (m_Length > 0 && m_Data != NULL));  /*  * length is an in/out parameter:  * In: size of value array - must be at least BlockLength  * Out: size of data stored: m_Length (No trailing zero!)  * if In < BlockLength, assertion is triggered (no way to handle gracefully)  */  if (m_Length == 0) {    value[0] = TCHAR('/0');    length = 0;  } else { // we have data to decrypt    size_t BlockLength = GetBlockSize(m_Length);    ASSERT(length >= BlockLength);    unsigned char *tempmem = new unsigned char[BlockLength];    size_t x;    for (x = 0; x < BlockLength; x += 8)      bf->Decrypt(m_Data + x, tempmem + x);    for (x = 0; x < BlockLength; x++)      value[x] = (x < m_Length) ? tempmem[x] : 0;    length = m_Length;    delete [] tempmem;  }}

// Writes data to a file (asynchronous overload).AKRESULT CAkDefaultIOHookDeferred::Write(	AkFileDesc &			in_fileDesc,        // File descriptor.	const AkIoHeuristics & /*in_heuristics*/,	// Heuristics for this data transfer (not used in this implementation).	AkAsyncIOTransferInfo & io_transferInfo		// Platform-specific asynchronous IO operation info.	){	AKASSERT( in_fileDesc.hFile != INVALID_HANDLE_VALUE 			&& io_transferInfo.uRequestedSize > 0 );	// If this assert comes up, it might be beacause this hook's GetBlockSize() return value is incompatible 	// with the system's handling of file reading for this specific file handle.	// Are you using the File Package Low-Level I/O with incompatible block size? (check -blocksize argument in the File Packager command line)	AKASSERT( io_transferInfo.uFilePosition % GetBlockSize( in_fileDesc ) == 0			|| !"Requested file position for I/O transfer is inconsistent with block size" );	OVERLAPPED * pOverlapped = GetFreeOverlapped( &io_transferInfo );		// Set file offset in OVERLAPPED structure.	pOverlapped->Offset = (DWORD)( io_transferInfo.uFilePosition & 0xFFFFFFFF );	pOverlapped->OffsetHigh = (DWORD)( ( io_transferInfo.uFilePosition >> 32 ) & 0xFFFFFFFF );    // File was open with asynchronous flag.     // Read overlapped.     if ( ::WriteFileEx( in_fileDesc.hFile,                      io_transferInfo.pBuffer,                      io_transferInfo.uRequestedSize,                      pOverlapped,					  CAkDefaultIOHookDeferred::FileIOCompletionRoutine ) )	{		return AK_Success;	}	ReleaseOverlapped( pOverlapped );    return AK_Fail;}

int32_t FixedMemPool::Init(void* mem, uint32_t max_node_num, size_t node_size, bool check_header) {    if (!mem) {        return -1;    }    m_header = (MemHeader*)mem;    if (!check_header) {        //init head        m_header->max_size = GetAllocSize(max_node_num, node_size);        m_header->max_node_num = max_node_num;        //we use the beginning of the memory pool to as head infomation        m_header->used_size = sizeof(MemHeader);        m_header->used_node_num = 0;        //block size is based on node size aligned by 8 bytes        m_header->block_size = GetBlockSize(node_size);        //no block is freed        m_header->free_list_offset = kInvalidPointer;        m_data = (char*)m_header + sizeof(MemHeader);    } else {        if (!CheckHeader(max_node_num, node_size, m_header)) {            snprintf(m_error_msg, sizeof(m_error_msg), "Memory pool head check error!");            return -1;        }        m_data = (char*)m_header + sizeof(MemHeader);    }    return 0;}

static TRI_hash_index_element_multi_t* GetFromFreelist (TRI_hash_array_multi_t* array) {  if (array->_freelist == nullptr) {    size_t blockSize = GetBlockSize(array->_blocks._length);    TRI_ASSERT(blockSize > 0);    auto begin = static_cast<TRI_hash_index_element_multi_t*>(TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, blockSize * OverflowEntrySize(), true));    if (begin == nullptr) {      return nullptr;    }    auto ptr = begin;    auto end = begin + (blockSize - 1);    while (ptr < end) {      ptr->_next = (ptr + 1);      ++ptr;    }    array->_freelist = begin;    TRI_PushBackVectorPointer(&array->_blocks, begin);    array->_nrOverflowAlloc += blockSize;  }  auto next = array->_freelist;  TRI_ASSERT(next != nullptr);  array->_freelist = next->_next;  array->_nrOverflowUsed++;     return next;}

int CryptoStreamEncryptionCBC::CalculateEncryptedTargetLength(int source_length) const{	int block_size = GetBlockSize();	switch (m_padding_strategy)	{	case PADDING_STRATEGY_NONE:		OP_ASSERT(source_length % block_size == 0);		return source_length;	case PADDING_STRATEGY_PCKS15:		/*		 * Pad the encrypted target with byte 'n' where n is the number		 * of padding bytes. Bytes are added until target_length == 0 mod		 * block_size		 *		 * If source length  == 0 mod block size, one block of padding		 * is added.		 */		return source_length + (block_size - (source_length % block_size));	default:		OP_ASSERT(!"UNKNOWN PADDING STRATEGY");		return source_length;	}}

void CryptoStreamEncryptionCBC::Encrypt(const UINT8 *source, UINT8 *target, int source_length, int target_length){	// IMPROVE ME : Implement cipher stealing for arbitrary lengths	OP_ASSERT(source && target && source_length >= 0 && target_length >= 0);	if (target_length == 0 && m_padding_strategy == PADDING_STRATEGY_NONE)		target_length = source_length;	OP_ASSERT(target_length == CalculateEncryptedTargetLength(source_length));	UINT8 padding_byte = target_length - source_length;	m_algorithm->SetEncryptKey(m_key);	int block_size = GetBlockSize();	for (int i = 0; i < target_length; i++)	{		UINT8 source_byte = i < source_length ? source[i] : padding_byte;		m_state[m_state_counter] = m_state[m_state_counter] ^ source_byte;		m_state_counter = (m_state_counter + 1) % block_size;		if (!m_state_counter)		{			m_algorithm->Encrypt(m_state, target + i + 1 - block_size);			op_memmove(m_state, target + i + 1 - block_size, block_size);		}	}}

void CBaseTexture::ClampToEdge(){  unsigned int imagePitch = GetPitch(m_imageWidth);  unsigned int imageRows = GetRows(m_imageHeight);  unsigned int texturePitch = GetPitch(m_textureWidth);  unsigned int textureRows = GetRows(m_textureHeight);  if (imagePitch < texturePitch)  {    unsigned int blockSize = GetBlockSize();    unsigned char *src = m_pixels + imagePitch - blockSize;    unsigned char *dst = m_pixels;    for (unsigned int y = 0; y < imageRows; y++)    {      for (unsigned int x = imagePitch; x < texturePitch; x += blockSize)        memcpy(dst + x, src, blockSize);      dst += texturePitch;    }  }  if (imageRows < textureRows)  {    unsigned char *dst = m_pixels + imageRows * texturePitch;    for (unsigned int y = imageRows; y < textureRows; y++)    {      memcpy(dst, dst - texturePitch, texturePitch);      dst += texturePitch;    }  }}

void CBaseTexture::Allocate(unsigned int width, unsigned int height, unsigned int format){  m_imageWidth = width;  m_imageHeight = height;  m_format = format;  m_orientation = 0;  m_textureWidth = m_imageWidth;  m_textureHeight = m_imageHeight;  if (m_format & XB_FMT_DXT_MASK)    while (GetPitch() < g_Windowing.GetMinDXTPitch())      m_textureWidth += GetBlockSize();  if (!g_Windowing.SupportsNPOT((m_format & XB_FMT_DXT_MASK) != 0))  {    m_textureWidth = PadPow2(m_textureWidth);    m_textureHeight = PadPow2(m_textureHeight);  }  if (m_format & XB_FMT_DXT_MASK)  { // DXT textures must be a multiple of 4 in width and height    m_textureWidth = ((m_textureWidth + 3) / 4) * 4;    m_textureHeight = ((m_textureHeight + 3) / 4) * 4;  }  // check for max texture size  #define CLAMP(x, y) { if (x > y) x = y; }  CLAMP(m_textureWidth, g_Windowing.GetMaxTextureSize());  CLAMP(m_textureHeight, g_Windowing.GetMaxTextureSize());  CLAMP(m_imageWidth, m_textureWidth);  CLAMP(m_imageHeight, m_textureHeight);  delete[] m_pixels;  m_pixels = new unsigned char[GetPitch() * GetRows()];}

bool Engine<routing_algorithms::corech::Algorithm>::CheckCompability(const EngineConfig &config){    if (!Engine<routing_algorithms::ch::Algorithm>::CheckCompability(config))    {        return false;    }    if (config.use_shared_memory)    {        storage::SharedMonitor<storage::SharedDataTimestamp> barrier;        using mutex_type = typename decltype(barrier)::mutex_type;        boost::interprocess::scoped_lock<mutex_type> current_region_lock(barrier.get_mutex());        auto mem = storage::makeSharedMemory(barrier.data().region);        auto layout = reinterpret_cast<storage::DataLayout *>(mem->Ptr());        return layout->GetBlockSize(storage::DataLayout::CH_CORE_MARKER_0) >               sizeof(std::uint64_t) + sizeof(util::FingerPrint);    }    else    {        if (!boost::filesystem::exists(config.storage_config.GetPath(".osrm.core")))            return false;        storage::io::FileReader in(config.storage_config.GetPath(".osrm.core"),                                   storage::io::FileReader::VerifyFingerprint);        in.ReadElementCount64(); // number of core markers        const auto number_of_core_markers = in.ReadElementCount64();        return number_of_core_markers > 0;    }}

  void Compress_RG(const FasTC::CompressionJob &cj) {    rg_etc1::etc1_pack_params params;    params.m_quality = rg_etc1::cLowQuality;    rg_etc1::pack_etc1_block_init();    uint32 kBlockSz = GetBlockSize(FasTC::eCompressionFormat_ETC1);    const uint32 startBlock = cj.CoordsToBlockIdx(cj.XStart(), cj.YStart());    uint8 *outBuf = cj.OutBuf() + startBlock * kBlockSz;    const uint32 endY = std::min(cj.YEnd(), cj.Height() - 4);    uint32 startX = cj.XStart();    for(uint32 j = cj.YStart(); j <= endY; j += 4) {      const uint32 endX = j == cj.YEnd()? cj.XEnd() : cj.Width();      for(uint32 i = startX; i < endX; i += 4) {        uint32 pixels[16];        const uint32 *inPixels = reinterpret_cast<const uint32 *>(cj.InBuf());        memcpy(pixels, inPixels + j*cj.Width() + i, 4 * sizeof(uint32));        memcpy(pixels + 4, inPixels + (j+1)*cj.Width() + i, 4 * sizeof(uint32));        memcpy(pixels + 8, inPixels + (j+2)*cj.Width() + i, 4 * sizeof(uint32));        memcpy(pixels + 12, inPixels + (j+3)*cj.Width() + i, 4 * sizeof(uint32));        pack_etc1_block(outBuf, pixels, params);        outBuf += kBlockSz;      }      startX = 0;    }  }

bool FileBlockDevice::ReadBlocks(u32 minBlock, int count, u8 *outPtr) {	if (fileLoader_->ReadAt((u64)minBlock * (u64)GetBlockSize(), 2048, count, outPtr) != (size_t)count) {		ERROR_LOG(FILESYS, "Could not read %d bytes from block", 2048 * count);		return false;	}	return true;}

void CBaseTexture::Allocate(unsigned int width, unsigned int height, unsigned int format){  m_imageWidth = m_originalWidth = width;  m_imageHeight = m_originalHeight = height;  m_format = format;  m_orientation = 0;  m_textureWidth = m_imageWidth;  m_textureHeight = m_imageHeight;  if (m_format & XB_FMT_DXT_MASK)    while (GetPitch() < CServiceBroker::GetRenderSystem().GetMinDXTPitch())      m_textureWidth += GetBlockSize();  if (!CServiceBroker::GetRenderSystem().SupportsNPOT((m_format & XB_FMT_DXT_MASK) != 0))  {    m_textureWidth = PadPow2(m_textureWidth);    m_textureHeight = PadPow2(m_textureHeight);  }  if (m_format & XB_FMT_DXT_MASK)  { // DXT textures must be a multiple of 4 in width and height    m_textureWidth = ((m_textureWidth + 3) / 4) * 4;    m_textureHeight = ((m_textureHeight + 3) / 4) * 4;  }  else  {    // align all textures so that they have an even width    // in some circumstances when we downsize a thumbnail    // which has an uneven number of pixels in width    // we crash in CPicture::ScaleImage in ffmpegs swscale    // because it tries to access beyond the source memory    // (happens on osx and ios)    // UPDATE: don't just update to be on an even width;    // ffmpegs swscale relies on a 16-byte stride on some systems    // so the textureWidth needs to be a multiple of 16. see ffmpeg    // swscale headers for more info.    m_textureWidth = ((m_textureWidth + 15) / 16) * 16;  }  // check for max texture size  #define CLAMP(x, y) { if (x > y) x = y; }  CLAMP(m_textureWidth, CServiceBroker::GetRenderSystem().GetMaxTextureSize());  CLAMP(m_textureHeight, CServiceBroker::GetRenderSystem().GetMaxTextureSize());  CLAMP(m_imageWidth, m_textureWidth);  CLAMP(m_imageHeight, m_textureHeight);  _aligned_free(m_pixels);  m_pixels = NULL;  if (GetPitch() * GetRows() > 0)  {    size_t size = GetPitch() * GetRows();    m_pixels = (unsigned char*) _aligned_malloc(size, 32);    if (m_pixels == nullptr)    {      CLog::Log(LOGERROR, "%s - Could not allocate %zu bytes. Out of memory.", __FUNCTION__, size);    }  }}

bool RAMBlockDevice::ReadBlock(int blockNumber, u8 *outPtr) {	if (blockNumber >= 0 && blockNumber < totalBlocks_) {		u32 blockSize = GetBlockSize();		memcpy(outPtr, image_ + blockSize * blockNumber, blockSize);		return true;	}	return false;}

bool FileBlockDevice::ReadBlock(int blockNumber, u8 *outPtr) {	if (fileLoader_->ReadAt((u64)blockNumber * (u64)GetBlockSize(), 1, 2048, outPtr) != 2048) {		DEBUG_LOG(FILESYS, "Could not read 2048 bytes from block");		return false;	}	return true;}

bool FileBlockDevice::ReadBlock(int blockNumber, u8 *outPtr) {	fseek(f, blockNumber * GetBlockSize(), SEEK_SET);	if(fread(outPtr, 1, 2048, f) != 2048)		DEBUG_LOG(LOADER, "Could not read 2048 bytes from block");	return true;}

// Size of committed memory managed by this heap:int CSmallBlockPool::GetCommittedSize(){	unsigned totalSize = (unsigned)m_pCommitLimit - (unsigned)m_pBase;	Assert( 0 != m_nBlockSize );	Assert( 0 != ( totalSize % GetBlockSize() ) );	return totalSize;}

void RaspberryJammer::Reset(){  TRACE;  IMutexLock lock(this);  this->synth.Reset();  this->synth.SetSampleRate(GetSampleRate());  mMidiQueue.Resize(GetBlockSize());}

bool FileBlockDevice::ReadBlock(int blockNumber, u8 *outPtr, bool uncached) {	FileLoader::Flags flags = uncached ? FileLoader::Flags::HINT_UNCACHED : FileLoader::Flags::NONE;	if (fileLoader_->ReadAt((u64)blockNumber * (u64)GetBlockSize(), 1, 2048, outPtr, flags) != 2048) {		DEBUG_LOG(FILESYS, "Could not read 2048 bytes from block");		return false;	}	return true;}

void IPlugMultiTargets::Reset(){  TRACE;  IMutexLock lock(this);    mPhase = 0;  mNoteGain = 0.;  mSampleRate = GetSampleRate();  mMidiQueue.Resize(GetBlockSize());}

	void Cipher::EncryptBlocks (byte *data, size_t blockCount) const	{		if (!Initialized)			throw NotInitialized (SRC_POS);		while (blockCount-- > 0)		{			Encrypt (data);			data += GetBlockSize();		}	}

CItemField::CItemField(const CItemField &that)  : m_Type(that.m_Type), m_Length(that.m_Length){  if (m_Length > 0) {    size_t bs = GetBlockSize(m_Length);    m_Data = new unsigned char[bs];    memcpy(m_Data, that.m_Data, bs);  } else {    m_Data = NULL;  }}

shared_ptr<CustomProtectedStream>CustomProtectedStream::Create(  shared_ptr<UserPolicy>policy,  SharedStream          stream,  uint64_t              contentStartPosition,  uint64_t              contentSize){  Logger::Hidden("+CustomProtectedStream::Create");  if (policy.get() == nullptr) {    throw exceptions::RMSInvalidArgumentException("Invalid policy argument");  }  auto pCryptoProvider = policy->GetImpl()->GetCryptoProvider();  // create an IStreamImpl implementation of the backing stream  auto pBackingStreamImpl = stream;  // We want the cache block size to be 512 for cbc512, 4096 for cbc4k  // In case of ECB blocksize is 16, Keep cache block size to be 4k.  uint64_t nProtectedStreamBlockSize = pCryptoProvider->GetBlockSize() ==                                       512 ? 512 : 4096;  // The protected stream block size must be a multiple of crypto  // provider's block size,  // otherwise the stream can't encrypt/decypt correctly.  if (0 != nProtectedStreamBlockSize % pCryptoProvider->GetBlockSize()) {    throw exceptions::RMSCryptographyException("Invalid block size");  }  auto pProtectedStreamImpl = BlockBasedProtectedStream::Create(pCryptoProvider,                                                                pBackingStreamImpl,                                                                contentStartPosition,                                                                contentSize,                                                                nProtectedStreamBlockSize);  auto result =    shared_ptr<CustomProtectedStream>(new CustomProtectedStream(                                        pProtectedStreamImpl));  Logger::Hidden("-CustomProtectedStream::Create");  return result;}

void CBaseTexture::Allocate(unsigned int width, unsigned int height, unsigned int format){  m_imageWidth = m_originalWidth = width;  m_imageHeight = m_originalHeight = height;  m_format = format;  m_orientation = 0;  m_textureWidth = m_imageWidth;  m_textureHeight = m_imageHeight;  if (m_format & XB_FMT_DXT_MASK)    while (GetPitch() < g_Windowing.GetMinDXTPitch())      m_textureWidth += GetBlockSize();  if (!g_Windowing.SupportsNPOT((m_format & XB_FMT_DXT_MASK) != 0))  {    m_textureWidth = PadPow2(m_textureWidth);    m_textureHeight = PadPow2(m_textureHeight);  }  if (m_format & XB_FMT_DXT_MASK)  { // DXT textures must be a multiple of 4 in width and height    m_textureWidth = ((m_textureWidth + 3) / 4) * 4;    m_textureHeight = ((m_textureHeight + 3) / 4) * 4;  }  else  {    // align all textures so that they have an even width    // in some circumstances when we downsize a thumbnail    // which has an uneven number of pixels in width    // we crash in CPicture::ScaleImage in ffmpegs swscale    // because it tries to access beyond the source memory    // (happens on osx and ios)    // UPDATE: don't just update to be on an even width;    // ffmpegs swscale relies on a 16-byte stride on some systems    // so the textureWidth needs to be a multiple of 16. see ffmpeg    // swscale headers for more info.    m_textureWidth = ((m_textureWidth + 15) / 16) * 16;  }  // check for max texture size  #define CLAMP(x, y) { if (x > y) x = y; }  CLAMP(m_textureWidth, g_Windowing.GetMaxTextureSize());  CLAMP(m_textureHeight, g_Windowing.GetMaxTextureSize());  CLAMP(m_imageWidth, m_textureWidth);  CLAMP(m_imageHeight, m_textureHeight);  delete[] m_pixels;  m_pixels = NULL;  if (GetPitch() * GetRows() > 0)  {    m_pixels = new unsigned char[GetPitch() * GetRows()];  }}

static void MergeFreeBlock(void* block){   void* previous, *current = block;   void* next;   unsigned uprevious, unext, size;   uprevious = ((struct FreeListElement*) block)->positionprev;   unext = ((struct FreeListElement*) block)->positionnext;   if (FreePositionHead != block)   {      previous = ABSOLUTEPOINTER(uprevious);            size = ((struct FreeListElement*) previous)->size;      if (((char*) previous+size) == block)      {         ((struct FreeListElement*) previous)->size += GetBlockSize(block);	 RemoveFromSizeList(previous);	 RemoveFromSizeList(block);	 InsertIntoFreeList(previous);	 RemoveBlockFromPositionList(block);         current = previous;      }   }   if (unext)   {      next = ABSOLUTEPOINTER(unext);      if (((char*)current+GetBlockSize(current)) == next)      {         ((struct FreeListElement*) current)->size += GetBlockSize(next);	 RemoveFromSizeList(current);	 RemoveFromSizeList(next);	 InsertIntoFreeList(current);	 RemoveBlockFromPositionList(next);      }   }}

DualErr Volume::Write(PGPUInt8 *buf, PGPUInt64 pos, PGPUInt32 nBlocks){	DualErr derr;	pgpAssertAddrValid(buf, PGPUInt8);	pgpAssert(Mounted());	pgpAssert(LockedForReadWrite() || LockedForFormat());	derr = DirectDiskWrite(mDrive, buf, nBlocks * GetBlockSize(), pos, 		nBlocks);	return derr;}

CItemField &CItemField::operator=(const CItemField &that){  if (this != &that) {    m_Type = that.m_Type;    m_Length = that.m_Length;    delete[] m_Data;    if (m_Length > 0) {      size_t bs = GetBlockSize(m_Length);      m_Data = new unsigned char[bs];      memcpy(m_Data, that.m_Data, bs);    } else {      m_Data = NULL;    }  }  return *this;}