void t_chessGui::run()
{
chessCegui.init();
loadImages();
loadSprites();
initCegui();
initServer();
initConnect();
RedBox = sf::Shape::Rectangle(0,0,100,100,sf::Color(255,0,0));
BlackBox = sf::Shape::Rectangle(0,0,100,100,sf::Color(0,255,0));
BlueBox = sf::Shape::Rectangle(0,0,100,100,sf::Color(0,0,255));
BrownBox = sf::Shape::Rectangle(0,0,100,100,sf::Color(255,255,0));
PurpleBox = sf::Shape::Rectangle(0,0,100,100,sf::Color(160,32,240));
PinkBox = sf::Shape::Rectangle(0,0,100,100,sf::Color(255,182,193));
while (App.IsOpened())
{
processEvents();
checkBuffer();
App.Clear();
drawBoard();
CEGUI::System::getSingleton().renderGUI();
App.Display();
}
return;
}
void Ambix_wideningAudioProcessor::calcParams()
{
checkBuffer();
if (param_changed) {
// set new latency
if (single_sided)
setLatencySamples(0);
else
setLatencySamples(Q*BESSEL_APPR);
// parameters in rad
double phi_hat = ((double)mod_depth_param)*2*M_PI;
double rot_offset = M_PI - ((double)rot_offset_param + 0.002)*2*M_PI; // offset needed - why??
// std::cout << "MATRIX:" << std::endl;
for (int m=1; m <= AMBI_ORDER; m++) {
// String output_cos = "cos: ";
// String output_sin = "sin: ";
for (int lambda = 0; lambda <= BESSEL_APPR; lambda++) {
double bessel = jn(lambda, (double)m*phi_hat);
double d_cos_coeff = cos(M_PI_2*lambda + m*rot_offset)*bessel;
double d_sin_coeff = sin(M_PI_2*lambda + m*rot_offset)*bessel;
//////
// set zero if lower then threshold defined in .h file
if (fabs(d_cos_coeff) < TRUNCATE) {
d_cos_coeff = 0.f;
}
if (fabs(d_cos_coeff) < TRUNCATE) {
d_sin_coeff = 0.f;
}
cos_coeffs[m-1][lambda] = (float)d_cos_coeff;
sin_coeffs[m-1][lambda] = (float)d_sin_coeff;
// output_cos << String(cos_coeffs[m-1][lambda]).substring(0, 4);
// output_cos << " ";
// output_sin << String(sin_coeffs[m-1][lambda]).substring(0, 4);
// output_sin << " ";
}
// std::cout << output_cos << std::endl;
// std::cout << output_sin << std::endl;
}
param_changed = false;
}
}
void MPEGProcessorBase::processSubstreamData(char *dat, int bytes, bool write)
{
_cur_hdr = (MPEG_PES_Header*)((char*)_cur_hdr + htons(_cur_hdr->packet_length) + 6);
if (!write) return;
//AC3_Frame_Hdr *ac3hdr = (AC3_Frame_Hdr*)dat;
//int by = ac3_bytes_per_frame(ac3hdr->frminfo);
int buffer_left = BUFFER_SIZE - ((char*)dat - _buffer);
if (bytes <= buffer_left) {
if (write) {
fwrite(dat, 1, bytes, _ac3_output);
}
} else {
if (write) {
fwrite(dat, 1, buffer_left, _ac3_output);
}
bytes -= buffer_left;
checkBuffer();
if (write) {
fwrite(_buffer, 1, bytes, _ac3_output);
}
}
}
void MPEGProcessorBase::processFile()
{
_buffer_offset = 0;
fread(_buffer, 1, BUFFER_SIZE, _f);
_cur_hdr = (MPEG_PES_Header*)_buffer;
while (checkBuffer()) {
// printf("packet length %d id %x\n", htons(_cur_hdr->packet_length), _cur_hdr->stream_id);
if (_cur_hdr->stream_id == Pack_Header) {
// printf("packet length %d id %x\n", htons(_cur_hdr->packet_length), _cur_hdr->stream_id);
_cur_hdr = get_pes_hdr_from_pack_hdr((MPEG_Partial_PS_Pack_Header*)_cur_hdr);
continue;
} else if (_cur_hdr->stream_id == Private_Stream_1_Header) {
// printf("packet length %d id %x\n", htons(_cur_hdr->packet_length), _cur_hdr->stream_id);
processPrivateStream1();
continue;
}
// printf("packet length %d id %x\n", htons(_cur_hdr->packet_length), _cur_hdr->stream_id);
switch (_cur_hdr->stream_id) {
case 0xBE:
// printf("padding stream\n");
break;
case 0xBF:
processPrivateStream2();
break;
case 0xE0:
break;
default:
break;
}
// if (_cur_hdr->stream_id >=0xC0 || _cur_hdr->stream_id <= 0xDF)
// printf("MPEG audio stream");
nextPESHdr();
}
}
void UdpChain::refrushReliableData( unsigned outgoing )
{
if ( mOutgoingRel == mOutgoingAck )
return;
mOutgoingRel = outgoing;
uint32 endPos = 0;
DataInfoList::iterator iter = mInfoList.begin();
for( ; iter != mInfoList.end() ; ++iter )
{
DataInfo& info = *iter;
if ( info.sequence > mOutgoingRel )
break;
endPos += info.size;
}
if ( endPos )
{
mInfoList.erase( mInfoList.begin() , iter );
mBufferRel.shiftUseSize( endPos );
mBufferRel.clearUseData();
checkBuffer( mBufferRel.getData() , (int)mBufferRel.getFillSize() );
}
}
bool CZipWriter::Write( const void *ptr, int len )
{
checkBuffer( len );
memcpy( &m_pBuffer[m_iLen], ptr, len );
m_iLen += len;
return true;
}
bool textfile_c::getChar() {
if (checkBuffer()) {
currentChar = buffer[bufferStart];
bufferStart = bufferStart+1;
return true;
} else {
return false;
}
}
ViStreamInput::ViStreamInput()
: ViAudioInput()
{
mDevice = QAudioDeviceInfo::defaultInputDevice();
mAudioInput = NULL;
mBufferDevice = NULL;
QObject::connect(&mTimer, SIGNAL(timeout()), this, SLOT(checkBuffer()));
setState(QAudio::IdleState);
}
void MMSStreamReader::run()
{
int to_read = 1024;
char prebuf[to_read];
m_handle = mmsx_connect (0, 0, m_url.toLocal8Bit().constData(), 128 * 1024);
if(!m_handle)
{
qWarning("MMSStreamReader: connection failed");
setErrorString("connection failed");
emit error();
QIODevice::close();
return;
}
m_mutex.lock();
if(m_aborted)
{
m_mutex.unlock();
qDebug("MMSStreamReader: aborted");
return;
}
m_mutex.unlock();
qint64 len = 0;
forever
{
m_mutex.lock();
if(m_buffer_at + to_read > m_buffer_size)
{
m_buffer_size = m_buffer_at + to_read;
m_buffer = (char *)realloc(m_buffer, m_buffer_size);
}
m_mutex.unlock();
len = mmsx_read (0, m_handle, prebuf, to_read);
m_mutex.lock();
if(len < 0)
{
m_mutex.unlock();
qWarning("MMSStreamReader: mms thread funished with code %lld (%s)", len, strerror(len));
if(!m_aborted && !m_ready)
{
setErrorString(strerror(len));
emit error();
}
break;
}
memcpy(m_buffer + m_buffer_at, prebuf, len);
m_buffer_at += len;
if(!m_ready)
checkBuffer();
m_mutex.unlock();
if(m_aborted)
break;
DownloadThread::usleep(5000);
}
QIODevice::close();
}
void EvaAgentDownloader::processDataBuffer( const unsigned short seq, const unsigned char * data,
const unsigned int len )
{
if(len > EVA_FILE_BUFFER_UNIT) {
m_State = EError;
return;
}
FileItem item;
item.no = seq;
item.len = len;
m_BufferSize += len;
m_BytesSent += len;
memcpy(item.data, data, len);
m_ItemBuffer[seq] = item;
checkBuffer(seq);
}
void MonteCarloRun::run()
{
boost::timer::nanosecond_type _timeSinceLast = _timer.elapsed().wall;
double period = 1 / _rate;
while(_isRunning)
{
boost::this_thread::sleep_for(boost::chrono::microseconds((long)(period * 1e6 * _N)));
if(checkBuffer((_N + _frameSize)))
{
_dataStream->changeFunc(genStreamFunc());
clearBuffer();
}
if(_timePerScheme < _timer.elapsed().wall - _timeSinceLast)
{
getNextMod();
boost::shared_lock<boost::shared_mutex> modLock(*_modType->getMutex());
AMC::ModType tempModType = _modType->getData();
modLock.unlock();
if(tempModType != AMC::ModType::MODTYPE_NR_ITEMS)
{
std::cout << "Setting modulation scheme to: " << AMC::toString(tempModType) << std::endl;
_featureExtractor->stop();
_dataStream->changeFunc(genStreamFunc());
clearBuffer();
_featureExtractor->start(AMC::FeatureExtractor::WRITE_TO_FILE, tempModType);
_timeSinceLast = _timer.elapsed().wall;
}
else
{
_isRunning = false;
std::cout << "Finished..." << std::endl;
_dataStream->stopStream();
_featureExtractor->stop();
}
}
}
}
static void* clientThreadEntry(void *arg)
{
int clientSocket = *static_cast<int*>(arg);
free(arg);
if(!setNonBlock(clientSocket))
{
printf("setNonBlock failed\n");
close(clientSocket);
return nullptr;
}
TransferRingBuffer tBuf(BUF_SIZE);
while(true)
{
void *data;
int size;
if(tBuf.startWrite(data, size))
{
int rd = read(clientSocket, data, size);
if(rd <= 0)
{
if(errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR)
{
if(rd == 0 && errno == 0)
{
printf("client disconnected\n");
close(clientSocket);
return nullptr;
}
else
{
printf("read failed: %s\n", strerror(errno));
close(clientSocket);
return nullptr;
}
}
}
else
{
tBuf.endWrite(rd);
}
}
if(tBuf.startRead(data, size))
{
if(withCheck)
{
checkBuffer(data, size);
}
int wr = write(clientSocket, data, size);
if(wr <= 0)
{
if(errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR)
{
printf("write failed: %s\n", strerror(errno));
close(clientSocket);
return nullptr;
}
}
else
{
tBuf.endRead(wr);
}
}
}
}
TInt DoTestProcess(TInt aTestNum,TInt aArg1,TInt aArg2)
{
(void)aArg1;
(void)aArg2;
RTestLdd ldd;
TInt r;
r=User::LoadLogicalDevice(KSharedIoTestLddName);
if(r!=KErrNone && r!=KErrAlreadyExists)
return KErrGeneral;
r=ldd.Open();
if(r!=KErrNone)
return r;
switch(aTestNum)
{
case ETestProcess1:
{
TAny* gbuffer;
TUint32 gsize;
r=User::GetTIntParameter(1,(TInt&)gbuffer);
if(r!=KErrNone)
return r;
r=User::GetTIntParameter(2,(TInt&)gsize);
if(r!=KErrNone)
return r;
r=checkBuffer(gbuffer,gsize,23454);
if(r!=KErrNone)
return r;
r=ldd.MapOutGlobalBuffer();
if(r!=KErrNone)
return r;
r=ldd.CreateBuffer(KTestBufferSize);
if(r!=KErrNone)
return r;
TAny* buffer;
TUint32 size;
r=ldd.MapInBuffer(&buffer,&size);
if(r!=KErrNone)
return r;
if(!CheckBuffer(buffer,size))
return KErrGeneral;
r=ldd.MapOutBuffer();
if(r!=KErrNone)
return r;
RProcess::Rendezvous(KProcessRendezvous);
*(TInt*)buffer = 0; // Should cause exception
break;
}
case ETestProcess2:
{
TInt size=aArg2;
TUint8* p=(TUint8*)aArg1;
RProcess::Rendezvous(KProcessRendezvous);
for(TInt i=0;i<size;i++)
p[i]=0; // Should cause exception
break;
}
case ETestProcess3:
{
TAny* buffer;
TUint32 size;
r=ldd.CreateBuffer(KTestBufferSize);
if(r!=KErrNone)
return r;
r=ldd.MapInBuffer(&buffer,&size);
if(r!=KErrNone)
return r;
if(!CheckBuffer(buffer,size))
return KErrGeneral;
*(TInt*)buffer=KMagic1;
TPckg<TInt> buf(*(TInt*)buffer);
r=ldd.ThreadRW(buf);
if(r!=KErrNone)
return r;
if(*(TInt*)buffer!=KMagic2)
return KErrCorrupt;
r=ldd.ThreadRW(*(TDes8*)aArg1,aArg2);
if(r!=KErrNone)
return r;
r=ldd.MapOutBuffer();
if(r!=KErrNone)
return r;
break;
}
default:
User::Panic(_L("T_SHAREDIO"),1);
}
ldd.Close();
return KErrNone;
}
GLDEF_C TInt E32Main()
{
TBuf16<512> cmd;
User::CommandLine(cmd);
if(cmd.Length() && TChar(cmd[0]).IsDigit())
{
TInt function = -1;
TInt arg1 = -1;
TInt arg2 = -1;
TLex lex(cmd);
lex.Val(function);
lex.SkipSpace();
lex.Val(arg1);
lex.SkipSpace();
lex.Val(arg2);
return DoTestProcess(function,arg1,arg2);
}
MemModelAttributes=UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL);
TUint mm=MemModelAttributes&EMemModelTypeMask;
PhysicalCommitSupported = mm!=EMemModelTypeDirect && mm!=EMemModelTypeEmul;
// Turn off lazy dll unloading
RLoader l;
test(l.Connect()==KErrNone);
test(l.CancelLazyDllUnload()==KErrNone);
l.Close();
test.Title();
#if defined(__FIXED__) || defined(__SECOND_FIXED__) || defined(__MOVING_FIXED__)
if(mm!=EMemModelTypeMoving)
{
test.Printf(_L("TESTS NOT RUN - Only applicable to moving memory model\r\n"));
return 0;
}
#endif
test.Start(_L("Loading test driver..."));
TInt r;
r=User::LoadLogicalDevice(KSharedIoTestLddName);
test(r==KErrNone || r==KErrAlreadyExists);
r=User::LoadLogicalDevice(KSharedIoTestLddName);
test(r==KErrAlreadyExists);
r=ldd.Open();
test(r==KErrNone);
TAny* buffer;
TUint32 size;
TUint32 key;
TInt testBufferSize=0;
for(; TestBufferSizes[testBufferSize]!=0; ++testBufferSize)
{
test.Printf(_L("Test buffer size = %08x\n"),TestBufferSizes[testBufferSize]);
test.Next(_L("Create buffer"));
r=ldd.CreateBuffer(TestBufferSizes[testBufferSize]);
if(r!=KErrNone)
test.Printf(_L("Creating buffer failed client r=%d"), r);
test(r==KErrNone);
test.Next(_L("Map In Buffer"));
r=ldd.MapInBuffer(&buffer,&size);
test.Next(_L("CheckBuffer"));
test(CheckBuffer(buffer,size));
test(r==KErrNone);
test.Next(_L("Fill and check shared buffer"));
key=Math::Random();
fillBuffer(buffer,size,key);
test(ldd.CheckBuffer(key)==KErrNone);
key=Math::Random();
test(ldd.FillBuffer(key)==KErrNone);
test(checkBuffer(buffer,size,key)==KErrNone);
test.Next(_L("Map Out Buffer"));
r=ldd.MapOutBuffer();
test(r==KErrNone);
test.Next(_L("Destroy Buffer"));
r=ldd.DestroyBuffer();
test(r==KErrNone);
test.Next(_L("Create a buffer under OOM conditions"));
CreateWithOOMCheck(TestBufferSizes[testBufferSize], EFalse);
if(PhysicalCommitSupported)
{
test.Next(_L("Create a buffer with a physical address under OOM conditions"));
CreateWithOOMCheck(TestBufferSizes[testBufferSize], ETrue);
test.Next(_L("Create a buffer with a physical address"));
r=ldd.CreateBufferPhysAddr(0x1000);
test(r==KErrNone);
test.Next(_L("Map In physical address Buffer"));
r=ldd.MapInBuffer(&buffer,&size);
test(r==KErrNone);
test.Next(_L("Fill and check physical address shared buffer"));
key=Math::Random();
fillBuffer(buffer,size,key);
test(ldd.CheckBuffer(key)==KErrNone);
key=Math::Random();
test(ldd.FillBuffer(key)==KErrNone);
test(checkBuffer(buffer,size,key)==KErrNone);
test.Next(_L("Map Out physical address Buffer"));
r=ldd.MapOutBuffer();
test(r==KErrNone);
test.Next(_L("Destroy a buffer with a physical address"));
r=ldd.DestroyBufferPhysAddr();
test(r==KErrNone);
}
test.Next(_L("Check using the same buffer by 2 different user processes"));
TAny* gbuffer;
TUint32 gsize;
r=ldd.MapInGlobalBuffer(RProcess().Id(),gbuffer,gsize);
test(r==KErrNone);
fillBuffer(gbuffer,gsize,23454);
r=ldd.MapOutGlobalBuffer();
test(r==KErrNone);
r=ldd.CreateBuffer(TestBufferSizes[testBufferSize]);
test(r==KErrNone);
r=ldd.MapInBuffer(&buffer,&size);
test(r==KErrNone);
test(CheckBuffer(buffer,size));
key=Math::Random();
fillBuffer(buffer,size,key);
test(ldd.CheckBuffer(key)==KErrNone);
RTestProcess rogueP;
TRequestStatus rendezvous;
TRequestStatus logon;
if(MemModelAttributes&EMemModelAttrProcessProt)
{
test.Next(_L("Checking buffers are protected at context switching"));
rogueP.Create(ETestProcess2,(TInt)buffer,(TInt)size);
rogueP.Logon(logon);
rogueP.Rendezvous(rendezvous);
rogueP.Resume();
User::WaitForRequest(rendezvous);
test(rendezvous==KProcessRendezvous);
User::WaitForRequest(logon);
test(rogueP.ExitType()==EExitPanic);
test(logon==3);
test(ldd.CheckBuffer(key)==KErrNone);
}
r=ldd.MapOutBuffer();
test(r==KErrNone);
r=ldd.DestroyBuffer();
test(r==KErrNone);
RTestProcess process;
if((MemModelAttributes&EMemModelAttrKernProt) && (MemModelAttributes&EMemModelTypeMask)!=EMemModelTypeDirect)
{
test.Next(_L("Checking writing to unmapped buffer"));
process.Create(ETestProcess1);
process.Logon(logon);
process.Rendezvous(rendezvous);
test(ldd.MapInGlobalBuffer(process.Id(),gbuffer,gsize)==KErrNone);
test(process.SetParameter(1,(TInt)gbuffer)==KErrNone);
test(process.SetParameter(2,(TInt)gsize)==KErrNone);
process.Resume();
User::WaitForRequest(rendezvous);
test(rendezvous==KProcessRendezvous);
User::WaitForRequest(logon);
test(process.ExitType()==EExitPanic);
test(logon==3);
process.Close();
}
r=ldd.CreateBuffer(TestBufferSizes[testBufferSize]);
if(r!=KErrNone)
return r;
r=ldd.MapInBuffer(&buffer,&size);
if(r!=KErrNone)
return r;
if(!CheckBuffer(buffer,size))
return KErrGeneral;
*(TInt*)buffer=KMagic1;
TPckg<TInt> buf(*(TInt*)buffer);
RTestProcess proc;
test.Next(_L("Checking address lookup is implemented"));
proc.Create(ETestProcess3,(TInt)&buf,RThread().Id());
proc.Logon(logon);
proc.Resume();
User::WaitForRequest(logon);
test(proc.ExitType()==EExitKill);
test(logon==0);
test(*(TInt*)buffer==KMagic2);
ldd.DestroyBuffer();
// Check process death whilst buffer is mapped in
// Test case for defect DEF051851 - Shared IO Buffer fault when process dies
test.Next(_L("Checking process death whilst buffer is mapped in"));
process.Create(ETestProcess1);
process.Logon(logon);
test.Start(_L("Map buffer into another process"));
test(ldd.MapInGlobalBuffer(process.Id(),gbuffer,gsize)==KErrNone);
test.Next(_L("Kill other process"));
process.Kill(99);
User::WaitForRequest(logon);
test(process.ExitType()==EExitKill);
test(logon==99);
process.Close();
test.Next(_L("Map out buffer"));
r=ldd.MapOutGlobalBuffer();
test.Printf(_L("result = %d\n"),r);
test(r==KErrNone);
test.Next(_L("Map buffer into this process"));
test(ldd.MapInGlobalBuffer(RProcess().Id(),gbuffer,gsize)==KErrNone);
test.Next(_L("Map out buffer from this process"));
r=ldd.MapOutGlobalBuffer();
test.Printf(_L("result = %d\n"),r);
test(r==KErrNone);
process.Create(ETestProcess1);
process.Logon(logon);
test.Next(_L("Map buffer into another process"));
test(ldd.MapInGlobalBuffer(process.Id(),gbuffer,gsize)==KErrNone);
test.Next(_L("Kill other process"));
process.Kill(99);
User::WaitForRequest(logon);
test(process.ExitType()==EExitKill);
test(logon==99);
process.Close();
test.Next(_L("Map out buffer"));
r=ldd.MapOutGlobalBuffer();
test.Printf(_L("result = %d\n"),r);
test(r==KErrNone);
test.End();
} // loop for next buffer size
test.Next(_L("Create and map in buffer"));
r=ldd.CreateBuffer(KTestBufferSize);
test(r==KErrNone);
r=ldd.MapInBuffer(&buffer,&size);
test(r==KErrNone);
// Test for DEF053512 - Can't delete SharedIo buffers in DLogicalDevice destructor
test.Next(_L("Map in global buffer"));
TAny* gbuffer;
TUint32 gsize;
test(ldd.MapInGlobalBuffer(RProcess().Id(),gbuffer,gsize)==KErrNone);
test.Next(_L("Closing channel (with a buffer still mapped in)"));
ldd.Close();
// Test for DEF053512 - Can't delete SharedIo buffers in DLogicalDevice destructor
test.Next(_L("Unload driver (whilst global buffer still mapped in)"));
r=User::FreeLogicalDevice(KSharedIoTestLddName);
test(r==KErrNone);
test.End();
return(0);
}
status_t SurfaceTexture::dequeueBuffer(int *outBuf, uint32_t w, uint32_t h,
uint32_t format, uint32_t usage) {
ST_LOGV("dequeueBuffer: w=%d h=%d fmt=%#x usage=%#x", w, h, format, usage);
if ((w && !h) || (!w && h)) {
ST_LOGE("dequeueBuffer: invalid size: w=%u, h=%u", w, h);
return BAD_VALUE;
}
status_t returnFlags(OK);
EGLDisplay dpy = EGL_NO_DISPLAY;
EGLSyncKHR fence = EGL_NO_SYNC_KHR;
{ // Scope for the lock
Mutex::Autolock lock(mMutex);
int found = -1;
int foundSync = -1;
int dequeuedCount = 0;
bool tryAgain = true;
#ifdef MISSING_GRALLOC_BUFFERS
int dequeueRetries = 5;
#endif
while (tryAgain) {
if (mAbandoned) {
ST_LOGE("dequeueBuffer: SurfaceTexture has been abandoned!");
return NO_INIT;
}
// We need to wait for the FIFO to drain if the number of buffer
// needs to change.
//
// The condition "number of buffers needs to change" is true if
// - the client doesn't care about how many buffers there are
// - AND the actual number of buffer is different from what was
// set in the last setBufferCountServer()
// - OR -
// setBufferCountServer() was set to a value incompatible with
// the synchronization mode (for instance because the sync mode
// changed since)
//
// As long as this condition is true AND the FIFO is not empty, we
// wait on mDequeueCondition.
const int minBufferCountNeeded = mSynchronousMode ?
MIN_SYNC_BUFFER_SLOTS : MIN_ASYNC_BUFFER_SLOTS;
const bool numberOfBuffersNeedsToChange = !mClientBufferCount &&
((mServerBufferCount != mBufferCount) ||
(mServerBufferCount < minBufferCountNeeded));
if (!mQueue.isEmpty() && numberOfBuffersNeedsToChange) {
// wait for the FIFO to drain
mDequeueCondition.wait(mMutex);
// NOTE: we continue here because we need to reevaluate our
// whole state (eg: we could be abandoned or disconnected)
continue;
}
if (numberOfBuffersNeedsToChange) {
// here we're guaranteed that mQueue is empty
freeAllBuffersLocked();
mBufferCount = mServerBufferCount;
if (mBufferCount < minBufferCountNeeded)
mBufferCount = minBufferCountNeeded;
mCurrentTexture = INVALID_BUFFER_SLOT;
returnFlags |= ISurfaceTexture::RELEASE_ALL_BUFFERS;
}
// look for a free buffer to give to the client
found = INVALID_BUFFER_SLOT;
foundSync = INVALID_BUFFER_SLOT;
dequeuedCount = 0;
for (int i = 0; i < mBufferCount; i++) {
const int state = mSlots[i].mBufferState;
if (state == BufferSlot::DEQUEUED) {
dequeuedCount++;
}
// if buffer is FREE it CANNOT be current
LOGW_IF((state == BufferSlot::FREE) && (mCurrentTexture==i),
"dequeueBuffer: buffer %d is both FREE and current!",
i);
if (FLAG_ALLOW_DEQUEUE_CURRENT_BUFFER) {
if (state == BufferSlot::FREE || i == mCurrentTexture) {
foundSync = i;
if (i != mCurrentTexture) {
found = i;
break;
}
}
} else {
if (state == BufferSlot::FREE) {
/* We return the oldest of the free buffers to avoid
* stalling the producer if possible. This is because
* the consumer may still have pending reads of the
* buffers in flight.
*/
bool isOlder = mSlots[i].mFrameNumber <
mSlots[found].mFrameNumber;
if (found < 0 || isOlder) {
foundSync = i;
found = i;
}
}
}
}
// clients are not allowed to dequeue more than one buffer
// if they didn't set a buffer count.
if (!mClientBufferCount && dequeuedCount) {
#ifdef MISSING_GRALLOC_BUFFERS
if (--dequeueRetries) {
LOGD("SurfaceTexture::dequeue: Not allowed to dequeue more "
"than a buffer SLEEPING\n");
usleep(10000);
} else {
mClientBufferCount = mServerBufferCount;
LOGD("SurfaceTexture::dequeue: Not allowed to dequeue more "
"than a buffer RETRY mBufferCount:%d mServerBufferCount:%d\n",
mBufferCount, mServerBufferCount);
}
continue;
#else
ST_LOGE("dequeueBuffer: can't dequeue multiple buffers without "
"setting the buffer count");
#endif
return -EINVAL;
}
// See whether a buffer has been queued since the last
// setBufferCount so we know whether to perform the
// MIN_UNDEQUEUED_BUFFERS check below.
bool bufferHasBeenQueued = mCurrentTexture != INVALID_BUFFER_SLOT;
if (bufferHasBeenQueued) {
// make sure the client is not trying to dequeue more buffers
// than allowed.
const int avail = mBufferCount - (dequeuedCount+1);
if (avail < (MIN_UNDEQUEUED_BUFFERS-int(mSynchronousMode))) {
#ifdef MISSING_GRALLOC_BUFFERS
if (mClientBufferCount != 0) {
mBufferCount++;
mClientBufferCount = mServerBufferCount = mBufferCount;
LOGD("SurfaceTexture::dequeuebuffer: MIN EXCEEDED "
"mBuffer:%d bumped\n", mBufferCount);
continue;
}
#endif
ST_LOGE("dequeueBuffer: MIN_UNDEQUEUED_BUFFERS=%d exceeded "
"(dequeued=%d)",
MIN_UNDEQUEUED_BUFFERS-int(mSynchronousMode),
dequeuedCount);
return -EBUSY;
}
}
// we're in synchronous mode and didn't find a buffer, we need to
// wait for some buffers to be consumed
tryAgain = mSynchronousMode && (foundSync == INVALID_BUFFER_SLOT);
if (tryAgain) {
mDequeueCondition.wait(mMutex);
}
}
if (mSynchronousMode && found == INVALID_BUFFER_SLOT) {
// foundSync guaranteed to be != INVALID_BUFFER_SLOT
found = foundSync;
}
if (found == INVALID_BUFFER_SLOT) {
// This should not happen.
ST_LOGE("dequeueBuffer: no available buffer slots");
return -EBUSY;
}
const int buf = found;
*outBuf = found;
const bool useDefaultSize = !w && !h;
if (useDefaultSize) {
// use the default size
w = mDefaultWidth;
h = mDefaultHeight;
}
const bool updateFormat = (format != 0);
if (!updateFormat) {
// keep the current (or default) format
format = mPixelFormat;
}
// buffer is now in DEQUEUED (but can also be current at the same time,
// if we're in synchronous mode)
mSlots[buf].mBufferState = BufferSlot::DEQUEUED;
const sp<GraphicBuffer>& buffer(mSlots[buf].mGraphicBuffer);
#ifdef QCOM_HARDWARE
qBufGeometry currentGeometry;
if (buffer != NULL)
currentGeometry.set(buffer->width, buffer->height, buffer->format);
else
currentGeometry.set(0, 0, 0);
qBufGeometry requiredGeometry;
requiredGeometry.set(w, h, format);
qBufGeometry updatedGeometry;
updatedGeometry.set(mNextBufferInfo.width, mNextBufferInfo.height,
mNextBufferInfo.format);
#endif
if ((buffer == NULL) ||
#ifdef QCOM_HARDWARE
needNewBuffer(currentGeometry, requiredGeometry, updatedGeometry) ||
#else
(uint32_t(buffer->width) != w) ||
(uint32_t(buffer->height) != h) ||
(uint32_t(buffer->format) != format) ||
#endif
((uint32_t(buffer->usage) & usage) != usage))
{
#ifdef QCOM_HARDWARE
if (buffer != NULL) {
mGraphicBufferAlloc->freeGraphicBufferAtIndex(buf);
}
#endif
usage |= GraphicBuffer::USAGE_HW_TEXTURE;
status_t error;
sp<GraphicBuffer> graphicBuffer(
mGraphicBufferAlloc->createGraphicBuffer(
w, h, format, usage, &error));
if (graphicBuffer == 0) {
ST_LOGE("dequeueBuffer: SurfaceComposer::createGraphicBuffer "
"failed");
return error;
}
if (updateFormat) {
mPixelFormat = format;
}
#ifdef QCOM_HARDWARE
checkBuffer((native_handle_t *)graphicBuffer->handle, mReqSize, usage);
#endif
mSlots[buf].mGraphicBuffer = graphicBuffer;
mSlots[buf].mRequestBufferCalled = false;
mSlots[buf].mFence = EGL_NO_SYNC_KHR;
if (mSlots[buf].mEglImage != EGL_NO_IMAGE_KHR) {
eglDestroyImageKHR(mSlots[buf].mEglDisplay,
mSlots[buf].mEglImage);
mSlots[buf].mEglImage = EGL_NO_IMAGE_KHR;
mSlots[buf].mEglDisplay = EGL_NO_DISPLAY;
}
if (mCurrentTexture == buf) {
// The current texture no longer references the buffer in this slot
// since we just allocated a new buffer.
mCurrentTexture = INVALID_BUFFER_SLOT;
}
returnFlags |= ISurfaceTexture::BUFFER_NEEDS_REALLOCATION;
}
dpy = mSlots[buf].mEglDisplay;
fence = mSlots[buf].mFence;
mSlots[buf].mFence = EGL_NO_SYNC_KHR;
}
if (fence != EGL_NO_SYNC_KHR) {
EGLint result = eglClientWaitSyncKHR(dpy, fence, 0, 1000000000);
// If something goes wrong, log the error, but return the buffer without
// synchronizing access to it. It's too late at this point to abort the
// dequeue operation.
if (result == EGL_FALSE) {
LOGE("dequeueBuffer: error waiting for fence: %#x", eglGetError());
} else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
LOGE("dequeueBuffer: timeout waiting for fence");
}
eglDestroySyncKHR(dpy, fence);
}
ST_LOGV("dequeueBuffer: returning slot=%d buf=%p flags=%#x", *outBuf,
mSlots[*outBuf].mGraphicBuffer->handle, returnFlags);
return returnFlags;
}
int testSR(Uint32 iVal, SectionSegmentPool* ssp, Uint32 len)
{
SectionReader srStepPeek(iVal, *ssp);
SectionReader srGetWord(iVal, *ssp);
SectionReader srPosSource(iVal, *ssp);
SectionReader srPosDest(iVal, *ssp);
SectionReader srPtrWord(iVal, *ssp);
VERIFY(srStepPeek.getSize() == len);
/* Reset the section readers at a random position */
const Uint32 noResetPos= 9999999;
Uint32 resetAt= len> 10 ? myRandom48(len) : noResetPos;
/* Read from the section readers, 1 word at a time */
for (Uint32 i=0; i < len; i++)
{
Uint32 peekWord;
Uint32 getWord;
const Uint32* ptrWord;
Uint32 ptrReadSize;
/* Check that peek, getWord and getWordsPtr return
* the same, correct value
*/
VERIFY(srStepPeek.peekWord(&peekWord));
if (i < (len -1))
VERIFY(srStepPeek.step(1));
VERIFY(srGetWord.getWord(&getWord));
VERIFY(srPtrWord.getWordsPtr(1, ptrWord, ptrReadSize));
VERIFY(ptrReadSize == 1);
//printf("PeekWord=%u, i=%u\n",
// peekWord, i);
VERIFY(peekWord == i);
VERIFY(peekWord == getWord);
VERIFY(peekWord == *ptrWord);
/* Check that one sectionReader with it's position
* set from the first returns the same, correct word
*/
SectionReader::PosInfo p= srPosSource.getPos();
srPosDest.setPos(p);
Uint32 srcWord, destWord;
VERIFY(srPosSource.getWord(&srcWord));
VERIFY(srPosDest.getWord(&destWord));
VERIFY(srcWord == peekWord);
VERIFY(srcWord == destWord);
/* Reset the readers */
if (i == resetAt)
{
//printf("Resetting\n");
resetAt= noResetPos;
i= (Uint32) -1;
srStepPeek.reset();
srGetWord.reset();
srPosSource.reset();
srPosDest.reset();
srPtrWord.reset();
}
else
{
if ((myRandom48(400) == 1) &&
(i < len -1))
{
/* Step all readers forward by some amount */
Uint32 stepSize= myRandom48((len - i) -1 );
//printf("Stepping %u words\n", stepSize);
VERIFY(srStepPeek.step(stepSize));
VERIFY(srGetWord.step(stepSize));
VERIFY(srPosSource.step(stepSize));
VERIFY(srPosDest.step(stepSize));
VERIFY(srPtrWord.step(stepSize));
i+= stepSize;
}
}
}
/* Check that there's nothing left in any reader */
VERIFY(!srStepPeek.step(1));
VERIFY(!srGetWord.step(1));
VERIFY(!srPosSource.step(1));
VERIFY(!srPosDest.step(1));
VERIFY(!srPtrWord.step(1));
srStepPeek.reset();
srGetWord.reset();
srPosSource.reset();
srPosDest.reset();
srPtrWord.reset();
/* Now read larger chunks of words */
Uint32 pos= 0;
Uint32* buffer= (Uint32*) malloc(len * 4);
VERIFY(buffer != NULL);
while (pos < len)
{
const Uint32 remain= len-pos;
const Uint32 readSize= remain == 1 ? 1 : myRandom48(remain);
//printf("Pos=%u Len=%u readSize=%u \n", pos, len, readSize);
/* Check that peek + step get the correct words */
VERIFY(srStepPeek.peekWords(buffer, readSize));
if (len > pos + readSize)
{
VERIFY(srStepPeek.step(readSize));
}
else
VERIFY(srStepPeek.step((len - pos) - 1));
VERIFY(checkBuffer(buffer, pos, readSize) == 0);
/* Check that getWords gets the correct words */
VERIFY(srGetWord.getWords(buffer, readSize));
VERIFY(checkBuffer(buffer, pos, readSize) == 0);
/* Check that using getPos + setPos gets the correct words */
VERIFY(srPosDest.setPos(srPosSource.getPos()));
VERIFY(srPosSource.getWords(buffer, readSize));
VERIFY(checkBuffer(buffer, pos, readSize) == 0);
VERIFY(srPosDest.getWords(buffer, readSize));
VERIFY(checkBuffer(buffer, pos, readSize) == 0);
/* Check that getWordsPtr gets the correct words */
Uint32 ptrWordsRead= 0;
//printf("Reading from ptr\n");
while (ptrWordsRead < readSize)
{
const Uint32* ptr= NULL;
Uint32 readLen;
VERIFY(srPtrWord.getWordsPtr((readSize - ptrWordsRead),
ptr,
readLen));
VERIFY(readLen <= readSize);
//printf("Read %u words, from pos %u, offset %u\n",
// readLen, pos, ptrWordsRead);
VERIFY(checkBuffer(ptr, pos+ ptrWordsRead, readLen) == 0);
ptrWordsRead+= readLen;
}
pos += readSize;
}
/* Check that there's no more words in any reader */
VERIFY(!srStepPeek.step(1));
VERIFY(!srGetWord.step(1));
VERIFY(!srPosSource.step(1));
VERIFY(!srPosDest.step(1));
VERIFY(!srPtrWord.step(1));
/* Verify that ptr-fetch variants do not fetch beyond
* the length, even if we ask for more
*/
srPtrWord.reset();
Uint32 readWords= 0;
while (readWords < len)
{
const Uint32* readPtr;
Uint32 wordsRead= 0;
VERIFY(srPtrWord.getWordsPtr(20, readPtr, wordsRead));
readWords+= wordsRead;
VERIFY(readWords <= len);
}
free(buffer);
return 0;
}
bool UdpChain::sendPacket( long time , TSocket& socket , SBuffer& buffer , NetAddress& addr )
{
if ( buffer.getFillSize() == 0 && time - mTimeLastUpdate > mTimeResendRel )
{
if ( mBufferRel.getFillSize() == 0 )
return false;
}
uint32 outgoing = ++mOutgoingSeq;
uint32 incoming = mIncomingAck;
uint32 bufSize = (uint32)buffer.getFillSize();
if ( bufSize )
{
if ( mBufferRel.getFreeSize() < bufSize )
{
mBufferRel.grow( mBufferRel.getMaxSize() * 2 );
Msg( "UDPChain::sendPacket : ReliableBuffer too small" );
}
size_t oldSize = mBufferRel.getFillSize();
mBufferRel.fill( outgoing );
mBufferRel.fill( incoming );
mBufferRel.fill( bufSize );
mBufferRel.append( buffer );
checkBuffer( mBufferRel.getData() , (int)mBufferRel.getFillSize() );
DataInfo info;
info.size = (uint32)( mBufferRel.getFillSize() - oldSize );
info.sequence = outgoing;
mInfoList.push_back( info );
buffer.clear();
mOutgoingAck = outgoing;
}
mBufferCache.clear();
try
{
if ( mOutgoingRel < mOutgoingAck )
{
mBufferCache.append( mBufferRel );
}
else
{
mBufferCache.fill( outgoing );
mBufferCache.fill( incoming );
mBufferCache.fill( 0 );
}
int count = 0;
while( mBufferCache.getAvailableSize() )
{
int numSend = mBufferCache.take( socket , addr );
++count;
if ( count == 10 )
{
return false;
}
}
mTimeLastUpdate = time;
}
catch ( BufferException& )
{
mBufferCache.resize( mBufferCache.getMaxSize() * 2 );
return false;
}
//Msg( "sendPacket %u %u %u" , outgoing , incoming , bufSize );
return true;
}
