int StreamAdapter::enqueue_buffer(const camera2_stream_ops_t* w, int64_t timestamp, buffer_handle_t* buffer) { int state = static_cast<const StreamAdapter*>(w)->mState; if (state != ACTIVE) { ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state); return INVALID_OPERATION; } ANativeWindow *a = toANW(w); status_t err; err = native_window_set_buffers_timestamp(a, timestamp); if (err != OK) return err; return a->queueBuffer(a, container_of(buffer, ANativeWindowBuffer, handle), -1); }
EGLBoolean egl_window_surface_t::swapBuffers() { DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE); rcEnc->rcFlushWindowColorBuffer(rcEnc, rcSurface); nativeWindow->queueBuffer(nativeWindow, buffer); if (nativeWindow->dequeueBuffer(nativeWindow, &buffer)) { buffer = NULL; setErrorReturn(EGL_BAD_ALLOC, EGL_FALSE); } nativeWindow->lockBuffer(nativeWindow, buffer); rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface, ((cb_handle_t *)(buffer->handle))->hostHandle); return EGL_TRUE; }
int IOMXHWBuffer_Queue( void *window, void *p_handle ) { ANativeWindow *anw = (ANativeWindow *)window; ANativeWindowBuffer_t *anb = (ANativeWindowBuffer_t *)p_handle; status_t err = NO_ERROR; CHECK_ANW(); CHECK_ANB(); #if ANDROID_API >= 18 err = anw->queueBuffer_DEPRECATED( anw, anb ); #else err = anw->queueBuffer( anw, anb ); #endif CHECK_ERR(); return 0; }
bool GonkDisplayICS::QueueBuffer(ANativeWindowBuffer *buf) { ANativeWindow *window = static_cast<ANativeWindow *>(mFBSurface.get()); return !window->queueBuffer(window, buf); }
status_t s3d_camera_test(void) { printf("[Unit Test] SurfaceFlinger 3D display test !\n\n"); sp<SurfaceComposerClient> client; //sp<SurfaceControl> u; //sp<SurfaceControl> c; sp<Surface> s; Surface::SurfaceInfo i; SkBitmap sbs; SkBitmap cam; // ready the png image file if (false == SkImageDecoder::DecodeFile("/data/3D_Camera_SBS.png", &sbs) || false == SkImageDecoder::DecodeFile("/data/camera.png", &cam)) { printf("fail load file"); return INVALID_OPERATION; } // create layer env client = new SurfaceComposerClient(); printf("screen (w, h) = (%d, %d)\n\n", (int)client->getDisplayWidth(0), (int)client->getDisplayHeight(0)); // test set to side by side mode, and pull to topest layer in transaction printf("*** camera test ...\n"); u = client->createSurface(String8("test-ui"), 0, DRAW_FHD_W, DRAW_FHD_H, PIXEL_FORMAT_BGRA_8888); c = client->createSurface(String8("test-camera"), 0, DRAW_FHD_W, DRAW_FHD_H, PIXEL_FORMAT_RGBX_8888); client->openGlobalTransaction(); { u->setLayer(210000); c->setLayer(200000); } client->closeGlobalTransaction(); ANativeWindow *w; // fill camera surface ANativeWindowBuffer *buf; void *ptr; const Rect rect0(544, 960); const Rect rect1(960, 540); s = u->getSurface(); // fill ui surface s->lock(&i); { printf("lock ui, i.s=%d, i.h=%d\n",i.s, i.h); memset(i.bits, 0, i.s * i.h * 4); memcpy(i.bits, cam.getPixels(), 544 * 960 * 4);//buffer stride is bigger then ... } s->unlockAndPost(); s = c->getSurface(); w = s.get(); native_window_api_connect(w, NATIVE_WINDOW_API_CAMERA); native_window_set_buffers_dimensions(w, 960, 540); native_window_set_buffers_format(w, HAL_PIXEL_FORMAT_RGBX_8888); native_window_set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_S3D_TOP_AND_BOTTOM); native_window_set_scaling_mode(w, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); native_window_set_buffers_transform(w, HAL_TRANSFORM_ROT_90); w->dequeueBuffer(w, &buf); GraphicBufferMapper::getInstance().lock(buf->handle, GRALLOC_USAGE_SW_WRITE_OFTEN, rect1, &ptr); { memcpy(ptr, sbs.getPixels(), 960 * 540 * 4); } GraphicBufferMapper::getInstance().unlock(buf->handle); // inlock to return buffer w->queueBuffer(w, buf); // queue to display uint8_t j = 0x80; client->openGlobalTransaction(); { u->setAlpha(j); } client->closeGlobalTransaction(); sleep(1); client->dispose(); return NO_ERROR; }
void FakeSurfaceComposer::captureScreenImp(const sp<IGraphicBufferProducer>& producer, uint32_t reqWidth, uint32_t reqHeight, const sp<GraphicProducerWrapper>& wrapper) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(wrapper.get()); RefPtr<nsScreenGonk> screen = nsScreenManagerGonk::GetPrimaryScreen(); // get screen geometry nsIntRect screenBounds = screen->GetNaturalBounds().ToUnknownRect(); const uint32_t hw_w = screenBounds.width; const uint32_t hw_h = screenBounds.height; if (reqWidth > hw_w || reqHeight > hw_h) { ALOGE("size mismatch (%d, %d) > (%d, %d)", reqWidth, reqHeight, hw_w, hw_h); static_cast<GraphicProducerWrapper*>(producer->asBinder().get())->exit(BAD_VALUE); return; } reqWidth = (!reqWidth) ? hw_w : reqWidth; reqHeight = (!reqHeight) ? hw_h : reqHeight; nsScreenGonk* screenPtr = screen.forget().take(); nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableFunction([screenPtr, reqWidth, reqHeight, producer, wrapper]() { // create a surface (because we're a producer, and we need to // dequeue/queue a buffer) sp<Surface> sur = new Surface(producer); ANativeWindow* window = sur.get(); if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) != NO_ERROR) { static_cast<GraphicProducerWrapper*>(producer->asBinder().get())->exit(BAD_VALUE); NS_ReleaseOnMainThread(screenPtr); return; } uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE; int err = 0; err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight); err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888); err |= native_window_set_usage(window, usage); status_t result = NO_ERROR; if (err == NO_ERROR) { ANativeWindowBuffer* buffer; result = native_window_dequeue_buffer_and_wait(window, &buffer); if (result == NO_ERROR) { nsresult rv = screenPtr->MakeSnapshot(buffer); if (rv != NS_OK) { result = INVALID_OPERATION; } window->queueBuffer(window, buffer, -1); } } else { result = BAD_VALUE; } native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL); static_cast<GraphicProducerWrapper*>(producer->asBinder().get())->exit(result); NS_ReleaseOnMainThread(screenPtr); }); mozilla::layers::CompositorParent::CompositorLoop()->PostTask( FROM_HERE, new RunnableCallTask(runnable)); }