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));
}