GP<GStringRep>
GStringRep::Unicode::create(
void const * const xbuf,
const unsigned int bufsize,
const GP<Unicode> &xremainder )
{
Unicode *r=xremainder;
GP<GStringRep> retval;
if(r)
{
const int s=r->gremainder;
if(xbuf && bufsize)
{
if(s)
{
void *buf;
GPBufferBase gbuf(buf,s+bufsize,1);
memcpy(buf,r->remainder,s);
memcpy((void *)((size_t)buf+s),xbuf,bufsize);
retval=((r->encoding)
?create(buf,s+bufsize,r->encoding)
:create(buf,s+bufsize,r->encodetype));
}else
{
retval=((r->encoding)
?create(xbuf,bufsize,r->encoding)
:create(xbuf,bufsize,r->encodetype));
}
}else if(s)
{
void *buf;
GPBufferBase gbuf(buf,s,1);
memcpy(buf,r->remainder,s);
retval=((r->encoding)
?create(buf,s,r->encoding)
:create(buf,s,r->encodetype));
}else
{
retval=((r->encoding)
?create(0,0,r->encoding)
:create(0,0,r->encodetype));
}
}else
{
retval=create(xbuf,bufsize,XUTF8);
}
return retval;
}
int SurfaceTextureClient::dequeueBuffer(android_native_buffer_t** buffer) {
LOGV("SurfaceTextureClient::dequeueBuffer");
Mutex::Autolock lock(mMutex);
int buf = -1;
status_t result = mSurfaceTexture->dequeueBuffer(&buf, mReqWidth, mReqHeight,
mReqFormat, mReqUsage);
if (result < 0) {
LOGV("dequeueBuffer: ISurfaceTexture::dequeueBuffer(%d, %d, %d, %d)"
"failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage,
result);
return result;
}
sp<GraphicBuffer>& gbuf(mSlots[buf]);
if (result & ISurfaceTexture::RELEASE_ALL_BUFFERS) {
freeAllBuffers();
}
if ((result & ISurfaceTexture::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
result = mSurfaceTexture->requestBuffer(buf, &gbuf);
if (result != NO_ERROR) {
LOGE("dequeueBuffer: ISurfaceTexture::requestBuffer failed: %d",
result);
return result;
}
}
*buffer = gbuf.get();
return OK;
}
int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) {
ATRACE_CALL();
ALOGV("Surface::dequeueBuffer");
Mutex::Autolock lock(mMutex);
int buf = -1;
int reqW = mReqWidth ? mReqWidth : mUserWidth;
int reqH = mReqHeight ? mReqHeight : mUserHeight;
sp<Fence> fence;
status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, mSwapIntervalZero,
reqW, reqH, mReqFormat, mReqUsage);
if (result < 0) {
ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer(%d, %d, %d, %d)"
"failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage,
result);
return result;
}
sp<GraphicBuffer>& gbuf(mSlots[buf].buffer);
// this should never happen
ALOGE_IF(fence == NULL, "Surface::dequeueBuffer: received null Fence! buf=%d", buf);
if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) {
freeAllBuffers();
}
if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
result = mGraphicBufferProducer->requestBuffer(buf, &gbuf);
if (result != NO_ERROR) {
ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result);
return result;
} else if (gbuf == 0) {
ALOGE("dequeueBuffer: Buffer is null return");
return INVALID_OPERATION;
}
}
if ((fence != NULL) && fence->isValid()) {
*fenceFd = fence->dup();
if (*fenceFd == -1) {
ALOGE("dequeueBuffer: error duping fence: %d", errno);
// dup() should never fail; something is badly wrong. Soldier on
// and hope for the best; the worst that should happen is some
// visible corruption that lasts until the next frame.
}
} else {
*fenceFd = -1;
}
*buffer = gbuf.get();
#ifdef SURFACE_SKIP_FIRST_DEQUEUE
if (!mDequeuedOnce) mDequeuedOnce = true;
#endif
return OK;
}
GUTF8String
UnicodeByteStream::gets(
size_t const t,unsigned long const stopat,bool const inclusive)
{
GUTF8String retval;
unsigned int len=buffer.length()-bufferpos;
if(!len)
{
int i;
char *buf;
static const size_t bufsize=327680;
GPBuffer<char> gbuf(buf,bufsize);
while((i=read(buf,bufsize)>0))
{
if((len=buffer.length()-bufferpos))
break;
}
}
if(len)
{
int i=buffer.search((char)stopat,bufferpos);
if(i>=0)
{
if(inclusive)
{
++i;
}
if(t&&(i>(int)t+bufferpos))
{
i=t+bufferpos;
}
if(i>bufferpos)
{
retval=buffer.substr(bufferpos,i-bufferpos);
}
bufferpos=i;
linesread+=CountLines(retval);
}else
{
retval=buffer.substr(bufferpos,len);
bufferpos=buffer.length();
linesread+=CountLines(retval);
retval+=gets(t?(t-(i-bufferpos)):0,stopat,inclusive);
}
}
return retval;
}
int SurfaceTextureClient::dequeueBuffer(android_native_buffer_t** buffer,
int* fenceFd) {
ATRACE_CALL();
ALOGV("SurfaceTextureClient::dequeueBuffer");
Mutex::Autolock lock(mMutex);
int buf = -1;
int reqW = mReqWidth ? mReqWidth : mUserWidth;
int reqH = mReqHeight ? mReqHeight : mUserHeight;
sp<Fence> fence;
status_t result = mSurfaceTexture->dequeueBuffer(&buf, fence, reqW, reqH,
mReqFormat, mReqUsage);
if (result < 0) {
ALOGV("dequeueBuffer: ISurfaceTexture::dequeueBuffer(%d, %d, %d, %d)"
"failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage,
result);
return result;
}
sp<GraphicBuffer>& gbuf(mSlots[buf].buffer);
if (result & ISurfaceTexture::RELEASE_ALL_BUFFERS) {
freeAllBuffers();
}
if ((result & ISurfaceTexture::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
result = mSurfaceTexture->requestBuffer(buf, &gbuf);
if (result != NO_ERROR) {
ALOGE("dequeueBuffer: ISurfaceTexture::requestBuffer failed: %d",
result);
return result;
}
}
if (fence.get()) {
*fenceFd = fence->dup();
if (*fenceFd == -1) {
ALOGE("dequeueBuffer: error duping fence: %d", errno);
// dup() should never fail; something is badly wrong. Soldier on
// and hope for the best; the worst that should happen is some
// visible corruption that lasts until the next frame.
}
} else {
*fenceFd = -1;
}
*buffer = gbuf.get();
return OK;
}
int SurfaceTextureClient::dequeueBuffer(android_native_buffer_t** buffer) {
LOGV("SurfaceTextureClient::dequeueBuffer");
#ifdef GFX_TESTFRAMEWORK
nsecs_t startTime = systemTime();
TF_PRINT(TF_EVENT_START, "STClient", "DQ", "BUFFER:STC dequeue start");
#endif
Mutex::Autolock lock(mMutex);
int buf = -1;
status_t result = mSurfaceTexture->dequeueBuffer(&buf, mReqWidth, mReqHeight,
mReqFormat, mReqUsage);
if (result < 0) {
LOGV("dequeueBuffer: ISurfaceTexture::dequeueBuffer(%d, %d, %d, %d)"
"failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage,
result);
return result;
}
sp<GraphicBuffer>& gbuf(mSlots[buf]);
if (result & ISurfaceTexture::RELEASE_ALL_BUFFERS) {
freeAllBuffers();
}
if ((result & ISurfaceTexture::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
result = mSurfaceTexture->requestBuffer(buf, &gbuf);
if (result != NO_ERROR) {
LOGE("dequeueBuffer: ISurfaceTexture::requestBuffer failed: %d",
result);
return result;
}
}
*buffer = gbuf.get();
#ifdef GFX_TESTFRAMEWORK
sDequeueEndTime[buf] = systemTime();
sDequeueStartTime[buf] = startTime;
TF_PRINT(TF_EVENT_STOP, "STClient", "DQ",
"BUFFER:STC dequeue end bufSlot=%d buffer=%p",
buf, mSlots[buf]->handle);
#endif
return OK;
}
// -------------------------------------------------------------
// OptimizerImplementation::p_gatherProblem
// -------------------------------------------------------------
void
OptimizerImplementation::p_gatherProblem(void)
{
parallel::Communicator comm(this->communicator());
int nproc(comm.size());
int me(comm.rank());
// package up the local part of the problem into a string buffer;
// MPI serialization cannot be used directly because VariablePtr's
// are used in Expression's
std::string lbuf;
{
std::ostringstream oss;
boost::archive::binary_oarchive oa(oss);
oa & p_variables;
oa & p_constraints;
oa & p_objective;
oa & p_globalConstraints;
lbuf = oss.str();
}
// all processes get a copy of the other processor parts of the problem
std::vector<std::string> gbuf(nproc);
boost::mpi::all_gather(comm, lbuf, gbuf);
// extract the problem and put it in local variables as required
for (int p = 0; p < nproc; ++p) {
if (p != me) {
std::istringstream iss(gbuf[p]);
boost::archive::binary_iarchive ia(iss);
std::vector<VariablePtr> tmpvars;
std::vector<ConstraintPtr> tmpcons;
ConstraintMap tmpglobal;
ExpressionPtr tmpobj;
ia & tmpvars;
ia & tmpcons;
ia & tmpobj;
ia & tmpglobal;
for (std::vector<VariablePtr>::iterator v = tmpvars.begin();
v != tmpvars.end(); ++v) {
p_allVariables[(*v)->name()] = *v;
}
std::copy(tmpcons.begin(), tmpcons.end(),
std::back_inserter(p_allConstraints));
// ConstraintMap::const_iterator c;
// for (c = tmpglobal.begin(); c != tmpglobal.end(); ++c) {
// std::cout << me << ": " << p << ": " << c->second->name() << ": "
// << c->second->render() << std::endl;
// }
p_gatherGlobalConstraints(tmpglobal);
if (tmpobj) {
if (!p_fullObjective) {
p_fullObjective = tmpobj;
} else {
p_fullObjective = p_fullObjective + tmpobj;
}
}
} else {
std::copy(p_constraints.begin(), p_constraints.end(),
std::back_inserter(p_allConstraints));
// ConstraintMap::const_iterator c;
// for (c = p_globalConstraints.begin(); c != p_globalConstraints.end(); ++c) {
// std::cout << me << ": " << p << ": " << c->second->name() << ": "
// << c->second->render() << std::endl;
// }
p_gatherGlobalConstraints(p_globalConstraints);
if (p_objective) {
if (!p_fullObjective) {
p_fullObjective = p_objective;
} else {
p_fullObjective = p_fullObjective + p_objective;
}
}
}
comm.barrier();
}
// add global constraints to the constraints list
ConstraintMap::const_iterator c;
for (c = p_allGlobalConstraints.begin(); c != p_allGlobalConstraints.end(); ++c) {
// std::cout << me << ": after: " << c->second->name() << ": "
// << c->second->render() << std::endl;
p_allConstraints.push_back(c->second);
}
// make sure the locally defined variables are used on this processor
for (std::vector<VariablePtr>::iterator v = p_variables.begin();
v != p_variables.end(); ++v) {
p_allVariables[(*v)->name()] = *v;
}
// subsitute variables in constraints and objective so they are unique
VariableSubstituter vs(p_allVariables);
std::for_each(p_allConstraints.begin(), p_allConstraints.end(),
boost::bind(&Constraint::accept, _1, boost::ref(vs)));
p_fullObjective->accept(vs);
// uniquely name all constraints in parallel
if (nproc > 1) {
ConstraintRenamer r;
std::for_each(p_allConstraints.begin(), p_allConstraints.end(),
boost::bind(&Constraint::accept, _1, boost::ref(r)));
}
}
int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) {
ATRACE_CALL();
ALOGD("Surface::dequeueBuffer");
int reqW;
int reqH;
bool swapIntervalZero;
uint32_t reqFormat;
uint32_t reqUsage;
{
Mutex::Autolock lock(mMutex);
reqW = mReqWidth ? mReqWidth : mUserWidth;
reqH = mReqHeight ? mReqHeight : mUserHeight;
swapIntervalZero = mSwapIntervalZero;
reqFormat = mReqFormat;
reqUsage = mReqUsage;
} // Drop the lock so that we can still touch the Surface while blocking in IGBP::dequeueBuffer
int buf = -1;
sp<Fence> fence;
status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, swapIntervalZero,
reqW, reqH, reqFormat, reqUsage);
if (result < 0) {
ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer(%d, %d, %d, %d, %d)"
"failed: %d", swapIntervalZero, reqW, reqH, reqFormat, reqUsage,
result);
return result;
}
ALOGD("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer(%d, %d, %d, %d, %d)[slot %d]", swapIntervalZero, reqW, reqH, reqFormat, reqUsage,buf);
Mutex::Autolock lock(mMutex);
if(fence == NULL) ALOGD("return fence is null");
sp<GraphicBuffer>& gbuf(mSlots[buf].buffer);
// this should never happen
ALOGE_IF(fence == NULL, "Surface::dequeueBuffer: received null Fence! buf=%d", buf);
if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) {
ALOGD("release all buffers");
freeAllBuffers();
}
if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
ALOGD("call producer request buffers");
result = mGraphicBufferProducer->requestBuffer(buf, &gbuf);
if (result != NO_ERROR) {
ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result);
mGraphicBufferProducer->cancelBuffer(buf, fence);
return result;
}
}
if (fence->isValid()) {
*fenceFd = fence->dup();
if (*fenceFd == -1) {
ALOGE("dequeueBuffer: error duping fence: %d", errno);
// dup() should never fail; something is badly wrong. Soldier on
// and hope for the best; the worst that should happen is some
// visible corruption that lasts until the next frame.
}
} else {
*fenceFd = -1;
}
*buffer = gbuf.get();
mSingleBuffer = gbuf ;
ALOGD("save single ocked buffer ");
ALOGD ("dequeue get buffer %p",*buffer);
#ifdef SURFACE_SKIP_FIRST_DEQUEUE
if (!mDequeuedOnce) {
ALOGD("SKIP first dequeue");
mDequeuedOnce = true;
}
#endif
return OK;
}
TCPStream::TCPStream(TCPSocket &server, bool throwflag, timeout_t to) :
streambuf(), Socket(accept(server.getSocket(), NULL, NULL)),
#ifdef OLD_IOSTREAM
iostream()
#else
iostream((streambuf *)this)
#endif
,bufsize(0)
,gbuf(NULL)
,pbuf(NULL) {
tpport_t port;
family = IPV4;
#ifdef OLD_IOSTREAM
init((streambuf *)this);
#endif
timeout = to;
setError(throwflag);
IPV4Host host = getPeer(&port);
if(!server.onAccept(host, port)) {
endSocket();
error(errConnectRejected);
iostream::clear(ios::failbit | rdstate());
return;
}
segmentBuffering(server.getSegmentSize());
Socket::state = CONNECTED;
}
#ifdef CCXX_IPV6
TCPStream::TCPStream(TCPV6Socket &server, bool throwflag, timeout_t to) :
streambuf(), Socket(accept(server.getSocket(), NULL, NULL)),
#ifdef OLD_IOSTREAM
iostream()
#else
iostream((streambuf *)this)
#endif
,bufsize(0)
,gbuf(NULL)
,pbuf(NULL) {
tpport_t port;
family = IPV6;
#ifdef OLD_IOSTREAM
init((streambuf *)this);
#endif
timeout = to;
setError(throwflag);
IPV6Host host = getIPV6Peer(&port);
if(!server.onAccept(host, port)) {
endSocket();
error(errConnectRejected);
iostream::clear(ios::failbit | rdstate());
return;
}
segmentBuffering(server.getSegmentSize());
Socket::state = CONNECTED;
}
#endif
TCPStream::TCPStream(const IPV4Host &host, tpport_t port, unsigned size, bool throwflag, timeout_t to) :
streambuf(), Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP),
#ifdef OLD_IOSTREAM
iostream(),
#else
iostream((streambuf *)this),
#endif
bufsize(0),gbuf(NULL),pbuf(NULL) {
#ifdef OLD_IOSTREAM
init((streambuf *)this);
#endif
family = IPV4;
timeout = to;
setError(throwflag);
connect(host, port, size);
}
#ifdef CCXX_IPV6
TCPStream::TCPStream(const IPV6Host &host, tpport_t port, unsigned size, bool throwflag, timeout_t to) :
streambuf(), Socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP),
#ifdef OLD_IOSTREAM
iostream(),
#else
iostream((streambuf *)this),
#endif
bufsize(0),gbuf(NULL),pbuf(NULL) {
family = IPV6;
#ifdef OLD_IOSTREAM
init((streambuf *)this);
#endif
timeout = to;
setError(throwflag);
connect(host, port, size);
}
#endif
TCPStream::~TCPStream()
{
#ifdef CCXX_EXCEPTIONS
try { endStream(); }
catch( ... ) { if ( ! std::uncaught_exception()) throw;};
#else
endStream();
#endif
}
#ifdef HAVE_GETADDRINFO
void TCPStream::connect(const char *target, unsigned mss)
{
char namebuf[128];
char *cp;
struct addrinfo hint, *list = NULL, *next, *first;
bool connected = false;
snprintf(namebuf, sizeof(namebuf), "%s", target);
cp = strrchr(namebuf, '/');
if(!cp)
cp = strrchr(namebuf, ':');
if(!cp) {
endStream();
connectError();
return;
}
*(cp++) = 0;
memset(&hint, 0, sizeof(hint));
hint.ai_family = family;
hint.ai_socktype = SOCK_STREAM;
hint.ai_protocol = IPPROTO_TCP;
if(getaddrinfo(namebuf, cp, &hint, &list) || !list) {
endStream();
connectError();
return;
}
first = list;
#ifdef TCP_MAXSEG
if(mss)
setsockopt(so, IPPROTO_TCP, TCP_MAXSEG, (char *)&mss, sizeof(mss));
#endif
while(list) {
if(!::connect(so, list->ai_addr, (socklen_t)list->ai_addrlen)) {
connected = true;
break;
}
next = list->ai_next;
list = next;
}
freeaddrinfo(first);
if(!connected) {
endStream();
connectError();
return;
}
segmentBuffering(mss);
Socket::state = CONNECTED;
}
int GonkNativeWindowClient::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) {
ATRACE_CALL();
ALOGV("GonkNativeWindowClient::dequeueBuffer");
int reqW;
int reqH;
bool swapIntervalZero;
uint32_t reqFormat;
uint32_t reqUsage;
{
Mutex::Autolock lock(mMutex);
reqW = mReqWidth ? mReqWidth : mUserWidth;
reqH = mReqHeight ? mReqHeight : mUserHeight;
swapIntervalZero = mSwapIntervalZero;
reqFormat = mReqFormat;
reqUsage = mReqUsage;
} // Drop the lock so that we can still touch the GonkNativeWindowClient while blocking in IGBP::dequeueBuffer
int buf = -1;
sp<Fence> fence;
status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, swapIntervalZero,
reqW, reqH, reqFormat, reqUsage);
if (result < 0) {
ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer(%d, %d, %d, %d, %d)"
"failed: %d", swapIntervalZero, reqW, reqH, reqFormat, reqUsage,
result);
return result;
}
Mutex::Autolock lock(mMutex);
sp<GraphicBuffer>& gbuf(mSlots[buf].buffer);
// this should never happen
ALOGE_IF(fence == NULL, "GonkNativeWindowClient::dequeueBuffer: received null Fence! buf=%d", buf);
if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) {
freeAllBuffers();
}
if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
result = mGraphicBufferProducer->requestBuffer(buf, &gbuf);
if (result != NO_ERROR) {
ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result);
mGraphicBufferProducer->cancelBuffer(buf, fence);
return result;
}
}
if (fence->isValid()) {
*fenceFd = fence->dup();
if (*fenceFd == -1) {
ALOGE("dequeueBuffer: error duping fence: %d", errno);
// dup() should never fail; something is badly wrong. Soldier on
// and hope for the best; the worst that should happen is some
// visible corruption that lasts until the next frame.
}
} else {
*fenceFd = -1;
}
*buffer = gbuf.get();
return OK;
}
