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

			Air::U1 Buffer11::Read( U32 uiOffset,U32 uiSize,void* pData )			{				DxContext*	pContext	=	(DxContext*)(pDevice->GetContext());				ID3D11Resource*	pResource	=	(ID3D11Resource*)GetBuffer();				D3D11_MAPPED_SUBRESOURCE res;				HRESULT	hr	=	pContext->Map(pResource,0,D3D11_MAP_READ,0,&res);				if(SUCCEEDED(hr)){					U8*	pDst	=	(U8*)res.pData;					memcpy(pData,&pDst[uiOffset],uiSize);					pContext->Unmap(pResource,0);				}				return true;			}

// Delete       - Deletes a segment of the string and resizes it// Returns      - Reference to the same string object// pos          - Position of the string segment to remove// len          - Number of characters to removeCStringEx& CStringEx::Delete(int pos, int len){        int strLen = GetLength();        if( pos >= strLen)                return *this;        if(len < 0 ||len > strLen - pos)                len = strLen - pos;        LPTSTR str = GetBuffer( strLen );        memmove(str+pos, str+pos+len, sizeof(_T(' ')) *(strLen-pos));        ReleaseBuffer( strLen - len );        return *this;}

// TODO: this code require full information about editabel register in dialog// TODO: to make editable all registers which is outputvoid RegRichTextCtrl::OnLeftDClick(wxMouseEvent& event){	wxClientDC dc(this);	PrepareDC(dc);	dc.SetFont(GetFont());	long position = 0;	GetBuffer().HitTest(dc, event.GetLogicalPosition(dc), position);	long linePos = GetBuffer().GetVisibleLineNumber(position, true, true);	wxString line = GetLineText(linePos);	const size_t szRegNames = 15;	for (size_t i = 0; i < szRegNames; ++i)		if (line.Find(RegistersName[i]) != wxNOT_FOUND)	{		wxString str = GetStringSelection();		bool bShowEditBox = true;		for (size_t k = 0; k < szRegNames; ++k)		{			if ( 0 == str.Cmp(RegistersName[k]) )			{				bShowEditBox = false;				break;			}		}		if (bShowEditBox)		{			EditRegister(RegistersName[i], str);			break;		}	}}

