bool IOBuffer::ReadFromUDPFd(int32_t fd, int32_t &recvAmount, sockaddr_in &peerAddress) {
SANITY_INPUT_BUFFER;
if (_published + 65536 > _size) {
if (!EnsureSize(65536)) {
SANITY_INPUT_BUFFER;
return false;
}
}
recvAmount = recvfrom(fd, (char *) (_pBuffer + _published), 65536,
MSG_NOSIGNAL, (sockaddr *) & peerAddress, &_dummy);
if (recvAmount > 0) {
_published += (uint32_t) recvAmount;
SANITY_INPUT_BUFFER;
return true;
} else {
#ifdef WIN32
uint32_t err = LASTSOCKETERROR;
if (err == SOCKERROR_RECV_CONN_RESET) {
WARN("Windows is stupid enough to issue a CONNRESET on a UDP socket. See http://support.microsoft.com/?kbid=263823 for details");
SANITY_INPUT_BUFFER;
return true;
}
#endif
FATAL("Unable to read data from UDP socket. Error was: %"PRIu32, LASTSOCKETERROR);
SANITY_INPUT_BUFFER;
return false;
}
}
//============================================================
TBool FFileString16::LoadFile(TCharC* pFileName){
// 打开文件
TFileHandle handle;
#ifdef _MO_WINDOWS
MO_LIB_FILE_OPEN(&handle, pFileName, TC("rb"));
#else
handle = fopen(pFileName, TC("rb"));
#endif
if(NULL == handle){
MO_PERROR(fopen);
return EFalse;
}
// 获得长度
if(ESuccess != fseek(handle, 0, SEEK_END)){
MO_PERROR(fseek);
return EFalse;
}
TInt length = ftell(handle);
EnsureSize(length);
// 从开始位置读取
if(ESuccess != fseek(handle, 0, SEEK_SET)){
MO_PERROR(fseek);
return EFalse;
}
TInt readed = fread(_pMemory, length, 1, handle);
if(1 != readed){
MO_PFATAL(fread);
}
_length = length;
// 关闭文件
if(ESuccess != fclose(handle)){
MO_PFATAL(fclose);
}
return ETrue;
}
void CINFManager::Append(CINFManager& Manager, const CVector<int>& DispTable, CIndex * Parent) {
cout << " [merging INFs]"; cout.flush();
CProgress Progress(10);
bool bIdentical = false;
int DispTableMax = 0;
for (register int d=0;d<(int)DispTable.GetSize();d++)
DispTableMax = (DispTableMax < DispTable[d])?DispTable[d]:DispTableMax;
EnsureSize(DispTableMax + 1);
for (register int i=0;i<(int) Manager.GetSize();i++) {
int DispTableIndex = DispTable[i];
Progress.Show(i, Manager.GetSize());
/* if target is empty */
if (!Manager.GetSize(i)) {
/* the other one is not indexed */
} else if (!m_INFVector[DispTableIndex].GetSize()) {
/* the other one is indexed, but local is not */
m_INFVector[DispTableIndex] = Manager[i];
} else {
/* both sides have indexed the page, keep it as is, should get the most recent*/
if (m_INFVector[DispTableIndex] != Manager[i]) {
if (!bIdentical) {
cout << "{\n [warning, identical urls are referenced in both indexes]";
bIdentical = true;
}
cout << "\n {url: " << Parent->GetURLLink(DispTableIndex) << "}";
cout.flush();
}
}
}
Progress.Finish();
cout << "[" << m_INFVector.GetSize() << " INF entries]" << endl;
}
bool IOBuffer::ReadFromUDPFd(int32_t fd, int32_t &recvAmount, sockaddr_in &peerAddress) {
SANITY_INPUT_BUFFER;
if (_published + 65536 > _size) {
if (!EnsureSize(65536)) {
SANITY_INPUT_BUFFER;
return false;
}
}
recvAmount = recvfrom(fd, (char *) (_pBuffer + _published), 65536,
MSG_NOSIGNAL, (sockaddr *) & peerAddress, &_dummy);
if (recvAmount > 0) {
_published += (uint32_t) recvAmount;
SANITY_INPUT_BUFFER;
return true;
} else {
int err = LASTSOCKETERROR;
#ifdef WIN32
//Patch from https://groups.google.com/forum/#!msg/c-rtmp-server/6W0iHZ8fS_w/b4c5ODm1NfUJ
if ((err == WSAECONNRESET) ||
(err == WSAENETRESET) ||
(err == WSAEMSGSIZE)) {
WARN("Windows is stupid enough to issue a CONNRESET on a UDP socket. See http://support.microsoft.com/?kbid=263823 for details");
SANITY_INPUT_BUFFER;
return true;
}
#endif /* WIN32 */
FATAL("Unable to read data from UDP socket. Error was: %d", err);
SANITY_INPUT_BUFFER;
return false;
}
}
void MemoryStream::Write(const uint32_t size, const void* pData)
{
EnsureSize(size);
uint32_t* pointer = reinterpret_cast<uint32_t*>(m_data + m_position);
memcpy(pointer, pData, size);
m_position += size;
}
bool IOBuffer::ReadFromTCPFd(int32_t fd, uint32_t expected, int32_t &recvAmount) {
SANITY_INPUT_BUFFER;
if (_published + expected > _size) {
if (!EnsureSize(expected)) {
SANITY_INPUT_BUFFER;
return false;
}
}
recvAmount = recv(fd, (char *) (_pBuffer + _published), expected, MSG_NOSIGNAL);
if (recvAmount > 0) {
_published += (uint32_t) recvAmount;
SANITY_INPUT_BUFFER;
return true;
} else {
int err = LASTSOCKETERROR;
if ((err != SOCKERROR_EAGAIN)&&(err != SOCKERROR_EINPROGRESS)) {
FATAL("Unable to read data. Size advertised by network layer was %"PRIu32". Permanent error: %d",
expected, err);
SANITY_INPUT_BUFFER;
return false;
}
// else {
// WARN("SOCKERROR_EAGAIN or SOCKERROR_EINPROGRESS encountered");
// }
return true;
}
}
bool IOBuffer::ReadFromPipe(int32_t fd, uint32_t expected, int32_t &recvAmount) {
//TODO: This is an UGLY hack.
#ifndef WIN32
SANITY_INPUT_BUFFER;
if (_published + expected > _size) {
if (!EnsureSize(expected)) {
SANITY_INPUT_BUFFER;
return false;
}
}
recvAmount = read(fd, (char *) (_pBuffer + _published), expected);
if (recvAmount > 0) {
_published += (uint32_t) recvAmount;
SANITY_INPUT_BUFFER;
return true;
} else {
int err = errno;
if (err != EINPROGRESS) {
FATAL("Unable to read from pipe: (%d) %s", err, strerror(err));
SANITY_INPUT_BUFFER;
return false;
}
SANITY_INPUT_BUFFER;
return true;
}
#else
NYIA;
return false;
#endif
}
void IOBuffer::ReadFromByte(uint8_t byte) {
SANITY_INPUT_BUFFER;
EnsureSize(1);
_pBuffer[_published] = byte;
_published++;
SANITY_INPUT_BUFFER;
}
//=================================================================================================
bool QuestManager::Read(BitStream& stream)
{
const int QUEST_MIN_SIZE = sizeof(int) + sizeof(byte) * 3;
word quest_count;
if(!stream.Read(quest_count)
|| !EnsureSize(stream, QUEST_MIN_SIZE * quest_count))
{
Error("Read world: Broken packet for quests.");
return false;
}
quests.resize(quest_count);
int index = 0;
for(Quest*& quest : quests)
{
quest = new PlaceholderQuest;
quest->quest_index = index;
if(!stream.Read(quest->refid) ||
!stream.ReadCasted<byte>(quest->state) ||
!ReadString1(stream, quest->name) ||
!ReadStringArray<byte, word>(stream, quest->msgs))
{
Error("Read world: Broken packet for quest %d.", index);
return false;
}
++index;
}
return true;
}
void IOBuffer::ReadFromRepeat(uint8_t byte, uint32_t size) {
SANITY_INPUT_BUFFER;
EnsureSize(size);
memset(_pBuffer + _published, byte, size);
_published += size;
SANITY_INPUT_BUFFER;
}
void IOBuffer::Initialize(uint32_t expected) {
if ((_pBuffer != NULL) ||
(_size != 0) ||
(_published != 0) ||
(_consumed != 0))
ASSERT("This buffer was used before. Please initialize it before using");
EnsureSize(expected);
}
/**
* @param pszStrData - data source.
* @param nLength - string length.
*/
void CStrStream::AppendData(PCTSTR pszStrData, size_t nLength)
{
if (pszStrData && *pszStrData)
{
size_t nNewLength = m_nLength + nLength;
EnsureSize(nNewLength + 1, true);
_tcsncpy_s(m_pszData + m_nLength, nLength + 1, pszStrData, nLength);
m_nLength = nNewLength;
}
}
/**
* @param pszSubstring - inserted string buffer.
* @param nPosition - start position.
* @param nLength - length of the inserted string.
*/
void CStrStream::Insert(PCTSTR pszSubstring, size_t nPosition, size_t nLength)
{
ValidateIndex(nPosition);
size_t nNewLength = m_nLength + nLength;
EnsureSize(nNewLength + 1, true);
size_t nNextPosition = nPosition + nLength;
size_t nNextLength = m_nLength - nPosition;
MoveMemory(m_pszData + nNextPosition, m_pszData + nPosition, (nNextLength + 1) * sizeof(TCHAR));
MoveMemory(m_pszData + nPosition, pszSubstring, nLength * sizeof(TCHAR));
m_nLength = nNewLength;
}
void MemoryStream::Write(const std::string& value)
{
const uint32_t additionalSize = static_cast<uint32_t>(sizeof(uint32_t) + value.length());
EnsureSize(additionalSize);
uint32_t* pointer = reinterpret_cast<uint32_t*>(m_data + m_position);
*pointer = static_cast<uint32_t>(value.length());
++pointer;
memcpy(pointer, value.data(), value.length());
m_position += additionalSize;
}
bool IOBuffer::ReadFromBuffer(const uint8_t *pBuffer, const uint32_t size) {
SANITY_INPUT_BUFFER;
if (!EnsureSize(size)) {
SANITY_INPUT_BUFFER;
return false;
}
memcpy(_pBuffer + _published, pBuffer, size);
_published += size;
SANITY_INPUT_BUFFER;
return true;
}
/**
* @param pszStrData - data source.
*/
void CStrStream::AppendData(PCSTR pszStrData)
{
if (pszStrData && *pszStrData)
{
int nSize = MultiByteToWideChar(CP_ACP, 0, pszStrData, -1, NULL, 0);
_ASSERTE(nSize > 0);
size_t nNewSize = m_nLength + nSize;
EnsureSize(nNewSize, true);
MultiByteToWideChar(CP_ACP, 0, pszStrData, -1, m_pszData + m_nLength, nSize);
m_nLength = nNewSize - 1;
}
}
/**
* @param pszStrData - data source.
*/
void CStrStream::AppendData(PCWSTR pszStrData)
{
if (pszStrData && *pszStrData)
{
size_t nSize = WideCharToMultiByte(CP_ACP, 0, pszStrData, -1, NULL, 0, NULL, NULL);
_ASSERTE(nSize > 0);
size_t nNewSize = m_nLength + nSize;
EnsureSize(nNewSize, true);
WideCharToMultiByte(CP_ACP, 0, pszStrData, -1, m_pszData + m_nLength, (int)nSize, NULL, NULL);
m_nLength = nNewSize - 1;
}
}
/**
* @param pszStrData - data source.
*/
void CStrStream::CopyData(PCSTR pszStrData)
{
if (pszStrData && *pszStrData)
{
int nSize = MultiByteToWideChar(CP_ACP, 0, pszStrData, -1, NULL, 0);
_ASSERTE(nSize > 0);
EnsureSize(nSize, false);
MultiByteToWideChar(CP_ACP, 0, pszStrData, -1, m_pszData, nSize);
m_nLength = nSize - 1;
}
else
Reset();
}
/**
* @param pszStrData - data source.
*/
void CStrStream::CopyData(PCWSTR pszStrData)
{
if (pszStrData && *pszStrData)
{
size_t nSize = WideCharToMultiByte(CP_ACP, 0, pszStrData, -1, NULL, 0, NULL, NULL);
_ASSERTE(nSize > 0);
EnsureSize(nSize, false);
WideCharToMultiByte(CP_ACP, 0, pszStrData, -1, m_pszData, (int)nSize, NULL, NULL);
m_nLength = nSize - 1;
}
else
Reset();
}
void ArrayBase::__SetSize(int inSize)
{
if (inSize<length)
{
int s = GetElementSize();
memset(mBase + inSize*s, 0, (length-inSize)*s);
length = inSize;
}
else if (inSize>length)
{
EnsureSize(inSize);
length = inSize;
}
}
void
CompositorD3D11::EndFrame()
{
nsIntSize oldSize = mSize;
EnsureSize();
UINT presentInterval = 0;
if (gfxWindowsPlatform::GetPlatform()->IsWARP()) {
// When we're using WARP we cannot present immediately as it causes us
// to tear when rendering. When not using WARP it appears the DWM takes
// care of tearing for us.
presentInterval = 1;
}
if (oldSize == mSize) {
RefPtr<IDXGISwapChain1> chain;
HRESULT hr = mSwapChain->QueryInterface((IDXGISwapChain1**)byRef(chain));
if (SUCCEEDED(hr) && chain) {
DXGI_PRESENT_PARAMETERS params;
PodZero(¶ms);
params.DirtyRectsCount = mInvalidRegion.GetNumRects();
std::vector<RECT> rects;
rects.reserve(params.DirtyRectsCount);
nsIntRegionRectIterator iter(mInvalidRegion);
const nsIntRect* r;
uint32_t i = 0;
while ((r = iter.Next()) != nullptr) {
RECT rect;
rect.left = r->x;
rect.top = r->y;
rect.bottom = r->YMost();
rect.right = r->XMost();
rects.push_back(rect);
}
params.pDirtyRects = &rects.front();
chain->Present1(presentInterval, mDisableSequenceForNextFrame ? DXGI_PRESENT_DO_NOT_SEQUENCE : 0, ¶ms);
} else {
mSwapChain->Present(presentInterval, mDisableSequenceForNextFrame ? DXGI_PRESENT_DO_NOT_SEQUENCE : 0);
}
mDisableSequenceForNextFrame = false;
if (mTarget) {
PaintToTarget();
}
}
mCurrentRT = nullptr;
}
/**
* @param pszStrData - data source.
* @param nLength - string length.
*/
void CStrStream::CopyData(PCTSTR pszStrData, size_t nLength)
{
if (m_pszData != pszStrData)
{
if (pszStrData && *pszStrData)
{
size_t nSize = nLength + 1;
EnsureSize(nSize, false);
_tcsncpy_s(m_pszData, nSize, pszStrData, nLength);
m_nLength = nLength;
}
else
Reset();
}
}
void
CompositorD3D9::EndFrame()
{
device()->EndScene();
nsIntSize oldSize = mSize;
EnsureSize();
if (oldSize == mSize) {
if (mTarget) {
PaintToTarget();
} else {
mSwapChain->Present();
}
}
mCurrentRT = nullptr;
}
/**
* liest vom Socket die Paketdatenmenge
*
* @author FloSoft
*/
int Message::recv(Socket& sock, unsigned int length)
{
if(!length)
return 0;
EnsureSize(length);
int read = sock.Recv(GetDataWritable(), length);
SetLength(length);
if(length != (unsigned int)read )
{
LOG.lprintf("recv: data: only got %d bytes instead of %d\n", read, length);
return -1;
}
return 0;
}
int Vector::Add(Object* element,int b_allowDuplicates)
{
if(!b_allowDuplicates){
if(Get(element)!=-1)
return size;
}
element->ref(); //increment this objects reference count
if(tlength<size+1)
EnsureSize((size+1)<<1); //double the size of the array. this will make allocations rare to help reduce memory fragmentation, copying, etc.
vector[size]=element;
size++;
return size;//return the new size of the vector
}
void
CompositorD3D11::EndFrame()
{
mContext->Flush();
nsIntSize oldSize = mSize;
EnsureSize();
if (oldSize == mSize) {
mSwapChain->Present(0, mDisableSequenceForNextFrame ? DXGI_PRESENT_DO_NOT_SEQUENCE : 0);
mDisableSequenceForNextFrame = false;
if (mTarget) {
PaintToTarget();
}
}
mCurrentRT = nullptr;
}
void
CompositorD3D11::EndFrame()
{
mContext->Flush();
nsIntSize oldSize = mSize;
EnsureSize();
if (oldSize == mSize) {
mSwapChain->Present(0, 0);
if (mTarget) {
PaintToTarget();
}
}
mCurrentRT = nullptr;
}
void
CompositorD3D9::BeginFrame(const nsIntRegion& aInvalidRegion,
const Rect *aClipRectIn,
const gfxMatrix& aTransform,
const Rect& aRenderBounds,
Rect *aClipRectOut,
Rect *aRenderBoundsOut)
{
if (!mSwapChain->PrepareForRendering()) {
return;
}
mDeviceManager->SetupRenderState();
EnsureSize();
device()->Clear(0, NULL, D3DCLEAR_TARGET, 0x00000000, 0, 0);
device()->BeginScene();
if (aClipRectOut) {
*aClipRectOut = Rect(0, 0, mSize.width, mSize.height);
}
if (aRenderBoundsOut) {
*aRenderBoundsOut = Rect(0, 0, mSize.width, mSize.height);
}
RECT r;
if (aClipRectIn) {
r.left = (LONG)aClipRectIn->x;
r.top = (LONG)aClipRectIn->y;
r.right = (LONG)(aClipRectIn->x + aClipRectIn->width);
r.bottom = (LONG)(aClipRectIn->y + aClipRectIn->height);
} else {
r.left = r.top = 0;
r.right = mSize.width;
r.bottom = mSize.height;
}
device()->SetScissorRect(&r);
nsRefPtr<IDirect3DSurface9> backBuffer = mSwapChain->GetBackBuffer();
mDefaultRT = new CompositingRenderTargetD3D9(backBuffer,
INIT_MODE_CLEAR,
IntRect(0, 0, mSize.width, mSize.height));
SetRenderTarget(mDefaultRT);
}
bool IOBuffer::ReadFromStdio(int32_t fd, uint32_t expected, int32_t &recvAmount) {
SANITY_INPUT_BUFFER;
if (_published + expected > _size) {
if (!EnsureSize(expected)) {
SANITY_INPUT_BUFFER;
return false;
}
}
recvAmount = READ_FD(fd, (char *) (_pBuffer + _published), expected);
if (recvAmount > 0) {
_published += (uint32_t) recvAmount;
SANITY_INPUT_BUFFER;
return true;
} else {
SANITY_INPUT_BUFFER;
return false;
}
}
bool IOBuffer::ReadFromFs(MmapFile &file, uint32_t size) {
SANITY_INPUT_BUFFER;
if (size == 0) {
SANITY_INPUT_BUFFER;
return true;
}
if (_published + size > _size) {
if (!EnsureSize(size)) {
SANITY_INPUT_BUFFER;
return false;
}
}
if (!file.ReadBuffer(_pBuffer + _published, size)) {
SANITY_INPUT_BUFFER;
return false;
}
_published += size;
SANITY_INPUT_BUFFER;
return true;
}
