void ofxBaseShaderNode::update(){ //if not dirty, nothing to do if(!getDirty()) return; //cout<<"drawing node "<<name<<endl; //first, recursively make sure all dependencies are up to date for(auto node:inputs){ node->update(); } //get a buffer and draw to it if(!output){ requestBuffer(); } draw(); setDirty(false); //now that we've drawn, dependents can start to draw, so set the counter dependent_count = num_dependents; //update inputs so they know when to free resources for(auto node:inputs){ node->decrementDependents(); } }
void ofxBaseShaderNode::scaleResolution(float ws, float hs){ settings.width*=ws; settings.height*=hs; if(output){ releaseBuffer(); requestBuffer(); } }
//override to copy fbo content void ofxConstantShaderNode::scaleResolution(float ws, float hs){ settings.width*=ws; settings.height*=hs; if(output){ ofFbo *output_old = output; releaseBuffer(); requestBuffer(); if(output!=output_old){ output->begin(); output_old->draw(0,0,output->getWidth(), output->getHeight()); output->end(); } } }
int PreviewStream::processFrame(CameraFrame *frame) { status_t ret = NO_ERROR; if (mShowFps) { showFps(); } ret = renderBuffer(frame); if (ret != NO_ERROR) { FLOGE("%s renderBuffer failed, state %d", __FUNCTION__, frame->getState()); goto err_exit; } //the frame held in service. frame->addReference(); StreamBuffer buffer; ret = requestBuffer(&buffer); if (ret != NO_ERROR) { FLOGE("%s requestBuffer failed", __FUNCTION__); goto err_exit; } for (int i = 0; i < mTotalBuffers; i++) { if (mCameraBuffer[i].mBufHandle == buffer.mBufHandle) { //release frame from service. mCameraBuffer[i].release(); break; } } err_exit: sem_post(&mRespondSem); return ret; }
int BinHTTPInputStreamCommon::sendRequest(const XMLURL &url, const XMLNetHTTPInfo *httpInfo) { // // Constants in ASCII to send/check in the HTTP request/response // static const char *CRLF2X = "\r\n\r\n"; static const char *LF2X = "\n\n"; // The port is open and ready to go. // Build up the http GET command to send to the server. CharBuffer requestBuffer(1023, fMemoryManager); createHTTPRequest(url, httpInfo, requestBuffer); // Send the http request if(!send(requestBuffer.getRawBuffer(), requestBuffer.getLen())) { ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_WriteSocket, url.getURLText(), fMemoryManager); } if(httpInfo && httpInfo->fPayload) { if(!send(httpInfo->fPayload, httpInfo->fPayloadLen)) { ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_WriteSocket, url.getURLText(), fMemoryManager); } } // // get the response, check the http header for errors from the server. // char tmpBuf[1024]; int ret; fBuffer.reset(); while(true) { ret = receive(tmpBuf, sizeof(tmpBuf)); if(ret == -1) { ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, url.getURLText(), fMemoryManager); } fBuffer.append(tmpBuf, ret); fBufferPos = strstr(fBuffer.getRawBuffer(), CRLF2X); if(fBufferPos != 0) { fBufferPos += 4; *(fBufferPos - 2) = 0; break; } fBufferPos = strstr(fBuffer.getRawBuffer(), LF2X); if(fBufferPos != 0) { fBufferPos += 2; *(fBufferPos - 1) = 0; break; } } // Parse the response status char *p = strstr(fBuffer.getRawBuffer(), "HTTP"); if(p == 0) { ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, url.getURLText(), fMemoryManager); } p = strchr(p, chSpace); if(p == 0) { ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, url.getURLText(), fMemoryManager); } return atoi(p); }
status_t BnGraphicBufferProducer::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case REQUEST_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int bufferIdx = data.readInt32(); sp<GraphicBuffer> buffer; int result = requestBuffer(bufferIdx, &buffer); reply->writeInt32(buffer != 0); if (buffer != 0) { reply->write(*buffer); } reply->writeInt32(result); return NO_ERROR; } break; case SET_BUFFER_COUNT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int bufferCount = data.readInt32(); int result = setBufferCount(bufferCount); reply->writeInt32(result); return NO_ERROR; } break; case DEQUEUE_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); bool async = data.readInt32(); uint32_t w = data.readInt32(); uint32_t h = data.readInt32(); uint32_t format = data.readInt32(); uint32_t usage = data.readInt32(); int buf; sp<Fence> fence; int result = dequeueBuffer(&buf, &fence, async, w, h, format, usage); reply->writeInt32(buf); reply->writeInt32(fence != NULL); if (fence != NULL) { reply->write(*fence); } reply->writeInt32(result); return NO_ERROR; } break; case QUEUE_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int buf = data.readInt32(); QueueBufferInput input(data); QueueBufferOutput* const output = reinterpret_cast<QueueBufferOutput *>( reply->writeInplace(sizeof(QueueBufferOutput))); status_t result = queueBuffer(buf, input, output); reply->writeInt32(result); return NO_ERROR; } break; case CANCEL_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int buf = data.readInt32(); sp<Fence> fence = new Fence(); data.read(*fence.get()); cancelBuffer(buf, fence); return NO_ERROR; } break; case QUERY: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int value; int what = data.readInt32(); int res = query(what, &value); reply->writeInt32(value); reply->writeInt32(res); return NO_ERROR; } break; #ifdef USE_K3V2OEM1 #else case SET_BUFFERS_SIZE: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int size = data.readInt32(); status_t res = setBuffersSize(size); reply->writeInt32(res); return NO_ERROR; } break; #endif case CONNECT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); sp<IBinder> token = data.readStrongBinder(); int api = data.readInt32(); bool producerControlledByApp = data.readInt32(); QueueBufferOutput* const output = reinterpret_cast<QueueBufferOutput *>( reply->writeInplace(sizeof(QueueBufferOutput))); status_t res = connect(token, api, producerControlledByApp, output); reply->writeInt32(res); return NO_ERROR; } break; case DISCONNECT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int api = data.readInt32(); status_t res = disconnect(api); reply->writeInt32(res); return NO_ERROR; } break; } return BBinder::onTransact(code, data, reply, flags); }
status_t BnSurfaceTexture::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case REQUEST_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int bufferIdx = data.readInt32(); sp<GraphicBuffer> buffer; int result = requestBuffer(bufferIdx, &buffer); reply->writeInt32(buffer != 0); if (buffer != 0) { reply->write(*buffer); } reply->writeInt32(result); return NO_ERROR; } break; case SET_BUFFER_COUNT: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int bufferCount = data.readInt32(); int result = setBufferCount(bufferCount); reply->writeInt32(result); return NO_ERROR; } break; case DEQUEUE_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); uint32_t w = data.readInt32(); uint32_t h = data.readInt32(); uint32_t format = data.readInt32(); uint32_t usage = data.readInt32(); int buf; int result = dequeueBuffer(&buf, w, h, format, usage); reply->writeInt32(buf); reply->writeInt32(result); return NO_ERROR; } break; case QUEUE_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int buf = data.readInt32(); QueueBufferInput const* const input = reinterpret_cast<QueueBufferInput const *>( data.readInplace(sizeof(QueueBufferInput))); QueueBufferOutput* const output = reinterpret_cast<QueueBufferOutput *>( reply->writeInplace(sizeof(QueueBufferOutput))); status_t result = queueBuffer(buf, *input, output); reply->writeInt32(result); return NO_ERROR; } break; case CANCEL_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int buf = data.readInt32(); cancelBuffer(buf); return NO_ERROR; } break; case QUERY: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int value; int what = data.readInt32(); int res = query(what, &value); reply->writeInt32(value); reply->writeInt32(res); return NO_ERROR; } break; case SET_SYNCHRONOUS_MODE: { CHECK_INTERFACE(ISurfaceTexture, data, reply); bool enabled = data.readInt32(); status_t res = setSynchronousMode(enabled); reply->writeInt32(res); return NO_ERROR; } break; #ifdef QCOM_HARDWARE case SET_BUFFERS_SIZE: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int size = data.readInt32(); status_t res = setBuffersSize(size); reply->writeInt32(res); return NO_ERROR; } break; case SET_MIN_UNDEQUEUED_BUFFER_COUNT: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int size = data.readInt32(); status_t res = setMinUndequeuedBufferCount(size); reply->writeInt32(res); return NO_ERROR; } break; #endif case CONNECT: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int api = data.readInt32(); QueueBufferOutput* const output = reinterpret_cast<QueueBufferOutput *>( reply->writeInplace(sizeof(QueueBufferOutput))); status_t res = connect(api, output); reply->writeInt32(res); return NO_ERROR; } break; case DISCONNECT: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int api = data.readInt32(); status_t res = disconnect(api); reply->writeInt32(res); return NO_ERROR; } break; } return BBinder::onTransact(code, data, reply, flags); }
status_t BnGraphicBufferProducer::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case REQUEST_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int bufferIdx = data.readInt32(); sp<GraphicBuffer> buffer; int result = requestBuffer(bufferIdx, &buffer); reply->writeInt32(buffer != 0); if (buffer != 0) { reply->write(*buffer); } reply->writeInt32(result); return NO_ERROR; } break; case SET_BUFFER_COUNT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int bufferCount = data.readInt32(); int result = setBufferCount(bufferCount); reply->writeInt32(result); return NO_ERROR; } break; case DEQUEUE_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); uint32_t w = data.readInt32(); uint32_t h = data.readInt32(); uint32_t format = data.readInt32(); uint32_t usage = data.readInt32(); int buf; sp<Fence> fence; int result = dequeueBuffer(&buf, &fence, w, h, format, usage); reply->writeInt32(buf); reply->writeInt32(fence != NULL); if (fence != NULL) { reply->write(*fence.get()); } reply->writeInt32(result); return NO_ERROR; } break; case QUEUE_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int buf = data.readInt32(); QueueBufferInput input(data); QueueBufferOutput* const output = reinterpret_cast<QueueBufferOutput *>( reply->writeInplace(sizeof(QueueBufferOutput))); status_t result = queueBuffer(buf, input, output); reply->writeInt32(result); return NO_ERROR; } break; case CANCEL_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int buf = data.readInt32(); sp<Fence> fence = new Fence(); data.read(*fence.get()); cancelBuffer(buf, fence); return NO_ERROR; } break; case QUERY: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int value; int what = data.readInt32(); int res = query(what, &value); reply->writeInt32(value); reply->writeInt32(res); return NO_ERROR; } break; case SET_SYNCHRONOUS_MODE: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); bool enabled = data.readInt32(); status_t res = setSynchronousMode(enabled); reply->writeInt32(res); return NO_ERROR; } break; case CONNECT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int api = data.readInt32(); QueueBufferOutput* const output = reinterpret_cast<QueueBufferOutput *>( reply->writeInplace(sizeof(QueueBufferOutput))); status_t res = connect(api, output); reply->writeInt32(res); return NO_ERROR; } break; case DISCONNECT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int api = data.readInt32(); status_t res = disconnect(api); reply->writeInt32(res); return NO_ERROR; } break; } return BBinder::onTransact(code, data, reply, flags); }
status_t BnSurfaceTexture::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case REQUEST_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int bufferIdx = data.readInt32(); sp<GraphicBuffer> buffer; int result = requestBuffer(bufferIdx, &buffer); reply->writeInt32(buffer != 0); if (buffer != 0) { reply->write(*buffer); } reply->writeInt32(result); return NO_ERROR; } break; case SET_BUFFER_COUNT: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int bufferCount = data.readInt32(); int result = setBufferCount(bufferCount); reply->writeInt32(result); return NO_ERROR; } break; case DEQUEUE_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); uint32_t w = data.readInt32(); uint32_t h = data.readInt32(); uint32_t format = data.readInt32(); uint32_t usage = data.readInt32(); int buf; sp<Fence> fence; int result = dequeueBuffer(&buf, fence, w, h, format, usage); bool hasFence = fence.get() && fence->isValid(); reply->writeInt32(buf); reply->writeInt32(hasFence); if (hasFence) { reply->write(*fence.get()); } reply->writeInt32(result); return NO_ERROR; } break; case QUEUE_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int buf = data.readInt32(); QueueBufferInput input(data); QueueBufferOutput* const output = reinterpret_cast<QueueBufferOutput *>( reply->writeInplace(sizeof(QueueBufferOutput))); status_t result = queueBuffer(buf, input, output); reply->writeInt32(result); return NO_ERROR; } break; case CANCEL_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int buf = data.readInt32(); sp<Fence> fence; bool hasFence = data.readInt32(); if (hasFence) { fence = new Fence(); data.read(*fence.get()); } cancelBuffer(buf, fence); return NO_ERROR; } break; case QUERY: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int value; int what = data.readInt32(); int res = query(what, &value); reply->writeInt32(value); reply->writeInt32(res); return NO_ERROR; } break; case SET_SYNCHRONOUS_MODE: { CHECK_INTERFACE(ISurfaceTexture, data, reply); bool enabled = data.readInt32(); status_t res = setSynchronousMode(enabled); reply->writeInt32(res); return NO_ERROR; } break; #ifdef QCOM_BSP case UPDATE_BUFFERS_GEOMETRY: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int w = data.readInt32(); int h = data.readInt32(); int f = data.readInt32(); status_t res = updateBuffersGeometry(w, h, f); reply->writeInt32(res); return NO_ERROR; } break; case SET_BUFFERS_SIZE: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int size = data.readInt32(); status_t res = setBuffersSize(size); reply->writeInt32(res); return NO_ERROR; } break; #endif case CONNECT: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int api = data.readInt32(); QueueBufferOutput* const output = reinterpret_cast<QueueBufferOutput *>( reply->writeInplace(sizeof(QueueBufferOutput))); status_t res = connect(api, output); reply->writeInt32(res); return NO_ERROR; } break; case DISCONNECT: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int api = data.readInt32(); status_t res = disconnect(api); reply->writeInt32(res); return NO_ERROR; } break; } return BBinder::onTransact(code, data, reply, flags); }
status_t BnGraphicBufferProducer::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case REQUEST_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int bufferIdx = data.readInt32(); sp<GraphicBuffer> buffer; int result = requestBuffer(bufferIdx, &buffer); reply->writeInt32(buffer != 0); if (buffer != 0) { reply->write(*buffer); } reply->writeInt32(result); return NO_ERROR; } break; case SET_BUFFER_COUNT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int bufferCount = data.readInt32(); int result = setBufferCount(bufferCount); reply->writeInt32(result); return NO_ERROR; } break; case DEQUEUE_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); bool async = data.readInt32(); uint32_t w = data.readInt32(); uint32_t h = data.readInt32(); uint32_t format = data.readInt32(); uint32_t usage = data.readInt32(); int buf; sp<Fence> fence; int result = dequeueBuffer(&buf, &fence, async, w, h, format, usage); reply->writeInt32(buf); reply->writeInt32(fence != NULL); if (fence != NULL) { reply->write(*fence); } reply->writeInt32(result); return NO_ERROR; } break; case QUEUE_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int buf = data.readInt32(); QueueBufferInput input(data); QueueBufferOutput* const output = reinterpret_cast<QueueBufferOutput *>( reply->writeInplace(sizeof(QueueBufferOutput))); status_t result = queueBuffer(buf, input, output); reply->writeInt32(result); return NO_ERROR; } break; case CANCEL_BUFFER: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int buf = data.readInt32(); sp<Fence> fence = new Fence(); data.read(*fence.get()); cancelBuffer(buf, fence); return NO_ERROR; } break; case QUERY: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int value; int what = data.readInt32(); int res = query(what, &value); reply->writeInt32(value); reply->writeInt32(res); return NO_ERROR; } break; case CONNECT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); sp<IBinder> token = data.readStrongBinder(); int api = data.readInt32(); bool producerControlledByApp = data.readInt32(); QueueBufferOutput* const output = reinterpret_cast<QueueBufferOutput *>( reply->writeInplace(sizeof(QueueBufferOutput))); status_t res = connect(token, api, producerControlledByApp, output); reply->writeInt32(res); return NO_ERROR; } break; case DISCONNECT: { CHECK_INTERFACE(IGraphicBufferProducer, data, reply); int api = data.readInt32(); status_t res = disconnect(api); reply->writeInt32(res); return NO_ERROR; } break; case SET_CROP: { Rect reg; CHECK_INTERFACE(ISurfaceTexture, data, reply); reg.left = data.readFloat(); reg.top = data.readFloat(); reg.right = data.readFloat(); reg.bottom = data.readFloat(); status_t result = setCrop(reg); reply->writeInt32(result); return NO_ERROR; } break; case SET_TRANSFORM: { uint32_t transform; CHECK_INTERFACE(ISurfaceTexture, data, reply); transform = data.readInt32(); status_t result = setCurrentTransform(transform); reply->writeInt32(result); return NO_ERROR; } break; case SET_SCALINGMODE: { uint32_t scalingmode; CHECK_INTERFACE(ISurfaceTexture, data, reply); scalingmode = data.readInt32(); status_t result = setCurrentScalingMode(scalingmode); reply->writeInt32(result); return NO_ERROR; } break; case SET_TIMESTEAP: { uint32_t timestamp; CHECK_INTERFACE(ISurfaceTexture, data, reply); timestamp = data.readInt64(); status_t result = setTimestamp(timestamp); reply->writeInt32(result); return NO_ERROR; } break; case SET_PARAMETER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); uint32_t cmd = (uint32_t)data.readInt32(); uint32_t value; if(cmd == HWC_LAYER_SETINITPARA) { layerinitpara_t layer_info; data.read((void *)&layer_info,sizeof(layerinitpara_t)); value = (uint32_t)&layer_info; } else if(cmd == HWC_LAYER_SETFRAMEPARA) { libhwclayerpara_t frame_info; data.read((void *)&frame_info,sizeof(libhwclayerpara_t)); value = (uint32_t)&frame_info; } else if(cmd == HWC_LAYER_SET3DMODE) { video3Dinfo_t _3d_info; data.read((void *)&_3d_info, sizeof(video3Dinfo_t)); value = (uint32_t)&_3d_info; } else { value = (uint32_t)data.readInt32(); } int res = setParameter(cmd,value); reply->writeInt32(res); return NO_ERROR; } break; case GET_PARAMETER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); uint32_t cmd = (uint32_t)data.readInt32(); uint32_t res = getParameter(cmd); reply->writeInt32((int32_t)res); return NO_ERROR; } break; } return BBinder::onTransact(code, data, reply, flags); }
status_t BnSurfaceTexture::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case REQUEST_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int bufferIdx = data.readInt32(); sp<GraphicBuffer> buffer; int result = requestBuffer(bufferIdx, &buffer); reply->writeInt32(buffer != 0); if (buffer != 0) { reply->write(*buffer); } reply->writeInt32(result); return NO_ERROR; } break; case SET_BUFFER_COUNT: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int bufferCount = data.readInt32(); int result = setBufferCount(bufferCount); reply->writeInt32(result); return NO_ERROR; } break; case DEQUEUE_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); uint32_t w = data.readInt32(); uint32_t h = data.readInt32(); uint32_t format = data.readInt32(); uint32_t usage = data.readInt32(); int buf; int result = dequeueBuffer(&buf, w, h, format, usage); reply->writeInt32(buf); reply->writeInt32(result); return NO_ERROR; } break; case QUEUE_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int buf = data.readInt32(); int64_t timestamp = data.readInt64(); uint32_t outWidth, outHeight, outTransform; status_t result = queueBuffer(buf, timestamp, &outWidth, &outHeight, &outTransform); reply->writeInt32(outWidth); reply->writeInt32(outHeight); reply->writeInt32(outTransform); reply->writeInt32(result); return NO_ERROR; } break; case CANCEL_BUFFER: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int buf = data.readInt32(); cancelBuffer(buf); return NO_ERROR; } break; case SET_CROP: { Rect reg; CHECK_INTERFACE(ISurfaceTexture, data, reply); reg.left = data.readFloat(); reg.top = data.readFloat(); reg.right = data.readFloat(); reg.bottom = data.readFloat(); status_t result = setCrop(reg); reply->writeInt32(result); return NO_ERROR; } break; case SET_TRANSFORM: { CHECK_INTERFACE(ISurfaceTexture, data, reply); uint32_t transform = data.readInt32(); status_t result = setTransform(transform); reply->writeInt32(result); return NO_ERROR; } break; case SET_SCALING_MODE: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int mode = data.readInt32(); status_t result = setScalingMode(mode); reply->writeInt32(result); return NO_ERROR; } break; case QUERY: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int value; int what = data.readInt32(); int res = query(what, &value); reply->writeInt32(value); reply->writeInt32(res); return NO_ERROR; } break; case SET_SYNCHRONOUS_MODE: { CHECK_INTERFACE(ISurfaceTexture, data, reply); bool enabled = data.readInt32(); status_t res = setSynchronousMode(enabled); reply->writeInt32(res); return NO_ERROR; } break; case CONNECT: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int api = data.readInt32(); uint32_t outWidth, outHeight, outTransform; status_t res = connect(api, &outWidth, &outHeight, &outTransform); reply->writeInt32(outWidth); reply->writeInt32(outHeight); reply->writeInt32(outTransform); reply->writeInt32(res); return NO_ERROR; } break; case DISCONNECT: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int api = data.readInt32(); status_t res = disconnect(api); reply->writeInt32(res); return NO_ERROR; } break; // [MTK] for S3D offset control //-------------------------------------------------------------- case SET_S3DOFFSET: { CHECK_INTERFACE(ISurfaceTexture, data, reply); int32_t offset = data.readInt32(); status_t result = setS3DOffset(offset); reply->writeInt32(result); return NO_ERROR; } break; } return BBinder::onTransact(code, data, reply, flags); }
//override constructor to request a buffer ofxConstantShaderNode::ofxConstantShaderNode(ofxFboAllocator *a, ofFbo::Settings s, string n) : ofxBaseShaderNode(a, s, n, NULL){ requestBuffer(); }
status_t BnSurface::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case REQUEST_BUFFER: { CHECK_INTERFACE(ISurface, data, reply); int bufferIdx = data.readInt32(); uint32_t w = data.readInt32(); uint32_t h = data.readInt32(); uint32_t format = data.readInt32(); uint32_t usage = data.readInt32(); sp<GraphicBuffer> buffer(requestBuffer(bufferIdx, w, h, format, usage)); if (buffer == NULL) return BAD_VALUE; return reply->write(*buffer); } case SET_BUFFER_COUNT: { CHECK_INTERFACE(ISurface, data, reply); int bufferCount = data.readInt32(); status_t err = setBufferCount(bufferCount); reply->writeInt32(err); return NO_ERROR; } case REGISTER_BUFFERS: { CHECK_INTERFACE(ISurface, data, reply); BufferHeap buffer; buffer.w = data.readInt32(); buffer.h = data.readInt32(); buffer.hor_stride = data.readInt32(); buffer.ver_stride= data.readInt32(); buffer.format = data.readInt32(); buffer.transform = data.readInt32(); buffer.flags = data.readInt32(); buffer.heap = interface_cast<IMemoryHeap>(data.readStrongBinder()); status_t err = registerBuffers(buffer); reply->writeInt32(err); return NO_ERROR; } break; case UNREGISTER_BUFFERS: { CHECK_INTERFACE(ISurface, data, reply); unregisterBuffers(); return NO_ERROR; } break; case POST_BUFFER: { CHECK_INTERFACE(ISurface, data, reply); ssize_t offset = data.readInt32(); postBuffer(offset); return NO_ERROR; } break; case CREATE_OVERLAY: { CHECK_INTERFACE(ISurface, data, reply); int w = data.readInt32(); int h = data.readInt32(); int f = data.readInt32(); int orientation = data.readInt32(); sp<OverlayRef> o = createOverlay(w, h, f, orientation); return OverlayRef::writeToParcel(reply, o); } break; default: return BBinder::onTransact(code, data, reply, flags); } }