// Get a frame from the camera device void getFrames(int noFrames, int minNoFrames, int* fd, int* imgCaptureType, int cqual, int fps, int bufferSize) { struct v4l2_buffer buf; struct buffer* bufs; struct v4l2_requestbuffers reqbuf = getReqBufs(noFrames, minNoFrames, fd); unsigned int n_buffers, i, ctr = 0; bool started = FALSE, streamOn = false; struct lstnode* cNode = allocate(bufferSize); pthread_mutex_t* mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t)); pthread_mutex_init(mutex, NULL); struct imgDetails det = getFrameFormat(fd); // get video format details bufs = (struct buffer*)calloc(reqbuf.count, sizeof(*bufs)); // alloc buffers // If allocation fails if (bufs == NULL) exitWithError("Could not allocate buffers."); // Map the memory in kernel space to user space to access video efficiently for (n_buffers = 0; n_buffers < reqbuf.count; n_buffers++) { mapBuffer(reqbuf, n_buffers, buf, bufs, fd); } // Queue the request struct to v4l2 to retrieve the video data mem location for(i = 0; i < reqbuf.count; i++) queueBuffer(i, buf, fd); streamOn = turnOnCamera(fd, streamOn, imgCaptureType); // turn on camera while(true) //forever { if(!started) // if the write data thread has not yet been started { started = TRUE; createThread(cNode, mutex); } for(i = 0; i < reqbuf.count; i++) // for each frame returned { usleep(fps); // maintain steady frame rate pthread_mutex_lock(mutex); // lock pointers createImage(buf, bufs, i, cNode, fd, det, cqual); cNode = cNode->next; // work with the next node in the list printf("|%d|\n", ctr++); pthread_mutex_unlock(mutex); // release locks queueBuffer(i, buf, fd); // queue up a new buffer } } for (i = 0; i < reqbuf.count; ++i) // unmap memory { munmap(bufs[i].start, bufs[i].length); } free(mutex); free(cNode); free(bufs); }
void TunnelRenderer::onMessageReceived(const sp<AMessage> &msg) { switch (msg->what()) { case kWhatQueueBuffer: { sp<ABuffer> buffer; CHECK(msg->findBuffer("buffer", &buffer)); queueBuffer(buffer); if (mStreamSource == NULL) { if (mTotalBytesQueued > 0ll) { initPlayer(); } else { ALOGI("Have %lld bytes queued...", mTotalBytesQueued); } } else { mStreamSource->doSomeWork(); } break; } default: TRESPASS(); } }
void KRAudioSource::advanceBuffer() { if(m_audioBuffers.size()) { delete m_audioBuffers.front(); m_audioBuffers.pop(); } queueBuffer(); }
bool Writeback::writeSync(int opFd, uint32_t opOffset) { if(!queueBuffer(opFd, opOffset)) { return false; } if(!Overlay::displayCommit(mFd.getFD())) { return false; } if(!dequeueBuffer()) { return false; } return true; }
void KRAudioSource::prime() { if(!m_isPrimed) { if(m_audioFile == NULL && m_audio_sample_name.size() != 0) { m_audioFile = getContext().getAudioManager()->get(m_audio_sample_name); } if(m_audioFile) { // Prime the buffer queue m_nextBufferIndex = 0; for(int i=0; i < KRENGINE_AUDIO_BUFFERS_PER_SOURCE; i++) { queueBuffer(); } m_isPrimed = true; } } }
void FrameBufferAndroid::blit(void *source, const Rect *sourceRect, const Rect *destRect, Format sourceFormat, size_t sourceStride) { copy(source, sourceFormat, sourceStride); if(buffer) { queueBuffer(nativeWindow, buffer, -1); if(locked) { locked = nullptr; unlock(); } buffer->common.decRef(&buffer->common); } }
status_t BnStreamListener::onTransact( uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) { switch (code) { case QUEUE_BUFFER: { CHECK_INTERFACE(IStreamListener, data, reply); size_t index = static_cast<size_t>(data.readInt32()); size_t size = static_cast<size_t>(data.readInt32()); queueBuffer(index, size); break; } case ISSUE_COMMAND: { CHECK_INTERFACE(IStreamListener, data, reply); Command cmd = static_cast<Command>(data.readInt32()); bool synchronous = static_cast<bool>(data.readInt32()); sp<AMessage> msg; if (data.readInt32()) { msg = AMessage::FromParcel(data); } issueCommand(cmd, synchronous, msg); break; } default: return BBinder::onTransact(code, data, reply, flags); } return OK; }
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); }
int FramebufferNativeWindow::queueBuffer_DEPRECATED(ANativeWindow* window, ANativeWindowBuffer* buffer) { return queueBuffer(window, buffer, -1); }
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); }
void AppendableSnd::queueBuffer(byte *data, uint32 size) { Common::MemoryReadStream *buffer = new Common::MemoryReadStream(data, size); queueBuffer(buffer); }
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); }