void CMemoryStreamSink::afterGettingFrame1(unsigned frameSize,struct timeval presentationTime)
{
CAutoLock BufferLock(&m_BufferLock);
OnRawData(fBuffer, frameSize);
//addData(fBuffer, frameSize, presentationTime);
// Then try getting the next frame:
continuePlaying();
}
DWORD CMemoryBuffer::ReadFromBuffer(BYTE *pbData, long lDataLength)
{
if (pbData==NULL) return 0;
if (lDataLength<=0) return 0;
if (!m_bRunning) return 0;
//Log("get..%d/%d",lDataLength,m_BytesInBuffer);
long bytesWritten = 0;
CAutoLock ClearLock(&m_ClearLock);
while (bytesWritten < lDataLength)
{
BUFFERITEM* item;
{ //Context for CAutoLock
CAutoLock BufferLock(&m_BufferLock);
if(m_BytesInBuffer <= 0 || !m_Array.size() || m_Array.size() <= 0)
{
return (DWORD)bytesWritten;
}
ivecBuffers it = m_Array.begin();
item = *it;
}
long copyLength = min(item->nDataLength - item->nOffset, lDataLength-bytesWritten);
memcpy(&pbData[bytesWritten], &item->data[item->nOffset], copyLength);
bytesWritten += copyLength;
item->nOffset += copyLength;
m_BytesInBuffer-=copyLength;
if (item->nOffset >= item->nDataLength)
{
delete[] item->data;
delete item;
CAutoLock BufferLock(&m_BufferLock);
m_Array.erase(m_Array.begin());
}
}
return (DWORD)bytesWritten;
}
void CMemoryBuffer::Clear()
{
CAutoLock BufferLock(&m_BufferLock);
m_bStopping=false;
std::vector<BUFFERITEM *>::iterator it = m_Array.begin();
for ( ; it != m_Array.end() ; it++ )
{
BUFFERITEM *item = *it;
delete[] item->data;
delete item;
}
m_Array.clear();
m_BytesInBuffer=0;
}
HRESULT CMemoryBuffer::PutBuffer(BYTE *pbData, long lDataLength)
{
if (!m_bRunning) return S_FALSE;
if (lDataLength<=0) return E_FAIL;
if (pbData==NULL) return E_FAIL;
BUFFERITEM* item = new BUFFERITEM();
item->nOffset=0;
item->nDataLength=lDataLength;
item->data = new byte[lDataLength];
memcpy(item->data, pbData, lDataLength);
bool sleep=false;
{ //Context for CAutoLock BufferLock
CAutoLock BufferLock(&m_BufferLock);
if (!m_bRunning)
{
delete[] item->data;
delete item;
return S_FALSE;
}
if (m_BytesInBuffer > MAX_MEMORY_BUFFER_SIZE)
{
//Log("add..%d/%d",lDataLength,m_BytesInBuffer);
LogDebug("memorybuffer:put full buffer (%d)",m_BytesInBuffer);
//Overflow - discard a reasonable chunk of the current buffer
while (m_BytesInBuffer > OVERFLOW_BUFFER_SIZE && m_Array.size()>0)
{
sleep=true;
BUFFERITEM *itemc = m_Array.back();
int copyLength=itemc->nDataLength - itemc->nOffset;
m_BytesInBuffer-=copyLength;
delete[] itemc->data;
delete itemc;
m_Array.pop_back();
}
}
m_Array.push_back(item);
m_BytesInBuffer+=lDataLength;
}
if (sleep)
{
Sleep(1);
}
return S_OK;
}
void CMemoryBuffer::Clear()
{
//XBMC->Log(LOG_DEBUG, "memorybuffer: Clear() %d",m_Array.size());
CAutoLock BufferLock(&m_BufferLock);
std::vector<BUFFERITEM *>::iterator it = m_Array.begin();
for ( ; it != m_Array.end() ; it++ )
{
BUFFERITEM *item = *it;
delete[] item->data;
delete item;
}
m_Array.clear();
m_BytesInBuffer=0;
//XBMC->Log(LOG_DEBUG, "memorybuffer: Clear() done");
}
void CMemoryBuffer::Clear()
{
LogDebug("memorybuffer: Clear() %d",m_Array.size());
CAutoLock ClearLock(&m_ClearLock);
CAutoLock BufferLock(&m_BufferLock);
ivecBuffers it = m_Array.begin();
for ( ; it != m_Array.end() ; it++ )
{
BUFFERITEM *item = *it;
delete[] item->data;
delete item;
}
m_Array.clear();
m_BytesInBuffer=0;
LogDebug("memorybuffer: Clear() done");
}
void CMemoryBuffer::Clear()
{
LogDebug("memorybuffer: Clear() buffers:%d, bytes:%d",m_Array.size(), m_BytesInBuffer);
CAutoLock BufferLock(&m_BufferLock);
if (m_Array.size()>0)
{
ivecBuffers it = m_Array.begin();
for ( ; it != m_Array.end() ; it++ )
{
BUFFERITEM *item = *it;
delete[] item->data;
delete item;
}
m_Array.clear();
}
m_BytesInBuffer=0;
}
DWORD CMemoryBuffer::ReadFromBuffer(BYTE *pbData, long lDataLength)
{
if (!m_bRunning) return 0;
if (pbData==NULL) return 0;
if (lDataLength<=0) return 0;
//Log("get..%d/%d",lDataLength,m_BytesInBuffer);
long bytesRead = 0;
while (bytesRead < lDataLength)
{
{ //Context for CAutoLock
CAutoLock BufferLock(&m_BufferLock);
if(m_BytesInBuffer <= 0 || m_Array.size() <= 0 || !m_bRunning)
{
return (DWORD)bytesRead;
}
BUFFERITEM* item;
ivecBuffers it = m_Array.begin();
item = *it;
long copyLength = min(item->nDataLength - item->nOffset, lDataLength-bytesRead);
memcpy(&pbData[bytesRead], &item->data[item->nOffset], copyLength);
bytesRead += copyLength;
item->nOffset += copyLength;
m_BytesInBuffer -= copyLength;
if (item->nOffset >= item->nDataLength)
{
delete[] item->data;
delete item;
m_Array.erase(m_Array.begin());
}
if (m_BytesInBuffer < 0)
{
LogDebug("memorybuffer: ReadFromBuffer() error, m_BytesInBuffer is negative!! :%d", m_BytesInBuffer);
}
}
}
return (DWORD)bytesRead;
}
long CMemoryBuffer::PutBuffer(unsigned char *pbData, long lDataLength)
{
if (lDataLength<=0) return E_FAIL;
if (pbData==NULL) return E_FAIL;
BUFFERITEM* item = new BUFFERITEM();
item->nOffset=0;
item->nDataLength=lDataLength;
item->data = new byte[lDataLength];
memcpy(item->data, pbData, lDataLength);
bool sleep=false;
{
CAutoLock BufferLock(&m_BufferLock);
m_Array.push_back(item);
m_BytesInBuffer+=lDataLength;
//Log("add..%d/%d",lDataLength,m_BytesInBuffer);
while (m_BytesInBuffer > MAX_MEMORY_BUFFER_SIZE)
{
sleep=true;
XBMC->Log(LOG_DEBUG, "memorybuffer:put full buffer (%d)",m_BytesInBuffer);
BUFFERITEM *item = m_Array.at(0);
int copyLength=item->nDataLength - item->nOffset;
m_BytesInBuffer-=copyLength;
m_Array.erase(m_Array.begin());
delete[] item->data;
delete item;
}
if (m_BytesInBuffer>0)
{
m_event.SetEvent();
}
}
if (m_pcallback)
{
m_pcallback->OnRawDataReceived(pbData,lDataLength);
}
if (sleep)
{
Sleep(10);
}
return S_OK;
}
DWORD CMemoryBuffer::ReadFromBuffer(BYTE *pbData, long lDataLength, long lOffset)
{
if (lDataLength<0) return 0;
while ((long)m_BytesInBuffer < lDataLength)
{
if (m_bStopping)
{
LogDebug("CMemoryBuffer::ReadFromBuffer - ReadFromBuffer::Stop()");
return 0;
}
m_event.ResetEvent();
m_event.Wait();
}
//Log("get..%d/%d",lDataLength,m_BytesInBuffer);
long bytesWritten = 0;
CAutoLock BufferLock(&m_BufferLock);
while (bytesWritten < lDataLength)
{
if (m_bStopping) return 0;
if(!m_Array.size() || m_Array.size() <= 0)
{
LogDebug("CMemoryBuffer::ReadFromBuffer - read:empty buffer\n");
return 0;
}
BUFFERITEM *item = m_Array.at(0);
long copyLength = min(item->nDataLength - item->nOffset, lDataLength-bytesWritten);
memcpy(&pbData[bytesWritten], &item->data[item->nOffset], copyLength);
bytesWritten += copyLength;
item->nOffset += copyLength;
m_BytesInBuffer-=copyLength;
if (item->nOffset >= item->nDataLength)
{
m_Array.erase(m_Array.begin());
delete[] item->data;
delete item;
}
}
return bytesWritten;
}
unsigned long CMemoryBuffer::ReadFromBuffer(unsigned char *pbData, long lDataLength)
{
if (pbData==NULL) return 0;
if (lDataLength<=0) return 0;
if (!m_bRunning) return 0;
while (m_BytesInBuffer < (unsigned long) lDataLength)
{
if (!m_bRunning) return 0;
m_event.ResetEvent();
m_event.Wait();
if (!m_bRunning) return 0;
}
//Log("get..%d/%d",lDataLength,m_BytesInBuffer);
long bytesWritten = 0;
CAutoLock BufferLock(&m_BufferLock);
while (bytesWritten < lDataLength)
{
if(!m_Array.size() || m_Array.size() <= 0)
{
XBMC->Log(LOG_DEBUG, "memorybuffer: read:empty buffer\n");
return 0;
}
BUFFERITEM *item = m_Array.at(0);
long copyLength = min(item->nDataLength - item->nOffset, lDataLength-bytesWritten);
memcpy(&pbData[bytesWritten], &item->data[item->nOffset], copyLength);
bytesWritten += copyLength;
item->nOffset += copyLength;
m_BytesInBuffer-=copyLength;
if (item->nOffset >= item->nDataLength)
{
m_Array.erase(m_Array.begin());
delete[] item->data;
delete item;
}
}
return bytesWritten;
}
void CMemorySink::addData(unsigned char* data, unsigned dataSize,struct timeval presentationTime)
{
if (testsize ==0)
{
LogDebug("CMemorySink:addData");
testsize=1;
}
if (dataSize==0) return;
if (data==NULL) return;
if (m_bReEntrant)
{
LogDebug("REENTRANT IN MEMORYSINK.CPP");
return;
}
CAutoLock BufferLock(&m_BufferLock);
m_bReEntrant=true;
m_buffer.PutBuffer(data, dataSize);
m_bReEntrant=false;
}
HRESULT CMemoryBuffer::PutBuffer(BYTE *pbData, long lDataLength, long lOffset)
{
if (lDataLength<=0) return E_FAIL;
if (lOffset<0) return E_FAIL;
if (pbData==NULL) return E_FAIL;
BUFFERITEM* item = new BUFFERITEM();
item->nOffset=0;
item->nDataLength=(lDataLength-lOffset);
item->data = new byte[item->nDataLength];
memcpy(item->data, &pbData[lOffset], item->nDataLength);
{
CAutoLock BufferLock(&m_BufferLock);
m_Array.push_back(item);
m_BytesInBuffer+=item->nDataLength;
//Log("add..%d/%d",lDataLength,m_BytesInBuffer);
while (m_BytesInBuffer > MAX_MEMORY_BUFFER_SIZE)
{
LogDebug("CMemoryBuffer::PutBuffer - add: full buffer (%d)",m_BytesInBuffer);
BUFFERITEM *item = m_Array.at(0);
int copyLength=item->nDataLength - item->nOffset;
m_BytesInBuffer-=copyLength;
m_Array.erase(m_Array.begin());
delete[] item->data;
delete item;
}
if (m_BytesInBuffer>0)
{
m_event.SetEvent();
}
}
if (m_pcallback)
{
m_pcallback->OnRawDataReceived(&pbData[lOffset],lDataLength);
}
return S_OK;
}
bool RenderTarget::copyToBuffer( GLenum mode, dp::sg::core::Image::PixelFormat pixelFormat, dp::sg::core::Image::PixelDataType pixelDataType, const dp::sg::core::BufferSharedPtr & buffer )
{
// FIXME use C++ object for current/noncurrent for exception safety
makeCurrent();
size_t components = 0;
size_t bytesPerComponent = 0;
// set up alignments
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
// determine OpenGL format
GLenum format = ~0;
switch (pixelFormat)
{
case dp::PixelFormat::PF_RGB:
format = GL_RGB;
components = 3;
break;
case dp::PixelFormat::PF_RGBA:
format = GL_RGBA;
components = 4;
break;
case dp::PixelFormat::PF_BGR:
format = GL_BGR;
components = 3;
break;
case dp::PixelFormat::PF_BGRA:
format = GL_BGRA;
components = 4;
break;
case dp::PixelFormat::PF_LUMINANCE:
format = GL_LUMINANCE;
components = 1;
break;
case dp::PixelFormat::PF_ALPHA:
format = GL_ALPHA;
components = 1;
break;
case dp::PixelFormat::PF_LUMINANCE_ALPHA:
format = GL_LUMINANCE_ALPHA;
components = 2;
break;
case dp::PixelFormat::PF_DEPTH_COMPONENT:
format = GL_DEPTH_COMPONENT;
components = 1;
break;
case dp::PixelFormat::PF_DEPTH_STENCIL:
format = GL_DEPTH24_STENCIL8;
components = 1;
break;
default:
DP_ASSERT(0 && "unsupported PixelFormat");
};
GLenum dataType = ~0;
switch (pixelDataType)
{
case dp::PixelFormat::PF_BYTE:
dataType = GL_BYTE;
bytesPerComponent = 1;
break;
case dp::PixelFormat::PF_UNSIGNED_BYTE:
dataType = GL_UNSIGNED_BYTE;
bytesPerComponent = 1;
break;
case dp::PixelFormat::PF_SHORT:
dataType = GL_SHORT;
bytesPerComponent = 2;
break;
case dp::PixelFormat::PF_UNSIGNED_SHORT:
dataType = GL_UNSIGNED_SHORT;
bytesPerComponent = 2;
break;
case dp::PixelFormat::PF_INT:
dataType = GL_INT;
bytesPerComponent = 4;
break;
case dp::PixelFormat::PF_UNSIGNED_INT:
dataType = GL_UNSIGNED_INT;
bytesPerComponent = 4;
break;
case dp::PixelFormat::PF_FLOAT32:
dataType = GL_FLOAT;
bytesPerComponent = 4;
break;
case dp::PixelFormat::PF_FLOAT16:
dataType = GL_HALF_FLOAT;
bytesPerComponent = 2;
break;
default:
DP_ASSERT(0 && "unsupported PixelDataType");
}
BufferLock(buffer)->setSize(m_width * m_height * components * bytesPerComponent);
// read the pixels
glWindowPos2i(0,0);
glReadBuffer( mode );
bool isBufferGL = buffer.isPtrTo<BufferGL>();
if ( isBufferGL )
{
GLint oldPBO;
glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &oldPBO);
// FIXME it's necessary to check wheter the buffer object shared data with the current context...
BufferGLLock bufferGL( sharedPtr_cast<BufferGL>( buffer ) );
bufferGL->bind( GL_PIXEL_PACK_BUFFER );
glReadPixels(0, 0, m_width, m_height, format, dataType, 0);
glBindBuffer(GL_PIXEL_PACK_BUFFER, (GLuint)oldPBO);
}
else
{
Buffer::DataWriteLock bufferLock(buffer, Buffer::MAP_WRITE);
glReadPixels(0, 0, m_width, m_height, format, dataType, bufferLock.getPtr());
}
makeNoncurrent();
return true;
}
/**
* @brief Handles all network connections
* @param arg a pointer to a structure containing port number and timeout
* @return never returns until shutdown
*
* @todo be sure this handles linkdead without removing all player structures
* so the player can log back in and be where they were
*
* Brings up a TCP listener on the MUD's assigned port and accepts connections.
* Also reads all data from connected clients and hands the data off to the
* Input thread. When there is output to be sent, this thread handles writing
* to the sockets after the first write has completed. This thread also
* handles the disconnection of clients gracefully.
*/
void *ConnectionThread( void *arg )
{
connectThreadArgs_t *argStruct;
int portNum;
char *port;
struct sockaddr_in6 sa;
int count;
int fdCount;
int newFd;
socklen_t salen;
struct timeval timeout;
ConnectionItem_t *item;
PlayerStruct_t *player;
ConnInputItem_t *connItem;
ConnDnsItem_t *dnsItem;
uint32 i;
int on;
int retval;
char ch;
argStruct = (connectThreadArgs_t *)arg;
portNum = argStruct->port;
pthread_mutex_lock( startupMutex );
if( portNum == -1 ) {
port = pb_get_setting( "listenPort" );
if( !port ) {
portNum = 4000;
} else {
portNum = atoi(port);
memfree(port);
}
}
/*
* Start listening
*/
listenFd = socket( AF_INET6, SOCK_STREAM, 0 );
if( listenFd < 0 ) {
perror("Opening listener socket");
exit(1);
}
on = 1;
if( setsockopt( listenFd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) ) ) {
perror("Setting socket to reuse");
exit(1);
}
memset(&sa, 0, sizeof(sa));
sa.sin6_family = AF_INET6;
sa.sin6_port = htons(portNum);
sa.sin6_addr = in6addr_any;
if (bind(listenFd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
perror("Binding listener socket");
close(listenFd);
exit(1);
}
if (listen(listenFd, 10)) {
perror("Listening to socket");
close(listenFd);
exit(1);
}
FD_ZERO(&saveReadFds);
FD_ZERO(&saveWriteFds);
FD_ZERO(&saveExceptFds);
connAddFd(listenFd, &saveReadFds);
ConnectionList = LinkedListCreate(NULL);
LogPrint( LOG_NOTICE, "Listening on port %d", portNum );
pthread_mutex_unlock( startupMutex );
while( !GlobalAbort ) {
/*
* Select on connected and listener
*/
readFds = saveReadFds;
writeFds = saveWriteFds;
exceptFds = saveExceptFds;
timeout.tv_sec = argStruct->timeout_sec;
timeout.tv_usec = argStruct->timeout_usec;
fdCount = select(maxFd+1, &readFds, &writeFds, &exceptFds, &timeout);
if( GlobalAbort ) {
continue;
}
recalcMaxFd = FALSE;
/*
* Open a connection for listener
*/
if( FD_ISSET(listenFd, &readFds) ) {
salen = sizeof(struct sockaddr_in6);
newFd = accept(listenFd, (struct sockaddr *)&sa, &salen);
connAddFd(newFd, &saveReadFds);
connAddFd(newFd, &saveExceptFds);
item = CREATE(ConnectionItem_t);
if( !item ) {
/*
* No memory!
*/
LogPrintNoArg( LOG_EMERG, "Out of memory!" );
close(newFd);
} else {
item->fd = newFd;
item->buffer = BufferCreate(MAX_BUFSIZE);
item->hostName = ProtectedDataCreate();
ProtectedDataLock( item->hostName );
item->hostName->data = CREATEN(char, 50);
inet_ntop(AF_INET6, &sa.sin6_addr, item->hostName->data, 50);
if( !strncmp(item->hostName->data, "::ffff:", 7) ) {
bcopy((char *)item->hostName->data + 7,
item->hostName->data, 43);
}
ProtectedDataUnlock( item->hostName );
if (!IS_SET(SystemFlags, SYS_SKIPDNS)) {
dnsItem = CREATE(ConnDnsItem_t);
if( dnsItem ) {
dnsItem->connection = item;
memcpy(dnsItem->ipAddr, &sa.sin6_addr, 16);
QueueEnqueueItem(ConnectDnsQ, dnsItem);
}
}
player = CREATE(PlayerStruct_t);
if( !player ) {
/*
* No memory!
*/
LogPrintNoArg( LOG_EMERG, "Out of memory!" );
BufferDestroy(item->buffer);
close(newFd);
memfree(item);
} else {
item->player = player;
player->connection = item;
player->in_buffer = item->buffer;
LinkedListAdd( ConnectionList, (LinkedListItem_t *)item,
UNLOCKED, AT_TAIL );
/*
* Pass the info on to the other threads...
*/
#ifdef DEBUG_CONNECT
LogPrint( LOG_INFO, "New connection: %p", player );
#endif
connItem = CREATE(ConnInputItem_t);
if( connItem ) {
connItem->type = CONN_NEW_CONNECT;
connItem->player = player;
QueueEnqueueItem(ConnectInputQ, (QueueItem_t)connItem);
}
}
}
fdCount--;
}
if( fdCount ) {
LinkedListLock( ConnectionList );
for( item = (ConnectionItem_t *)(ConnectionList->head);
item && fdCount;
item = (item ? (ConnectionItem_t *)item->link.next
: (ConnectionItem_t *)ConnectionList->head) ) {
if( FD_ISSET( item->fd, &exceptFds ) ) {
/*
* This connection's borked, close it, remove it, move on
*/
if( FD_ISSET( item->fd, &readFds ) ) {
fdCount--;
}
if( FD_ISSET( item->fd, &writeFds ) ) {
fdCount--;
}
BufferLock( item->buffer );
item = connRemove(item);
fdCount--;
continue;
}
if( item && FD_ISSET( item->fd, &readFds ) ) {
/*
* This connection has data ready
*/
count = BufferAvailWrite( item->buffer, TRUE );
if( !count ) {
/*
* No buffer space, the buffer's unlocked, move on
*/
LogPrint( LOG_INFO, "No buffer space: %p", item );
continue;
}
/*
* The buffer's locked
*/
count = read( item->fd, BufferGetWrite( item->buffer ),
count );
if( !count ) {
LogPrint( LOG_DEBUG, "EOF on %d", item->fd );
/*
* We hit EOF, close and remove
*/
if( FD_ISSET( item->fd, &writeFds ) ) {
fdCount--;
}
item = connRemove(item);
fdCount--;
continue;
}
BufferWroteBytes( item->buffer, count );
BufferUnlock( item->buffer );
/*
* Tell the input thread
*/
connItem = CREATE(ConnInputItem_t);
if( connItem ) {
#ifdef DEBUG_INPUT
LogPrint( LOG_INFO, "New data: %p", item->player );
#endif
connItem->type = CONN_INPUT_AVAIL;
connItem->player = item->player;
QueueEnqueueItem(ConnectInputQ, (QueueItem_t)connItem);
}
}
if( item && FD_ISSET( item->fd, &writeFds ) ) {
/*
* We have space to output, so write if we have anything
* to write
*/
#ifdef DEBUG_OUTPUT
LogPrint( LOG_INFO, "Output sent to: %p", item );
#endif
if( item->outBufDesc ) {
/* TODO: deal with partial block writes */
retval = write( item->fd, item->outBufDesc->buf,
item->outBufDesc->len );
memfree( item->outBufDesc->buf );
memfree( item->outBufDesc );
item->outBufDesc = NULL;
}
/*
* Kick the next output
*/
connKickOutput( item );
fdCount--;
}
}
LinkedListUnlock( ConnectionList );
}
if( recalcMaxFd ) {
LinkedListLock( ConnectionList );
maxFd = listenFd;
for( item = (ConnectionItem_t *)(ConnectionList->head); item;
item = (ConnectionItem_t *)item->link.next ) {
if( item->fd > maxFd ) {
maxFd = item->fd;
}
}
LinkedListUnlock( ConnectionList );
}
}
long CMemoryBuffer::Size()
{
CAutoLock BufferLock(&m_BufferLock);
return (m_bRunning ? m_BytesInBuffer : -1);
}