static ParseStatus ReadHeader(MemBuffer* const mem) {  const size_t min_size = RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE;  uint32_t riff_size;  // Basic file level validation.  if (MemDataSize(mem) < min_size) return PARSE_NEED_MORE_DATA;  if (memcmp(GetBuffer(mem), "RIFF", CHUNK_SIZE_BYTES) ||      memcmp(GetBuffer(mem) + CHUNK_HEADER_SIZE, "WEBP", CHUNK_SIZE_BYTES)) {    return PARSE_ERROR;  }  riff_size = GetLE32(GetBuffer(mem) + TAG_SIZE);  if (riff_size < CHUNK_HEADER_SIZE) return PARSE_ERROR;  if (riff_size > MAX_CHUNK_PAYLOAD) return PARSE_ERROR;  // There's no point in reading past the end of the RIFF chunk  mem->riff_end_ = riff_size + CHUNK_HEADER_SIZE;  if (mem->buf_size_ > mem->riff_end_) {    mem->buf_size_ = mem->end_ = mem->riff_end_;  }  Skip(mem, RIFF_HEADER_SIZE);  return PARSE_OK;}

	size_t GarlicRoutingSession::CreateDeliveryStatusClove (uint8_t * buf, uint32_t msgID)	{		size_t size = 0;		if (m_Owner)		{			auto inboundTunnel = m_Owner->GetTunnelPool ()->GetNextInboundTunnel ();			if (inboundTunnel)			{				buf[size] = eGarlicDeliveryTypeTunnel << 5; // delivery instructions flag tunnel				size++;				// hash and tunnelID sequence is reversed for Garlic				memcpy (buf + size, inboundTunnel->GetNextIdentHash (), 32); // To Hash				size += 32;				htobe32buf (buf + size, inboundTunnel->GetNextTunnelID ()); // tunnelID				size += 4;				// create msg				auto msg = CreateDeliveryStatusMsg (msgID);				if (m_Owner)				{					//encrypt					uint8_t key[32], tag[32];					RAND_bytes (key, 32); // random session key					RAND_bytes (tag, 32); // random session tag					m_Owner->SubmitSessionKey (key, tag);					GarlicRoutingSession garlic (key, tag);					msg = garlic.WrapSingleMessage (msg);				}				memcpy (buf + size, msg->GetBuffer (), msg->GetLength ());				size += msg->GetLength ();				// fill clove				uint64_t ts = i2p::util::GetMillisecondsSinceEpoch () + 8000; // 8 sec				uint32_t cloveID;				RAND_bytes ((uint8_t *)&cloveID, 4);				htobe32buf (buf + size, cloveID); // CloveID				size += 4;				htobe64buf (buf + size, ts); // Expiration of clove				size += 8;				memset (buf + size, 0, 3); // certificate of clove				size += 3;			}			else				LogPrint (eLogError, "Garlic: No inbound tunnels in the pool for DeliveryStatus");		}		else			LogPrint (eLogWarning, "Garlic: Missing local LeaseSet");		return size;	}

		void RenderLine(uint8 *pStart, float xOff, float vLineTop, float vLineBottom, int nCursor, int nSelStart, int nSelEnd, View *pcView, bool bSelected)		{						Color32_s sCursCol(40,40,40);			Color32_s sCursLineCol(255,235,186);						if( ! bSelected )			{				sCursCol = lighten_color(sCursCol);				sCursLineCol = lighten_color(sCursLineCol);			}					float vCharWidth = GetCharWidth();			float vCharHeight = GetCharHeight();						uint8 *pEnd = GetBuffer() + GetBufferLength();			static char zLine[(BYTES_PER_LINE) + 1];			for( int x = 0; x < BYTES_PER_LINE; x++ )			{				uint8 *p = pStart + x;				zLine[x] = p >= pEnd || *p < 32 || *p > 126?'.':*p;			}								Rect cRect(xOff + GetX() + 2, vLineTop, xOff + GetX() + GetWidth() - 2, vLineBottom);						pcView->SetFgColor(Color32_s(0,0,0));			if( nSelStart < 0 )			{								if( nCursor >= 0 )					pcView->FillRect(cRect, sCursLineCol);								pcView->DrawText(cRect, zLine);					if( nCursor >= 0 )							{					float vCursorX = cRect.left + (vCharWidth * nCursor);					pcView->SetFgColor(sCursCol);					pcView->DrawLine(Point(vCursorX, vLineTop), Point(vCursorX, vLineBottom));					vCursorX++;					pcView->DrawLine(Point(vCursorX, vLineTop), Point(vCursorX, vLineBottom));				}			}			else			{				IPoint cSel1((int)(nSelStart * vCharWidth), (int)vCharHeight);				IPoint cSel2((int)((nSelEnd * vCharWidth) + 1), (int)vCharHeight);				pcView->DrawSelectedText(cRect, zLine, cSel1, cSel2, SEL_CHAR);			}		}

HRESULT CLR_RT_HeapBlock_XmlReader::Read(){    TINYCLR_HEADER();    CLR_RT_XmlState* state = GetState();    state->State.bufferStart = GetBuffer();    state->State.buffer      = state->State.bufferStart + GetOffset();    state->State.bufferEnd   = state->State.buffer + GetLength();    state->State.reader      = this;    if(state->State.initFn)    {        state->State.initFn( state );    }    while(true)    {        TINYCLR_CHECK_HRESULT(state->State.stateFn( state ));    }    TINYCLR_CLEANUP();    if(hr == XML_E_NEED_MORE_DATA)    {        if(state->State.cleanUpFn)        {            state->State.cleanUpFn( state );        }        else        {            state->State.ShiftBuffer( state->State.buffer );        }        // if after buffer adjustment, there's no room for new data, then we know that        // we've exceeded one of the system constraints (either the length of name or        // attribute value is over buffer size)        if(state->State.bufferEnd - state->State.bufferStart == XmlBufferSize)        {            hr = XML_E_LIMIT_EXCEEDED;        }    }    SetOffset( state->State.buffer    - state->State.bufferStart );    SetLength( state->State.bufferEnd - state->State.buffer      );    TINYCLR_CLEANUP_END();}

boolBufferTextureClient::AllocateForSurface(gfx::IntSize aSize){  MOZ_ASSERT(IsValid());  MOZ_ASSERT(mFormat != gfx::FORMAT_YUV, "This textureClient cannot use YCbCr data");  int bufSize    = ImageDataSerializer::ComputeMinBufferSize(aSize, mFormat);  if (!Allocate(bufSize)) {    return false;  }  ImageDataSerializer serializer(GetBuffer());  serializer.InitializeBufferInfo(aSize, mFormat);  mSize = aSize;  return true;}

void Binarization::HMT(unsigned char *buffer_in, unsigned char *buffer_out, bool inverse) {	set_structure_element(mixture_structure_element_2_);	unsigned char *buffer = GetBuffer(BUFFER_INTERMEDIATE - 1);	Invert(buffer_in, buffer);	Erode(buffer, buffer, inverse);	set_structure_element(mixture_structure_element_1_);	Erode(buffer_in, buffer_out, inverse);	for(int i = 1; i < height_ - 1; i++)		for(int j = 1; j < width_ - 1; j++) {			buffer_out[(i * width_ + j) * 3 + 2] = inverse ? buffer_out[(i * width_ + j) * 3 + 2] | buffer[(i * width_ + j) * 3 + 2] : buffer_out[(i * width_ + j) * 3 + 2] & buffer[(i * width_ + j) * 3 + 2];			buffer_out[(i * width_ + j) * 3 + 1] = inverse ? buffer_out[(i * width_ + j) * 3 + 1] | buffer[(i * width_ + j) * 3 + 1] : buffer_out[(i * width_ + j) * 3 + 1] & buffer[(i * width_ + j) * 3 + 1];			buffer_out[(i * width_ + j) * 3 + 0] = inverse ? buffer_out[(i * width_ + j) * 3 + 0] | buffer[(i * width_ + j) * 3 + 0] : buffer_out[(i * width_ + j) * 3 + 0] & buffer[(i * width_ + j) * 3 + 0];		}}

boolBufferTextureData::BorrowMappedData(MappedTextureData& aData){  if (GetFormat() == gfx::SurfaceFormat::YUV) {    return false;  }  gfx::IntSize size = GetSize();  aData.data = GetBuffer();  aData.size = size;  aData.format = GetFormat();  aData.stride = ImageDataSerializer::ComputeRGBStride(aData.format, size.width);  return true;}

LPSTR IUrlDownloader::CreateCharCopy() const{    ASSERT(GetStatus() == S_Success);    LPSTR ret = NULL;    if (GetStatus() == S_Success)    {        UINT bfLen = GetBufferSize();        if (bfLen > 0)        {            ret = new CHAR[bfLen + 1];            strncpy(ret, (LPCSTR)GetBuffer(), bfLen);            ret[bfLen] = 0;        }    }    return ret;}

      /// ctor; parses event data      CameraEventData(prVoid* pEventData)         :m_uiEventCode(0)      {         BYTE* pbData = reinterpret_cast<BYTE*>(pEventData);         std::vector<BYTE>& vecBuffer = GetBuffer();         vecBuffer.assign(pbData, pbData + 12);// at least 12 bytes         // read length of event data         prUInt32 uiLength = ReadUint32();         vecBuffer.assign(pbData, pbData + uiLength);         unsigned int uiNumParams = (uiLength - 12) / 4;         Parse(uiNumParams);      }

void ImageProcessing::Output(const char *output, int buffer_num) {	std::ofstream ofs(output, std::ifstream::binary);	ofs.write((char *)head_, head_size_);	unsigned char *canvas = GetBuffer(buffer_num);	for(int i = 0; i < height_; i++)		for(int j = 0; j < width_; j++) {			image_[image_size_ / height_ * i + j * 3 + 2] = canvas[(i * width_ + j) * 3 + 2];			image_[image_size_ / height_ * i + j * 3 + 1] = canvas[(i * width_ + j) * 3 + 1];			image_[image_size_ / height_ * i + j * 3 + 0] = canvas[(i * width_ + j) * 3 + 0];		}	ofs.write((char *)image_, image_size_);	ofs.close();}

void CComplexBinary::Append (CDatum dDatum)//	Append////	Appends data	{	const CString &sNewData = dDatum;	if (sNewData.GetLength() == 0)		return;	//	Compute the new length	int iOldLen = GetLength();	int iNewLen = iOldLen + sNewData.GetLength();	//	Allocate a new buffer	char *pNewBuffer = new char [sizeof(DWORD) + iNewLen + 1];	char *pPos = pNewBuffer;	*(DWORD *)pPos = iNewLen;	pPos += sizeof(DWORD);	//	Copy the original data	if (iOldLen)		{		utlMemCopy(m_pData, pPos, iOldLen);		pPos += iOldLen;		}	//	Copy the new data	utlMemCopy(sNewData.GetParsePointer(), pPos, sNewData.GetLength());	pPos += sNewData.GetLength();	//	NULL-terminator	*pPos++ = '/0';	//	Free our original buffer and swap	if (m_pData)		delete [] GetBuffer();	m_pData = pNewBuffer + sizeof(DWORD);	}

void CFileName::ReplaceExtension(LPCTSTR pszNewExt){  ASSERT(pszNewExt);  if(_TCHAR('.')==*pszNewExt){    // Be tolerant of whether '.' is included in what we are passed:    pszNewExt++;  }  LPTSTR pch=GetBuffer(2+GetLength()+_tcslen(pszNewExt));  LPTSTR pcExt=_tcsrchr(pch,_TCHAR('.'));  if(NULL==pcExt || _tcschr(pcExt,cSep)){    // No existing extension    pcExt=pch+GetLength();    *pcExt++=_TCHAR('.');  }  _tcscpy(pcExt+1,pszNewExt);  ReleaseBuffer();}

voidContentClientSingleBuffered::SyncFrontBufferToBackBuffer(){  if (!mFrontAndBackBufferDiffer) {    return;  }  if (SupportsAzureContent()) {    DrawTarget* backBuffer = GetDTBuffer();    if (!backBuffer && mDeprecatedTextureClient) {      backBuffer = mDeprecatedTextureClient->LockDrawTarget();    }    RefPtr<DrawTarget> oldBuffer;    oldBuffer = SetDTBuffer(backBuffer,                            mBufferRect,                            mBufferRotation);    backBuffer = GetDTBufferOnWhite();    if (!backBuffer && mDeprecatedTextureClientOnWhite) {      backBuffer = mDeprecatedTextureClientOnWhite->LockDrawTarget();    }    oldBuffer = SetDTBufferOnWhite(backBuffer);  } else {    gfxASurface* backBuffer = GetBuffer();    if (!backBuffer && mDeprecatedTextureClient) {      backBuffer = mDeprecatedTextureClient->LockSurface();    }    nsRefPtr<gfxASurface> oldBuffer;    oldBuffer = SetBuffer(backBuffer,                          mBufferRect,                          mBufferRotation);    backBuffer = GetBufferOnWhite();    if (!backBuffer && mDeprecatedTextureClientOnWhite) {      backBuffer = mDeprecatedTextureClientOnWhite->LockSurface();    }    oldBuffer = SetBufferOnWhite(backBuffer);  }  mIsNewBuffer = false;  mFrontAndBackBufferDiffer = false;}

static void parseBreakpointWatchpointCommandArguments(BreakpointWatchpointArguments* pArguments){    Buffer*    pBuffer = GetBuffer();        __try    {        __throwing_func( pArguments->type = Buffer_ReadChar(pBuffer) );        __throwing_func( ThrowIfNextCharIsNotEqualTo(pBuffer, ',') );        __throwing_func( pArguments->address = ReadUIntegerArgument(pBuffer) );        __throwing_func( ThrowIfNextCharIsNotEqualTo(pBuffer, ',') );        __throwing_func( pArguments->kind = ReadUIntegerArgument(pBuffer) );    }    __catch    {        __rethrow;    }}

WrappedIDXGISwapChain2::WrappedIDXGISwapChain2(IDXGISwapChain* real, HWND wnd, WrappedID3D11Device *device)	: RefCountDXGIObject(real), m_pReal(real), m_pDevice(device), m_iRefcount(1), m_Wnd(wnd){	DXGI_SWAP_CHAIN_DESC desc;	real->GetDesc(&desc);	#if defined(INCLUDE_DXGI_1_2)	m_pReal1 = NULL;	real->QueryInterface(__uuidof(IDXGISwapChain1), (void **)&m_pReal1);	m_pReal2 = NULL;	real->QueryInterface(__uuidof(IDXGISwapChain2), (void **)&m_pReal2);#endif	int bufCount = desc.BufferCount;	if(desc.SwapEffect == DXGI_SWAP_EFFECT_DISCARD)		bufCount = 1;	RDCASSERT(bufCount < MAX_NUM_BACKBUFFERS);	for(int i=0; i < MAX_NUM_BACKBUFFERS; i++)	{		m_pBackBuffers[i] = NULL;		if(i < bufCount)		{			GetBuffer(i, __uuidof(ID3D11Texture2D), (void **)&m_pBackBuffers[i]);			WrappedID3D11Texture2D *wrapped = (WrappedID3D11Texture2D *)m_pBackBuffers[i];			if(wrapped)			{				// keep ref as a 'view' (invisible to user)				wrapped->ViewAddRef();				wrapped->Release();			}		}	}	SAFE_ADDREF(m_pDevice);	// we do a 'fake' present right at the start, so that we can capture frame 1, by	// going from this fake present to the first present.	m_pDevice->FirstFrame(this);}

int CxString :: GetPrivateProfileString( const char *sec, const char *ent,				const char *def, int size, const char *file ){	if (NULL == file || 0 == strlen(file))	// ohne ini-Dateiname kein Resultat		return 0;		int		result = size;char	*text;	ASSERT( def );	ASSERT( file );	if ( result <= 10 ) result = 10;	text = GetBuffer( result );	result = ::GetPrivateProfileString( sec, ent, def, text, result, file );	ReleaseBuffer();	return result;}	// GetPrivateProfileString

voidprefix::CRenderableVideo::Update( float fSeconds ){     // decode next frame from the stream.     SeekNextFrameFromStream(static_cast<int>(fSeconds*1000.0f));     //UpdateBuffer();     // prepare frame buffer for rendering     m_Renderer.CommitFrameBufferSingle(*m_pFrameBufferObj, 0);     // flip image vertically     glRasterPos2i( 0, 240);     glPixelZoom(1,-1);     //glRasterPos2i(0,0);     // put pixels into buffer     glDrawPixels(GetWidth(),GetHeight(), GL_RGB, GL_UNSIGNED_BYTE, GetBuffer());     // restore things back to normal     glPixelZoom(1,1);     m_Renderer.RollbackFrameBuffer( *m_pFrameBufferObj );}

boolMemBuffer::Compare(const vector<uint8_t> &compTo){    if (compTo.size() != GetBufSize()) {        throw FrmwkEx(HERE, "Compare buffers not same size: %d != %d",                      compTo.size(), GetBufSize());    }    vector<uint8_t>::const_iterator iterCompTo = compTo.begin();    uint8_t *iterThis = GetBuffer();    for (size_t i = 0; i < GetBufSize(); i++, iterCompTo++, iterThis++) {        if (*iterCompTo != *iterThis) {            LOG_ERR("Detected data miscompare @ index = %ld(0x%08lX)", i, i);            return false;        }    }    return true;}

CHistogram3D CHistogram3D::operator -(const CHistogram3D &histo) const{    if (histo.iNbBins!=iNbBins || histo.iPadding!=iPadding)	{        cerr<<"ERROR in CHistogram3D::operator -(...): histograms have different sizes"<<endl;        return *this;	}    if (histo.fRangeMin!=fRangeMin || histo.fRangeMax!=fRangeMax)	{        cerr<<"ERROR in CHistogram3D::operator -(...): histograms have different ranges"<<endl;        return *this;	}    CHistogram3D histoRes;    int i, iSize;    const float *pValue, *pValue2;    float *pValueRes;    histoRes.iNbBins = iNbBins;    histoRes.iPadding = iPadding;    histoRes.fGaussianStdDeviation = fGaussianStdDeviation;    histoRes.arrayGaussian = arrayGaussian;    histoRes.fRangeMin = fRangeMin;    histoRes.fRangeMax = fRangeMax;    histoRes.fSumWeights = fSumWeights - histo.fSumWeights;    histoRes.Init(iNbBins + CTriplet<int>(iPadding, iPadding, iPadding)*2);    iSize = CArray1D<float>::GetSize();    pValue = GetBuffer();    pValue2 = histo.GetBuffer();    pValueRes = histoRes.GetBuffer();    for (i=0; i<iSize; i++)    {        *pValueRes = *pValue - *pValue2;        pValue++;        pValue2++;        pValueRes++;    }    return histoRes;}

bool Source::Play(bool bRestart){    // Is a buffer loaded?    Buffer *pBuffer = static_cast<Buffer*>(GetBuffer());    if (!pBuffer)        return false; // Error!    // Paused?    if (IsPaused() && !bRestart) {        FSOUND_SetPaused(m_nChannel, 0);    } else {        // Play        if (IsPlaying()) {            if (!bRestart)                return true; // Done            Stop();        }        m_nChannel = pBuffer->Play();        // Add source to sound manager        static_cast<SoundManager&>(GetSoundManager()).AddActiveSource(*this);        // Get frequency and setup pitch        m_nFrequency = FSOUND_GetFrequency(m_nChannel);        float fPitch = m_fPitch;        m_fPitch = -1.0f;        SetPitch(fPitch);        // Set volume        pBuffer->SetVolume(m_nChannel, m_fVolume);        // [HACK] HW sound: We have to pause the playback if we want to change the looping mode...        //	FSOUND_SetPaused(m_nChannel, 1);        pBuffer->SetLooping(m_nChannel, m_bLooping);        //	FSOUND_SetPaused(m_nChannel, 0);        // Set attributes        SetAttribute(Position, m_vAttributes[Position]);        SetAttribute(Velocity, m_vAttributes[Velocity]);    }    // Done    return true;}

//Levanta del buffer de su TTY un scancodeint GetKey(){	int key;	char* video= (char*)0xB8000;	BUFFERTYPE* mibuffer;	mibuffer=GetBuffer();	if((mibuffer->tail)==(mibuffer->head))	{		return -1;	}	else	{		key=mibuffer->buffer[mibuffer->head]&0xFF;		mibuffer->head=(mibuffer->head+1)%10;	}		return key;}

	int _Unpack(lua_State* L)	{		size_t sz = 0;		void * buffer = GetBuffer(L, 1, &sz);		void * output = lua_touserdata(L, lua_upvalueindex(1));		int osz = lua_tointeger(L, lua_upvalueindex(2));		int r = Zerounpack(buffer, sz, output, &osz);		if (r < 0)			return luaL_error(L, "Invalid unpack stream");		if (r > osz) {			output = ExpandBuffer(L, osz, r);			r = Zerounpack(buffer, sz, output, &r);			if (r < 0)				return luaL_error(L, "Invalid unpack stream");		}				lua_pushlstring(L, (const char*)output, r);		return 1;	}

void COXString::Format(LPCTSTR pszFormat, LPCTSTR* rgpsz, int nString){	// NOTE: will not work for strings > 255 characters	int nTotalLen = PtrToInt(_tcslen(pszFormat));	int i = 0;	for (i = 0; i < nString; i++)	{		if (rgpsz[i] != NULL)			nTotalLen += PtrToInt(_tcslen(rgpsz[i]));	}	LPCTSTR pchSrc = pszFormat;	LPTSTR pchDestBegin  =  GetBuffer(nTotalLen+1);	LPTSTR pchDest = pchDestBegin;	while (*pchSrc != '/0')	{		if (pchSrc[0] == _T('%') && (pchSrc[1] >= _T('1') && pchSrc[1] <= _T('9')))		{			i = pchSrc[1] - _T('1');			pchSrc += 2;			if (i >= nString)			{				TRACE1("COXString::Format : Illegal string index requested %d/n", i);				*pchDest++ = _T('?');			}   				else if (rgpsz[i] != NULL)			{				UTBStr::tcscpy(pchDest, nTotalLen, rgpsz[i]);				pchDest += _tcslen(pchDest);			}		}		else		{			*pchDest++ = *pchSrc++;		}	}	ReleaseBuffer((int)((LPCTSTR)pchDest - (LPCTSTR)pchDestBegin));	// Release will assert if we went too far}