blob: 4b074e7b06cff4ca97d8cfdd769f54d60316a54a [file] [log] [blame]
Alex Vakulenkoe4eec202017-01-27 14:41:04 -08001#define LOG_TAG "libgvr_shim"
2
3#include <EGL/egl.h>
4#include <EGL/eglext.h>
5#include <GLES2/gl2.h>
6#include <GLES2/gl2ext.h>
7#include <GLES3/gl31.h>
8#include <GLES3/gl3ext.h>
9#include <algorithm>
10#include <cmath>
11
12#ifdef __ARM_NEON
13#include <arm_neon.h>
14#else
15#ifndef __FLOAT32X4T_86
16#define __FLOAT32X4T_86
17typedef float float32x4_t __attribute__ ((__vector_size__ (16)));
18typedef struct float32x4x4_t { float32x4_t val[4]; };
19#endif
20#endif
21
22#include <cutils/log.h>
23#include <dvr/graphics.h>
24#include <dvr/performance_client_api.h>
25#include <dvr/pose_client.h>
26#include <private/dvr/buffer_hub_queue_core.h>
27#include <private/dvr/buffer_hub_queue_producer.h>
28#include <private/dvr/clock_ns.h>
29#include <private/dvr/display_client.h>
30#include <private/dvr/graphics_private.h>
31#include <private/dvr/internal_types.h>
32#include <private/dvr/numeric.h>
33#include <private/dvr/types.h>
34#include <private/dvr/video_mesh_surface_client.h>
35#include <sys/system_properties.h>
36#include <vr/gvr/capi/include/gvr.h>
37#include <vr/gvr/capi/include/gvr_ext.h>
38#include <vr/gvr/capi/include/gvr_util.h>
39#include <vr/gvr/capi/src/gvr_experimental.h>
40#include <vr/gvr/capi/src/gvr_private.h>
41
42#include <android_runtime/android_view_Surface.h>
43#include <gui/Surface.h>
44
45using android::dvr::DisplayClient;
46using android::dvr::EigenToGvrMatrix;
47using android::dvr::FieldOfView;
48using android::dvr::FovRadiansToDegrees;
49using android::dvr::GetSystemClockNs;
50using android::dvr::GvrIdentityMatrix;
51using android::dvr::GvrMatrixToPosef;
52using android::dvr::GvrToDvrFov;
53using android::dvr::GvrToEigenMatrix;
54using android::dvr::GvrToEigenRotation;
55using android::dvr::GvrTranslationMatrix;
56using android::dvr::IsEqual;
57using android::dvr::PosefToGvrMatrix;
58using android::dvr::mat3;
59using android::dvr::mat4;
60using android::dvr::Posef;
61using android::dvr::quat;
62using android::dvr::vec3;
63
64namespace {
65
66constexpr static int32_t GVR_SDK_MAJOR_VERSION = 2;
67constexpr static int32_t GVR_SDK_MINOR_VERSION = 0;
68constexpr static int32_t GVR_SDK_PATCH_VERSION = 0;
69
70// The "DaydreamOS" part has been appended to make easier to see when VrCore
71// dynamic GVR API loading is effectively working.
72static const char* kVersionString = "2.0.0 DaydreamOS";
73static const char* kViewerVendor = "Google";
74static const char* kViewerModel = "Lucid";
75
76// Experimental system property used to provide 6DoF information on 3DoF APIs.
77static const char* kForce6DofProp = "experimental.force_6dof";
78
79static constexpr int kControllerCount = 2;
80
81gvr_frame* GetFrameFromSwapChain(gvr_swap_chain* swap_chain) {
82 return reinterpret_cast<gvr_frame*>(swap_chain);
83}
84
85gvr_swap_chain* GetSwapChainForFrame(gvr_frame* frame) {
86 return reinterpret_cast<gvr_swap_chain*>(frame);
87}
88
89const gvr_swap_chain* GetSwapChainForFrame(const gvr_frame* frame) {
90 return reinterpret_cast<const gvr_swap_chain*>(frame);
91}
92
93// Returns the world to head transform as a Posef.
94Posef ToPosef(const DvrPoseAsync& pose) {
95 return Posef(
96 quat(pose.orientation[3], pose.orientation[0], pose.orientation[1],
97 pose.orientation[2]),
98 vec3(pose.translation[0], pose.translation[1], pose.translation[2]));
99}
100
101// Returns the world to head transform, with 0 position, as a gvr matrix
102gvr_mat4f Gvr6dofTo3dof(const gvr_mat4f& pose) {
103 gvr_mat4f ret = pose;
104 ret.m[0][3] = 0;
105 ret.m[1][3] = 0;
106 ret.m[2][3] = 0;
107 return ret;
108}
109
110void GvrToDvrPose(gvr_mat4f world_to_head_transform,
111 /*out*/ float32x4_t* orientation,
112 /*out */ float32x4_t* translation) {
113 Posef pose = GvrMatrixToPosef(world_to_head_transform);
114 (*orientation)[0] = pose.GetRotation().x();
115 (*orientation)[1] = pose.GetRotation().y();
116 (*orientation)[2] = pose.GetRotation().z();
117 (*orientation)[3] = pose.GetRotation().w();
118 (*translation)[0] = pose.GetPosition().x();
119 (*translation)[1] = pose.GetPosition().y();
120 (*translation)[2] = pose.GetPosition().z();
121 (*translation)[3] = 0;
122}
123
124bool MatricesAlmostEqual(const gvr_mat4f& m1, const gvr_mat4f& m2,
125 float tolerance) {
126 for (int row = 0; row < 4; ++row) {
127 for (int col = 0; col < 4; ++col) {
128 if (!IsEqual(m1.m[row][col], m2.m[row][col], tolerance))
129 return false;
130 }
131 }
132 return true;
133}
134
135gvr_mat4f FovToViewportTransform(const gvr_rectf& fov) {
136 // Depth range (1 1000) is chosen to match gvr impl in google3, which is
137 // chosen to match Unity integration.
138 return EigenToGvrMatrix(
139 GvrToDvrFov(fov).GetProjectionMatrix(1.f, 1000.f).inverse());
140}
141
142gvr_rectf ViewportTransformToFov(const gvr_mat4f& transform) {
143 return DvrToGvrFov(
144 FieldOfView::FromProjectionMatrix(GvrToEigenMatrix(transform).inverse()));
145}
146
147bool GetGlColorFormat(int32_t gvr_color_format,
148 /*out*/ GLenum* gl_color_format) {
149 switch (gvr_color_format) {
150 case GVR_COLOR_FORMAT_RGBA_8888:
151 *gl_color_format = GL_RGBA8;
152 break;
153 case GVR_COLOR_FORMAT_RGB_565:
154 *gl_color_format = GL_RGB565;
155 break;
156 default:
157 return false;
158 }
159 return true;
160}
161
162bool GetGlDepthFormat(int32_t gvr_depth_format,
163 /*out*/ GLenum* gl_depth_format) {
164 switch (gvr_depth_format) {
165 case GVR_DEPTH_STENCIL_FORMAT_DEPTH_16:
166 *gl_depth_format = GL_DEPTH_COMPONENT16;
167 break;
168 case GVR_DEPTH_STENCIL_FORMAT_DEPTH_24:
169 *gl_depth_format = GL_DEPTH_COMPONENT24;
170 break;
171 case GVR_DEPTH_STENCIL_FORMAT_DEPTH_24_STENCIL_8:
172 *gl_depth_format = GL_DEPTH24_STENCIL8;
173 break;
174 case GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F:
175 *gl_depth_format = GL_DEPTH_COMPONENT32F;
176 break;
177 case GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F_STENCIL_8:
178 *gl_depth_format = GL_DEPTH32F_STENCIL8;
179 break;
180 default:
181 return false;
182 }
183 return true;
184}
185
186// Returns true on success, false on failure. If the swap_chain already has a
187// DvrGraphicsContext and gvr buffer, they'll be freed first. If creation fails,
188// the DvrGraphicsContext in the swap_chain will be set to null and the
189// corresponding gvr buffer will be freed.
190bool CreateDvrGraphicsContextAndGvrBuffer(gvr_swap_chain* swap_chain) {
191 if (swap_chain->buffers_.empty()) {
192 ALOGE("Can't create a graphics context for an empty swap chain");
193 return false;
194 }
195
196 // We currently only render the first gvr buffer. Create a DvrGraphicsContext
197 // for the first buffer only.
198 gvr_buffer& buf = swap_chain->buffers_[0];
199 buf.FreeGl();
200
201 bool visible;
202 int z_order;
203 if (swap_chain->graphics_context_ != nullptr) {
204 visible = dvrGraphicsSurfaceGetVisible(swap_chain->graphics_context_);
205 z_order = dvrGraphicsSurfaceGetZOrder(swap_chain->graphics_context_);
206 dvrGraphicsContextDestroy(swap_chain->graphics_context_);
207 swap_chain->graphics_context_ = nullptr;
208 } else {
209 visible = buf.spec.initially_visible;
210 z_order = buf.spec.z_order;
211 }
212
213 int width = 0, height = 0;
214 GLuint texture_id = 0;
215 GLenum texture_target = 0;
216 DvrSurfaceParameter surface_params[] = {
217 DVR_SURFACE_PARAMETER_IN(DISABLE_DISTORTION, false),
218 DVR_SURFACE_PARAMETER_IN(CREATE_GL_CONTEXT, 0),
219 DVR_SURFACE_PARAMETER_IN(WIDTH, buf.spec.size.width),
220 DVR_SURFACE_PARAMETER_IN(HEIGHT, buf.spec.size.height),
221 DVR_SURFACE_PARAMETER_IN(BLUR_BEHIND, buf.spec.blur_behind),
222 DVR_SURFACE_PARAMETER_IN(VISIBLE, visible),
223 DVR_SURFACE_PARAMETER_IN(Z_ORDER, z_order),
224 DVR_SURFACE_PARAMETER_OUT(SURFACE_WIDTH, &width),
225 DVR_SURFACE_PARAMETER_OUT(SURFACE_HEIGHT, &height),
226 DVR_SURFACE_PARAMETER_OUT(SURFACE_TEXTURE_TARGET_TYPE, &texture_target),
227 DVR_SURFACE_PARAMETER_OUT(SURFACE_TEXTURE_TARGET_ID, &texture_id),
228 DVR_SURFACE_PARAMETER_LIST_END,
229 };
230
231 DvrGraphicsContext* graphics_context;
232 int ret = dvrGraphicsContextCreate(surface_params, &graphics_context);
233 if (ret < 0) {
234 ALOGE("dvrGraphicsContextCreate failed: %d (%s)", ret, strerror(-ret));
235 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
236 return false;
237 }
238
239 // Sanity check that the size of the buffer we allocated from the system is
240 // what we expect
241 if (buf.spec.size != gvr_sizei{width, height}) {
242 ALOGE(
243 "The created surface is the wrong size."
244 " Should be %dx%d, instead got %dx%d.",
245 buf.spec.size.width, buf.spec.size.height, width, height);
246 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
247 dvrGraphicsContextDestroy(graphics_context);
248 return false;
249 }
250
251 buf = gvr_buffer(swap_chain->context, buf.spec, texture_id, texture_target);
252 if (buf.frame_buffer == 0) {
253 dvrGraphicsContextDestroy(graphics_context);
254 return false;
255 }
256
257 swap_chain->graphics_context_ = graphics_context;
258 return true;
259}
260
261bool SwapChainResizeBuffer(gvr_swap_chain* swap_chain, int buffer_index) {
262 gvr_buffer& buf = swap_chain->buffers_[buffer_index];
263 buf.FreeGl();
264 gvr_sizei orig_size = buf.spec.size;
265 buf.spec.size = buf.requested_size;
266 bool resize_successful = false;
267 if (buffer_index == 0) {
268 resize_successful = CreateDvrGraphicsContextAndGvrBuffer(swap_chain);
269 } else {
270 buf = gvr_buffer(swap_chain->context, buf.spec, 0, GL_TEXTURE_2D);
271 resize_successful = buf.frame_buffer != 0;
272 }
273
274 if (resize_successful) {
275 // The resize was successful, so clear the resize request
276 buf.requested_size = {-1, -1};
277 } else {
278 ALOGE("Failed to resize buffer. orig_size=%dx%d requested_size=%dx%d.",
279 orig_size.width, orig_size.height, buf.requested_size.width,
280 buf.requested_size.height);
281 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
282 buf.spec.size = orig_size;
283 }
284
285 return resize_successful;
286}
287
288void WaitNextFrame(gvr_swap_chain* swap_chain, int64_t start_delay_nanos,
289 gvr_frame_schedule* out_next_frame_schedule,
290 bool called_by_app) {
291 if (called_by_app)
292 swap_chain->wait_next_frame_called_by_app_ = true;
293
294 DvrFrameSchedule dvr_schedule;
295 int ret = dvrGraphicsWaitNextFrame(swap_chain->graphics_context_,
296 start_delay_nanos, &dvr_schedule);
297 if (ret < 0) {
298 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
299 return;
300 }
301 if (out_next_frame_schedule) {
302 out_next_frame_schedule->vsync_count = dvr_schedule.vsync_count;
303 out_next_frame_schedule->scheduled_finish.monotonic_system_time_nanos =
304 dvr_schedule.scheduled_frame_finish_ns;
305 }
306
307 DvrPoseAsync pose;
308 ret = dvrPoseGet(swap_chain->context->pose_client_, dvr_schedule.vsync_count,
309 &pose);
310 if (ret < 0) {
311 ALOGW("dvrPoseGet failed: %d", ret);
312 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
313 return;
314 }
315
316 swap_chain->context->next_frame_6dof_pose_ = PosefToGvrMatrix(ToPosef(pose));
317
318 for (int i = 0; i < kControllerCount; ++i) {
319 ret = dvrPoseGetController(swap_chain->context->pose_client_, i,
320 dvr_schedule.vsync_count, &pose);
321 if (ret == 0) {
322 // Silently fail when there are no controllers.
323 swap_chain->context->next_frame_controller_pose_[i] =
324 PosefToGvrMatrix(ToPosef(pose).Inverse());
325 }
326 }
327}
328
329bool VerifyBufferIndex(const std::string& function_name,
330 const gvr_swap_chain* swap_chain, int index) {
331 if (index > static_cast<int32_t>(swap_chain->buffers_.size())) {
332 ALOGE("%s out of range buffer index. index=%d num_buffers=%zu.",
333 function_name.c_str(), index, swap_chain->buffers_.size());
334 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
335 return false;
336 }
337 return true;
338}
339
340} // anonymous namespace
341
342gvr_context* gvr_create(JNIEnv* env, jobject /* app_context */,
343 jobject /* class_loader */) {
344 std::unique_ptr<gvr_context> context(new gvr_context);
345
346 // Set cpu set to avoid default scheduling randomness.
347 dvrSetCpuPartition(0, "/application/performance");
348
349 context->jni_env_ = env;
350 context->pose_client_ = dvrPoseCreate();
351 if (!context->pose_client_) {
352 ALOGE("Failed to create pose client");
353 return nullptr;
354 }
355
356 context->display_client_ = DisplayClient::Create();
357 if (!context->display_client_) {
358 ALOGE("Failed to create display client");
359 return nullptr;
360 }
361
362 int ret =
363 context->display_client_->GetDisplayMetrics(&context->display_metrics_);
364 if (ret < 0) {
365 ALOGE("Failed to get display metrics: %d (%s)", ret, strerror(-ret));
366 return nullptr;
367 }
368
369 const float* left_fov = context->display_metrics_.left_fov_lrbt.data();
370 context->left_eye_viewport_transform_ =
371 FovToViewportTransform(FovRadiansToDegrees(
372 gvr_rectf{left_fov[0], left_fov[1], left_fov[2], left_fov[3]}));
373
374 const float* right_fov = context->display_metrics_.right_fov_lrbt.data();
375 context->right_eye_viewport_transform_ =
376 FovToViewportTransform(FovRadiansToDegrees(
377 gvr_rectf{right_fov[0], right_fov[1], right_fov[2], right_fov[3]}));
378
379 context->next_frame_6dof_pose_ = GvrIdentityMatrix();
380
381 for (int i = 0; i < kControllerCount; ++i) {
382 context->next_frame_controller_pose_[i] = GvrIdentityMatrix();
383 }
384
385 // Check the system property to force 6DoF when requested 3DoF.
386 char prop_buffer[PROP_VALUE_MAX];
387 if (__system_property_get(kForce6DofProp, prop_buffer) &&
388 (!strncasecmp("1", prop_buffer, PROP_VALUE_MAX) ||
389 !strncasecmp("true", prop_buffer, PROP_VALUE_MAX))) {
390 context->force_6dof_ = true;
391 }
392
393 return context.release();
394}
395
396gvr_version gvr_get_version() {
397 gvr_version version = {};
398 version.major = GVR_SDK_MAJOR_VERSION;
399 version.minor = GVR_SDK_MINOR_VERSION;
400 version.patch = GVR_SDK_PATCH_VERSION;
401 return version;
402}
403
404const char* gvr_get_version_string() { return kVersionString; }
405
406int32_t gvr_get_error(gvr_context* gvr) { return gvr->last_error_; }
407
408int32_t gvr_clear_error(gvr_context* gvr) {
409 int32_t last_error = gvr->last_error_;
410 gvr->last_error_ = GVR_ERROR_NONE;
411 return last_error;
412}
413
414const char* gvr_get_error_string(int32_t error_code) {
415 switch (error_code) {
416 case GVR_ERROR_NONE:
417 return "No error";
418 case GVR_ERROR_CONTROLLER_CREATE_FAILED:
419 return "Creation of GVR controller context failed";
420 case GVR_ERROR_NO_FRAME_AVAILABLE:
421 return "No frame available in swap chain";
422 case GVR_ERROR_INTERNAL:
423 return "Internal error";
424 default:
425 return "(Internal error: unknown error code)";
426 }
427}
428
429const gvr_user_prefs* gvr_get_user_prefs(gvr_context* gvr) {
430 return &gvr->user_prefs_;
431}
432
433int32_t gvr_user_prefs_get_controller_handedness(
434 const gvr_user_prefs* /* user_prefs */) {
435 return GVR_CONTROLLER_RIGHT_HANDED;
436}
437
438gvr_context_::~gvr_context_() {
439 for (gvr_swap_chain* swap_chain : swap_chains_)
440 swap_chain->context = nullptr;
441 if (pose_client_)
442 dvrPoseDestroy(pose_client_);
443}
444
445void gvr_destroy(gvr_context** gvr) {
446 if (!gvr || !(*gvr)) {
447 ALOGW("gvr_destroy: Invalid gvr_context pointer.");
448 return;
449 }
450 delete *gvr;
451 *gvr = nullptr;
452}
453
454void gvr_initialize_gl(gvr_context* /* gvr */) {}
455
456bool gvr_get_async_reprojection_enabled(const gvr_context* /* gvr */) {
457 return true;
458}
459
460void gvr_get_recommended_buffer_viewports(
461 const gvr_context* gvr, gvr_buffer_viewport_list* viewport_list) {
462 gvr_buffer_viewport left(
463 /*buffer_index*/ 0,
464 /*uv*/ {0, .5f, 0, 1}, gvr->left_eye_viewport_transform_, GVR_LEFT_EYE,
465 GVR_EXTERNAL_SURFACE_ID_NONE, GVR_REPROJECTION_FULL);
466
467 gvr_buffer_viewport right(
468 /*buffer_index*/ 0,
469 /*uv*/ {.5f, 1, 0, 1}, gvr->right_eye_viewport_transform_, GVR_RIGHT_EYE,
470 GVR_EXTERNAL_SURFACE_ID_NONE, GVR_REPROJECTION_FULL);
471
472 viewport_list->viewports.resize(2);
473 viewport_list->viewports[0] = left;
474 viewport_list->viewports[1] = right;
475}
476
477void gvr_get_screen_buffer_viewports(const gvr_context* gvr,
478 gvr_buffer_viewport_list* viewport_list) {
479 gvr_get_recommended_buffer_viewports(gvr, viewport_list);
480}
481
482gvr_sizei gvr_get_maximum_effective_render_target_size(const gvr_context* gvr) {
483 return gvr_sizei{
484 static_cast<int32_t>(gvr->display_metrics_.distorted_width),
485 static_cast<int32_t>(gvr->display_metrics_.distorted_height)};
486}
487
488gvr_sizei gvr_get_screen_target_size(const gvr_context* gvr) {
489 // DisplayMetrics returns native_width and native_height for the display in
490 // portrait orientation, which our device is never in. Swap the width and
491 // height to account for this.
492 return gvr_sizei{
493 static_cast<int32_t>(gvr->display_metrics_.display_native_height),
494 static_cast<int32_t>(gvr->display_metrics_.display_native_width)};
495}
496
497void gvr_set_surface_size(gvr_context* gvr,
498 gvr_sizei /* surface_size_pixels */) {
499 // TODO(leandrogracia): this needs to be properly implemented.
500 ALOGE("gvr_set_surface_size not implemented.");
501 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
502}
503
504void gvr_distort_to_screen(
505 gvr_context* gvr, int32_t /* texture_id */,
506 const gvr_buffer_viewport_list* /* viewport_list */,
507 gvr_mat4f /* head_space_from_start_space */,
508 gvr_clock_time_point /* target_presentation_time */) {
509 // TODO(leandrogracia): this needs to be properly implemented.
510 ALOGE("gvr_distort_to_screen not implemented.");
511 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
512}
513
514/////////////////////////////////////////////////////////////////////////////
515// Viewports and viewport lists
516/////////////////////////////////////////////////////////////////////////////
517
518bool gvr_buffer_viewport::operator==(const gvr_buffer_viewport_& other) const {
519 return buffer_index == other.buffer_index && uv == other.uv &&
520 eye == other.eye && external_surface_id == other.external_surface_id &&
521 reprojection == other.reprojection &&
522 MatricesAlmostEqual(transform, other.transform, 1e-5f);
523}
524
525gvr_buffer_viewport* gvr_buffer_viewport_create(gvr_context* /* gvr */) {
526 return new gvr_buffer_viewport;
527}
528
529void gvr_buffer_viewport_destroy(gvr_buffer_viewport** viewport) {
530 if (viewport) {
531 delete *viewport;
532 *viewport = nullptr;
533 }
534}
535
536gvr_rectf gvr_buffer_viewport_get_source_uv(
537 const gvr_buffer_viewport* viewport) {
538 return viewport->uv;
539}
540
541void gvr_buffer_viewport_set_source_uv(gvr_buffer_viewport* viewport,
542 gvr_rectf uv) {
543 viewport->uv = uv;
544}
545
546gvr_rectf gvr_buffer_viewport_get_source_fov(
547 const gvr_buffer_viewport* viewport) {
548 return ViewportTransformToFov(viewport->transform);
549}
550
551void gvr_buffer_viewport_set_source_fov(gvr_buffer_viewport* viewport,
552 gvr_rectf fov) {
553 viewport->transform = FovToViewportTransform(fov);
554}
555
556gvr_mat4f gvr_buffer_viewport_get_transform(
557 const gvr_buffer_viewport* viewport) {
558 return viewport->transform;
559}
560
561void gvr_buffer_viewport_set_transform(gvr_buffer_viewport* viewport,
562 gvr_mat4f transform) {
563 viewport->transform = transform;
564}
565
566int32_t gvr_buffer_viewport_get_target_eye(
567 const gvr_buffer_viewport* viewport) {
568 return viewport->eye;
569}
570
571void gvr_buffer_viewport_set_target_eye(gvr_buffer_viewport* viewport,
572 int32_t index) {
573 viewport->eye = index;
574}
575
576int32_t gvr_buffer_viewport_get_source_buffer_index(
577 const gvr_buffer_viewport* viewport) {
578 return viewport->buffer_index;
579}
580
581void gvr_buffer_viewport_set_source_buffer_index(gvr_buffer_viewport* viewport,
582 int32_t buffer_index) {
583 viewport->buffer_index = buffer_index;
584}
585
586int32_t gvr_buffer_viewport_get_external_surface_id(
587 const gvr_buffer_viewport* viewport) {
588 return viewport->external_surface_id;
589}
590
591void gvr_buffer_viewport_set_external_surface_id(gvr_buffer_viewport* viewport,
592 int32_t external_surface_id) {
593 viewport->external_surface_id = external_surface_id;
594}
595
596int32_t gvr_buffer_viewport_get_reprojection(
597 const gvr_buffer_viewport* viewport) {
598 return viewport->reprojection;
599}
600
601void gvr_buffer_viewport_set_reprojection(gvr_buffer_viewport* viewport,
602 int32_t reprojection) {
603 viewport->reprojection = static_cast<gvr_reprojection>(reprojection);
604}
605
606bool gvr_buffer_viewport_equal(const gvr_buffer_viewport* a,
607 const gvr_buffer_viewport* b) {
608 return *a == *b;
609}
610
611gvr_buffer_viewport_list* gvr_buffer_viewport_list_create(
612 const gvr_context* /* gvr */) {
613 return new gvr_buffer_viewport_list;
614}
615
616void gvr_buffer_viewport_list_destroy(
617 gvr_buffer_viewport_list** viewport_list) {
618 if (!viewport_list || !(*viewport_list)) {
619 ALOGW("gvr_buffer_viewport_list_destroy: Invalid list pointer.");
620 return;
621 }
622 delete *viewport_list;
623 *viewport_list = nullptr;
624}
625
626size_t gvr_buffer_viewport_list_get_size(
627 const gvr_buffer_viewport_list* viewport_list) {
628 return viewport_list->viewports.size();
629}
630
631void gvr_buffer_viewport_list_get_item(
632 const gvr_buffer_viewport_list* viewport_list, size_t index,
633 gvr_buffer_viewport* viewport) {
634 *viewport = viewport_list->viewports[index];
635}
636
637void gvr_buffer_viewport_list_set_item(gvr_buffer_viewport_list* viewport_list,
638 size_t index,
639 const gvr_buffer_viewport* viewport) {
640 if (index < viewport_list->viewports.size())
641 viewport_list->viewports[index] = *viewport;
642 else
643 viewport_list->viewports.push_back(*viewport);
644}
645
646/////////////////////////////////////////////////////////////////////////////
647// Swapchains and frames
648/////////////////////////////////////////////////////////////////////////////
649
650gvr_buffer_spec* gvr_buffer_spec_create(gvr_context* /* gvr */) {
651 return new gvr_buffer_spec;
652}
653
654void gvr_buffer_spec_destroy(gvr_buffer_spec** spec) {
655 if (spec) {
656 delete *spec;
657 *spec = nullptr;
658 }
659}
660
661gvr_sizei gvr_buffer_spec_get_size(const gvr_buffer_spec* spec) {
662 return spec->size;
663}
664
665void gvr_buffer_spec_set_size(gvr_buffer_spec* spec, gvr_sizei size) {
666 spec->size = size;
667}
668
669int32_t gvr_buffer_spec_get_samples(const gvr_buffer_spec* spec) {
670 return spec->msaa_samples;
671}
672
673void gvr_buffer_spec_set_samples(gvr_buffer_spec* spec, int32_t num_samples) {
674 spec->msaa_samples = num_samples;
675}
676
677void gvr_buffer_spec_set_color_format(gvr_buffer_spec* spec,
678 int32_t color_format) {
679 spec->color_format = color_format;
680}
681
682void gvr_buffer_spec_set_depth_stencil_format(gvr_buffer_spec* spec,
683 int32_t depth_stencil_format) {
684 spec->depth_stencil_format = depth_stencil_format;
685}
686
687void gvr_buffer_spec_set_z_order(gvr_buffer_spec* spec, int z_order) {
688 spec->z_order = z_order;
689}
690
691void gvr_buffer_spec_set_visibility(gvr_buffer_spec* spec,
692 int32_t visibility) {
693 spec->initially_visible = (visibility != GVR_INVISIBLE);
694}
695
696void gvr_buffer_spec_set_blur_behind(gvr_buffer_spec* spec,
697 int32_t blur_behind) {
698 spec->blur_behind = (blur_behind != GVR_BLUR_BEHIND_FALSE);
699}
700
701void gvr_buffer::SetDefaults() {
702 spec = gvr_buffer_spec();
703 frame_buffer = 0;
704 color_render_buffer = 0;
705 depth_stencil_render_buffer = 0;
706 requested_size = {-1, -1};
707}
708
709gvr_buffer::gvr_buffer() { SetDefaults(); }
710
711gvr_buffer::gvr_buffer(gvr_context* gvr, const gvr_buffer_spec& spec_in,
712 GLuint texture_id, GLenum texture_target) {
713 SetDefaults();
714 spec = spec_in;
715
716 glGetError(); // Clear error state
717 glGenFramebuffers(1, &frame_buffer);
718 glBindFramebuffer(GL_FRAMEBUFFER, frame_buffer);
719
720 if (texture_id == 0) {
721 GLenum gl_color_format;
722 if (!GetGlColorFormat(spec.color_format, &gl_color_format)) {
723 ALOGE("Unknown color format: %d", spec.color_format);
724 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
725 FreeGl();
726 return;
727 }
728
729 glGenRenderbuffers(1, &color_render_buffer);
730 glBindRenderbuffer(GL_RENDERBUFFER, color_render_buffer);
731 if (spec.msaa_samples < 2) {
732 glRenderbufferStorage(GL_RENDERBUFFER, gl_color_format, spec.size.width,
733 spec.size.height);
734 } else {
735 glRenderbufferStorageMultisample(GL_RENDERBUFFER, spec.msaa_samples,
736 gl_color_format, spec.size.width,
737 spec.size.height);
738 }
739 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
740 GL_RENDERBUFFER, color_render_buffer);
741 } else {
742 if (spec.msaa_samples < 2) {
743 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
744 texture_target, texture_id, 0);
745 } else {
746 glFramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
747 texture_target, texture_id, 0,
748 spec.msaa_samples);
749 }
750 }
751
752 if (spec.depth_stencil_format != GVR_DEPTH_STENCIL_FORMAT_NONE) {
753 GLenum gl_depth_format;
754 if (!GetGlDepthFormat(spec.depth_stencil_format, &gl_depth_format)) {
755 ALOGE("Unknown depth/stencil format: %d", spec.depth_stencil_format);
756 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
757 FreeGl();
758 return;
759 }
760
761 glGenRenderbuffers(1, &depth_stencil_render_buffer);
762 glBindRenderbuffer(GL_RENDERBUFFER, depth_stencil_render_buffer);
763 if (spec.msaa_samples < 2) {
764 glRenderbufferStorage(GL_RENDERBUFFER, gl_depth_format, spec.size.width,
765 spec.size.height);
766 } else {
767 glRenderbufferStorageMultisample(GL_RENDERBUFFER, spec.msaa_samples,
768 gl_depth_format, spec.size.width,
769 spec.size.height);
770 }
771 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
772 GL_RENDERBUFFER, depth_stencil_render_buffer);
773 }
774
775 GLenum gl_error = glGetError();
776 if (gl_error != GL_NO_ERROR) {
777 ALOGE("GL error after creating framebuffer: %d", gl_error);
778 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
779 FreeGl();
780 return;
781 }
782
783 GLenum framebuffer_complete_result = glCheckFramebufferStatus(GL_FRAMEBUFFER);
784 if (framebuffer_complete_result != GL_FRAMEBUFFER_COMPLETE) {
785 ALOGE("Framebuffer setup failed. glCheckFramebufferStatus returned %d",
786 framebuffer_complete_result);
787 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
788 FreeGl();
789 return;
790 }
791}
792
793void gvr_buffer::FreeGl() {
794 if (frame_buffer != 0) {
795 glDeleteFramebuffers(1, &frame_buffer);
796 frame_buffer = 0;
797 }
798 if (color_render_buffer != 0) {
799 glDeleteRenderbuffers(1, &color_render_buffer);
800 color_render_buffer = 0;
801 }
802 if (depth_stencil_render_buffer != 0) {
803 glDeleteRenderbuffers(1, &depth_stencil_render_buffer);
804 depth_stencil_render_buffer = 0;
805 }
806}
807
808gvr_buffer::~gvr_buffer() { FreeGl(); }
809
810gvr_buffer::gvr_buffer(gvr_buffer&& other) {
811 spec = other.spec;
812 frame_buffer = other.frame_buffer;
813 color_render_buffer = other.color_render_buffer;
814 depth_stencil_render_buffer = other.depth_stencil_render_buffer;
815 requested_size = other.requested_size;
816 other.SetDefaults();
817}
818
819gvr_buffer& gvr_buffer::operator=(gvr_buffer&& other) {
820 if (this == &other)
821 return *this;
822 spec = other.spec;
823 frame_buffer = other.frame_buffer;
824 color_render_buffer = other.color_render_buffer;
825 depth_stencil_render_buffer = other.depth_stencil_render_buffer;
826 requested_size = other.requested_size;
827 other.SetDefaults();
828 return *this;
829}
830
831gvr_swap_chain* gvr_swap_chain_create(gvr_context* gvr,
832 const gvr_buffer_spec** buffers,
833 int32_t count) {
834 if (count == 0) {
835 ALOGE("At least one buffer must be requested");
836 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
837 return nullptr;
838 }
839
840 // We only support one buffer, but it's common for gvr apps to use more than
841 // one. Print an error to the log if the app requests more than one buffer,
842 // but continue on. We'll only render the first buffer in that case.
843 if (count > 1) {
844 ALOGE(
845 "Only one buffer is supported but the app requested %d."
846 " Only the first buffer will be rendered.",
847 count);
848 }
849
850 std::unique_ptr<gvr_swap_chain> swap_chain(new gvr_swap_chain(gvr));
851
852 // The first buffer gets a DvrGraphicsContext, which contains the surface we
853 // pass to displayd for rendering.
854 swap_chain->buffers_.push_back(gvr_buffer());
855 swap_chain->buffers_.back().spec = *buffers[0];
856 if (!CreateDvrGraphicsContextAndGvrBuffer(swap_chain.get()))
857 return nullptr;
858
859 // The rest of the buffers, which we don't render for now, get color render
860 // buffers.
861 for (int i = 1; i < count; ++i) {
862 swap_chain->buffers_.push_back(
863 gvr_buffer(gvr, *buffers[i], 0, GL_TEXTURE_2D));
864 if (swap_chain->buffers_.back().frame_buffer == 0)
865 return nullptr;
866 }
867
868 gvr->swap_chains_.push_back(swap_chain.get());
869 return swap_chain.release();
870}
871
872gvr_swap_chain_::~gvr_swap_chain_() {
873 if (context) {
874 auto iter = std::find(std::begin(context->swap_chains_),
875 std::end(context->swap_chains_), this);
876 if (iter != context->swap_chains_.end())
877 context->swap_chains_.erase(iter);
878 }
879 buffers_.clear();
880 if (graphics_context_ != nullptr)
881 dvrGraphicsContextDestroy(graphics_context_);
882}
883
884void gvr_swap_chain_destroy(gvr_swap_chain** swap_chain) {
885 if (!swap_chain || !(*swap_chain)) {
886 ALOGW("gvr_swap_chain_destroy: Invalid swap chain pointer.");
887 return;
888 }
889 delete *swap_chain;
890 *swap_chain = nullptr;
891}
892
893int32_t gvr_swap_chain_get_buffer_count(const gvr_swap_chain* swap_chain) {
894 return swap_chain ? static_cast<int32_t>(swap_chain->buffers_.size()) : 0;
895}
896
897gvr_sizei gvr_swap_chain_get_buffer_size(gvr_swap_chain* swap_chain,
898 int32_t index) {
899 if (!VerifyBufferIndex("gvr_swap_chain_get_buffer_size", swap_chain, index))
900 return gvr_sizei{0, 0};
901
902 gvr_buffer& buf = swap_chain->buffers_[index];
903 if (buf.requested_size != gvr_sizei{-1, -1})
904 return buf.requested_size;
905 else
906 return buf.spec.size;
907}
908
909void gvr_swap_chain_resize_buffer(gvr_swap_chain* swap_chain, int32_t index,
910 gvr_sizei size) {
911 if (!VerifyBufferIndex("gvr_swap_chain_resize_buffer", swap_chain, index))
912 return;
913
914 gvr_buffer& buf = swap_chain->buffers_[index];
915 if (size != buf.spec.size)
916 buf.requested_size = size;
917 else
918 buf.requested_size = {-1, -1};
919}
920
921gvr_frame* gvr_swap_chain_acquire_frame(gvr_swap_chain* swap_chain) {
922 if (!swap_chain)
923 return nullptr;
924
925 if (swap_chain->frame_acquired_) {
926 gvr_set_error(swap_chain->context, GVR_ERROR_NO_FRAME_AVAILABLE);
927 return nullptr;
928 }
929
930 // Resize buffers if necessary
931 for (int i = 0; i < static_cast<int>(swap_chain->buffers_.size()); ++i) {
932 gvr_buffer& buf = swap_chain->buffers_[i];
933 if (buf.requested_size != gvr_sizei{-1, -1}) {
934 if (!SwapChainResizeBuffer(swap_chain, i))
935 return nullptr;
936 }
937 }
938
939 // Only call gvr_wait_next_frame() if the app didn't call it already.
940 if (!swap_chain->wait_next_frame_called_by_app_)
941 WaitNextFrame(swap_chain, 0, nullptr, /*called_by_app*/ false);
942
943 int ret = dvrBeginRenderFrame(swap_chain->graphics_context_);
944 if (ret < 0) {
945 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
946 return nullptr;
947 }
948
949 swap_chain->frame_acquired_ = true;
950 return GetFrameFromSwapChain(swap_chain);
951}
952
953void gvr_frame_bind_buffer(gvr_frame* frame, int32_t index) {
954 gvr_swap_chain* swap_chain = GetSwapChainForFrame(frame);
955 if (!VerifyBufferIndex("gvr_frame_bind_buffer", swap_chain, index))
956 return;
957 glBindFramebuffer(GL_FRAMEBUFFER, swap_chain->buffers_[index].frame_buffer);
958}
959
960void gvr_frame_unbind(gvr_frame* /* frame */) {
961 glBindFramebuffer(GL_FRAMEBUFFER, 0);
962}
963
964gvr_sizei gvr_frame_get_buffer_size(const gvr_frame* frame, int32_t index) {
965 const gvr_swap_chain* swap_chain = GetSwapChainForFrame(frame);
966 if (!VerifyBufferIndex("gvr_frame_get_buffer_size", swap_chain, index))
967 return gvr_sizei{0, 0};
968 return swap_chain->buffers_[index].spec.size;
969}
970
971int32_t gvr_frame_get_framebuffer_object(const gvr_frame* frame,
972 int32_t index) {
973 const gvr_swap_chain* swap_chain = GetSwapChainForFrame(frame);
974 if (!VerifyBufferIndex("gvr_frame_get_framebuffer_object", swap_chain, index))
975 return 0;
976 return swap_chain->buffers_[index].frame_buffer;
977}
978
979void gvr_frame_submit(gvr_frame** frame, const gvr_buffer_viewport_list* list,
980 gvr_mat4f head_space_from_start_space) {
981 if (!frame)
982 return;
983
984 gvr_swap_chain* swap_chain = GetSwapChainForFrame(*frame);
985
986 if (!swap_chain->frame_acquired_) {
987 ALOGE("Frame was never acquired before being submitted");
988 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
989 return;
990 }
991
992 *frame = nullptr;
993 swap_chain->frame_acquired_ = false;
994
995 // Currently, support for arbitrary buffer viewport configs is very limited.
996 // We assume that the first two viewports have to be the recommended color
997 // buffer viewports, followed by pairs of external external buffer viewports
998 // for video rendering.
999 gvr_buffer_viewport_list supported_viewports;
1000 gvr_get_recommended_buffer_viewports(swap_chain->context,
1001 &supported_viewports);
1002 for (size_t i = 0; i < supported_viewports.viewports.size(); ++i) {
1003 if (i >= list->viewports.size() ||
1004 supported_viewports.viewports[i] != list->viewports[i]) {
1005 ALOGE("Custom viewport configurations are not fully supported.");
1006 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
1007 return;
1008 }
1009 }
1010
1011 for (size_t i = supported_viewports.viewports.size();
1012 i < list->viewports.size(); ++i) {
1013 int32_t external_surface_id = list->viewports[i].external_surface_id;
1014 // Ignore additional custom buffer viewport for now, only those buffer
1015 // viewports backed by external surfaces are supported.
1016 // TODO(b/31442094, b/31771861, 28954457) Add full GVR buffer viewport
1017 // support.
1018 if (external_surface_id == GVR_EXTERNAL_SURFACE_ID_NONE)
1019 continue;
1020
1021 auto surface_it = swap_chain->external_surfaces_.find(external_surface_id);
1022 if (surface_it == swap_chain->external_surfaces_.end()) {
1023 ALOGE("Cannot find external_surface by id: %d.", external_surface_id);
1024 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
1025 return;
1026 }
1027
1028 // Pass the transfrom matrix of video mesh to displayd.
1029 dvrGraphicsVideoMeshSurfacePresent(
1030 swap_chain->graphics_context_, surface_it->second->video_surface,
1031 list->viewports[i].eye,
1032 GvrToEigenMatrix(list->viewports[i].transform).data());
1033 }
1034
1035 float32x4_t pose_orientation, pose_translation;
1036 GvrToDvrPose(head_space_from_start_space, &pose_orientation,
1037 &pose_translation);
1038 int ret = dvrSetEdsPose(swap_chain->graphics_context_, pose_orientation,
1039 pose_translation);
1040 if (ret < 0)
1041 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
1042
1043 ret = dvrPresent(swap_chain->graphics_context_);
1044 if (ret < 0) {
1045 gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
1046 return;
1047 }
1048}
1049
1050void gvr_bind_default_framebuffer(gvr_context* /* gvr */) {
1051 glBindFramebuffer(GL_FRAMEBUFFER, 0);
1052}
1053
1054/////////////////////////////////////////////////////////////////////////////
1055// Head tracking
1056/////////////////////////////////////////////////////////////////////////////
1057
1058gvr_clock_time_point gvr_get_time_point_now() {
1059 return gvr_clock_time_point{GetSystemClockNs()};
1060}
1061
1062gvr_mat4f gvr_get_head_space_from_start_space_rotation(
1063 const gvr_context* gvr, const gvr_clock_time_point /* time */) {
1064 // TODO(steventhomas): Implement prediction according to the supplied time
1065 // value.
1066 return gvr->force_6dof_ ? gvr->next_frame_6dof_pose_
1067 : Gvr6dofTo3dof(gvr->next_frame_6dof_pose_);
1068}
1069
1070gvr_mat4f gvr_apply_neck_model(const gvr_context* /* gvr */,
1071 gvr_mat4f head_space_from_start_space_rotation,
1072 float /* factor */) {
1073 // TODO(leandrogracia): this needs to be properly implemented.
1074 ALOGE("gvr_apply_neck_model not implemented.");
1075 return head_space_from_start_space_rotation;
1076}
1077
1078// This is used to turn off sensors to save power. Not relevant for our all in
1079// one device.
1080void gvr_pause_tracking(gvr_context* /* gvr */) {}
1081
1082// This is used to turn on sensors. Not relevant for our all in one device.
1083void gvr_resume_tracking(gvr_context* /* gvr */) {}
1084
1085void gvr_reset_tracking(gvr_context* gvr) {
1086 // TODO(leandrogracia): this needs to be properly implemented.
1087 ALOGE("gvr_reset_tracking not implemented.");
1088 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
1089}
1090
1091void gvr_recenter_tracking(gvr_context* gvr) {
1092 // TODO(leandrogracia): this needs to be properly implemented.
1093 ALOGE("gvr_recenter_tracking not implemented.");
1094 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
1095}
1096
1097/////////////////////////////////////////////////////////////////////////////
1098// Head mounted display
1099/////////////////////////////////////////////////////////////////////////////
1100
1101bool gvr_set_default_viewer_profile(gvr_context* gvr,
1102 const char* /* viewer_profile_uri */) {
1103 // TODO(leandrogracia): this needs to be properly implemented.
1104 ALOGE("gvr_set_default_viewer_profile not implemented.");
1105 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
1106 return false;
1107}
1108
1109void gvr_refresh_viewer_profile(gvr_context* /* gvr */) {}
1110
1111const char* gvr_get_viewer_vendor(const gvr_context* /* gvr */) {
1112 return kViewerVendor;
1113}
1114
1115const char* gvr_get_viewer_model(const gvr_context* /* gvr */) {
1116 return kViewerModel;
1117}
1118
1119int32_t gvr_get_viewer_type(const gvr_context* /* gvr */) {
1120 // TODO(leandrogracia): this needs to be properly implemented.
1121 // In this case, we will probably need to define a new viewer type that
1122 // has 6DoF support.
1123 return GVR_VIEWER_TYPE_DAYDREAM;
1124}
1125
1126gvr_mat4f gvr_get_eye_from_head_matrix(const gvr_context* gvr,
1127 const int32_t eye) {
1128 float eye_mult = eye == GVR_LEFT_EYE ? 1 : -1;
1129 return GvrTranslationMatrix(
1130 .5f * eye_mult * gvr->display_metrics_.inter_lens_distance_m, 0, 0);
1131}
1132
1133gvr_recti gvr_get_window_bounds(const gvr_context* gvr) {
1134 // Our app windows are always full screen
1135 gvr_sizei screen_size = gvr_get_screen_target_size(gvr);
1136 return gvr_recti{0, screen_size.width, 0, screen_size.height};
1137}
1138
1139void gvr_compute_distorted_point(const gvr_context* /* gvr */,
1140 const int32_t /* eye */,
1141 const gvr_vec2f /* uv_in */,
1142 gvr_vec2f /* uv_out */[3]) {
1143 // TODO(leandrogracia): this needs to be properly implemented.
1144 ALOGE("gvr_compute_distorted_point not implemented.");
1145}
1146
1147/////////////////////////////////////////////////////////////////////////////
1148// GVR API extension (from gvr_ext.h)
1149/////////////////////////////////////////////////////////////////////////////
1150
1151gvr_frame_schedule* gvr_frame_schedule_create() {
1152 return new gvr_frame_schedule;
1153}
1154
1155void gvr_frame_schedule_destroy(gvr_frame_schedule** schedule) {
1156 if (!schedule || !(*schedule)) {
1157 ALOGW("gvr_frame_schedule_destroy: Invalid frame schedule pointer.");
1158 return;
1159 }
1160 delete *schedule;
1161 *schedule = nullptr;
1162}
1163
1164uint32_t gvr_frame_schedule_get_vsync_count(gvr_frame_schedule* schedule) {
1165 return schedule->vsync_count;
1166}
1167
1168gvr_clock_time_point gvr_frame_schedule_get_scheduled_finish(
1169 gvr_frame_schedule* schedule) {
1170 return schedule->scheduled_finish;
1171}
1172
1173void gvr_wait_next_frame(gvr_swap_chain* swap_chain, int64_t start_delay_nanos,
1174 gvr_frame_schedule* out_next_frame_schedule) {
1175 WaitNextFrame(swap_chain, start_delay_nanos, out_next_frame_schedule,
1176 /*called_by_app*/ true);
1177}
1178
1179gvr_mat4f gvr_get_6dof_head_pose_in_start_space(gvr_context* gvr,
1180 uint32_t vsync_count) {
1181 DvrPoseAsync pose;
1182 int ret = dvrPoseGet(gvr->pose_client_, vsync_count, &pose);
1183 if (ret < 0) {
1184 ALOGW("dvrPoseGet failed: %d", ret);
1185 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
1186 return GvrIdentityMatrix();
1187 }
1188
1189 return PosefToGvrMatrix(ToPosef(pose));
1190}
1191
1192gvr_mat4f gvr_get_head_space_from_start_space_pose(
1193 gvr_context* gvr, const gvr_clock_time_point /* time */) {
1194 // TODO(leandrogracia): implement prediction based on the provided time.
1195 // We need to do the same for the 3dof version too.
1196 return gvr->next_frame_6dof_pose_;
1197}
1198
1199void gvr_swap_chain_set_z_order(const gvr_swap_chain* swap_chain, int z_order) {
1200 dvrGraphicsSurfaceSetZOrder(swap_chain->graphics_context_, z_order);
1201}
1202
1203bool gvr_experimental_is_feature_supported(const gvr_context* /* gvr */,
1204 int32_t feature) {
1205 switch (feature) {
1206 case GVR_ASYNC_REPROJECTION:
1207 case GVR_6DOF_HEAD_POSE:
1208 return true;
1209 default:
1210 return false;
1211 }
1212}
1213
1214bool gvr_experimental_register_perf_event_callback(
1215 gvr_context* gvr, int* /* out_handle */, void* /* user_data */,
1216 void (* /* event_callback */)(void*, int, float)) {
1217 ALOGE("gvr_experimental_register_perf_event_callback not implemented.");
1218 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
1219 return false;
1220}
1221
1222bool gvr_experimental_unregister_perf_event_callback(gvr_context* gvr,
1223 int /* handle */) {
1224 ALOGE("gvr_experimental_unregister_perf_event_callback not implemented.");
1225 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
1226 return false;
1227}
1228
1229const gvr_analytics* gvr_get_analytics(gvr_context* gvr) {
1230 ALOGE("gvr_get_analytics not implemented.");
1231 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
1232 return nullptr;
1233}
1234
1235const gvr_analytics_sample* gvr_analytics_create_sample(
1236 const gvr_analytics* analytics) {
1237 ALOGE("gvr_analytics_create_sample not implemented.");
1238 return nullptr;
1239}
1240
1241const char* gvr_analytics_sample_get_buffer(const gvr_analytics_sample* sample) {
1242 ALOGE("gvr_analytics_sample_get_buffer not implemented.");
1243 return nullptr;
1244}
1245
1246size_t gvr_analytics_sample_get_buffer_length(
1247 const gvr_analytics_sample* sample) {
1248 ALOGE("gvr_analytics_sample_get_buffer_length not implemented.");
1249 return 0;
1250}
1251
1252void gvr_analytics_destroy_sample(const gvr_analytics_sample** sample) {
1253 ALOGE("gvr_analytics_destroy_sample not implemented.");
1254}
1255
1256bool gvr_user_prefs_get_performance_monitoring_enabled(
1257 const gvr_user_prefs* /* user_prefs */) {
1258 ALOGW("gvr_user_prefs_get_performance_monitoring_enabled not implemented.");
1259 return false;
1260}
1261
1262void gvr_enable_context_sharing(gvr_context* gvr,
1263 gvr_egl_context_listener /* handler */,
1264 void* /* user_data */) {
1265 ALOGW("gvr_enable_context_sharing not implemented.");
1266 gvr_set_error(gvr, GVR_ERROR_INTERNAL);
1267}
1268
1269gvr_mat4f gvr_get_start_space_from_controller_space_pose(
1270 gvr_context* gvr, int controller_id,
1271 const gvr_clock_time_point /* time */) {
1272 if (controller_id < 0 || controller_id >= kControllerCount) {
1273 return GvrIdentityMatrix();
1274 }
1275
1276 // TODO(leandrogracia): implement prediction based on the provided time.
1277 // We need to do the same for the 3dof version too.
1278 return gvr->next_frame_controller_pose_[controller_id];
1279}
1280
1281gvr_external_surface* gvr_external_surface_create(gvr_context* context) {
1282 // A |gvr_external_surface| is bound to a DVR Graphics context at the
1283 // moment, which means we need an |gvr_swap_chain| created prior to the call
1284 // of |gvr_external_surface_create|. Check whether the current GVR context
1285 // has |gvr_swap_chain| created. Fail if there is no swap chain created
1286 // already.
1287 if (context->swap_chains_.empty()) {
1288 ALOGE("gvr_external_surface_create: No swapchain has been created yet.");
1289 return nullptr;
1290 }
1291
1292 // In case there are multiple swap chains in the context, the first is
1293 // implicitly chosen. Actually, this should not happen as current scanline
1294 // racing based GVR implementation only supports single swap chain per GVR
1295 // context.
1296 if (context->swap_chains_.size() > 1) {
1297 ALOGW("gvr_external_surface_create: Multiple swap chains detected. "
1298 "Choosing the first one but this may yield unexpected results.");
1299 }
1300 gvr_swap_chain* swap_chain = context->swap_chains_[0];
1301 DvrVideoMeshSurface* video_surface = dvrGraphicsVideoMeshSurfaceCreate(
1302 swap_chain->graphics_context_);
1303
1304 if (video_surface == nullptr) {
1305 ALOGE("gvr_external_surface_create: Failed to create video mesh surface.");
1306 return nullptr;
1307 }
1308
1309 gvr_external_surface* surface = new gvr_external_surface;
1310 surface->id = swap_chain->next_external_surface_id_++;
1311 surface->swap_chain = swap_chain;
1312 surface->video_surface = video_surface;
1313
1314 // Insert the surface into a lookup table in swap_chain. This will be
1315 // needed to by the external_surface_id in |gvr_buffer_viewport|.
1316 swap_chain->external_surfaces_.insert({surface->id, surface});
1317 return surface;
1318}
1319
1320void gvr_external_surface_destroy(gvr_external_surface** surface) {
1321 if (!surface || !(*surface)) {
1322 ALOGW("gvr_external_surface_destroy: Invalid external surface pointer.");
1323 return;
1324 }
1325
1326 (*surface)->swap_chain->external_surfaces_.erase((*surface)->id);
1327 if ((*surface)->video_surface != nullptr) {
1328 dvrGraphicsVideoMeshSurfaceDestroy((*surface)->video_surface);
1329 }
1330
1331 delete *surface;
1332 *surface = nullptr;
1333}
1334
1335void* gvr_external_surface_get_surface(const gvr_external_surface* surface) {
1336 CHECK(surface->swap_chain != nullptr &&
1337 surface->swap_chain->context != nullptr &&
1338 surface->swap_chain->context->jni_env_ != nullptr)
1339 << "gvr_external_surface_get_surface: Surface must be constructed within "
1340 << "a JNIEnv. Check |gvr_create| call.";
1341
1342 CHECK(surface->video_surface != nullptr)
1343 << "gvr_external_surface_get_surface: Invalid surface.";
1344
1345 std::shared_ptr<android::dvr::ProducerQueue> producer_queue =
1346 surface->video_surface->client->GetProducerQueue();
1347 std::shared_ptr<android::dvr::BufferHubQueueCore> core =
1348 android::dvr::BufferHubQueueCore::Create(producer_queue);
1349
1350 return android_view_Surface_createFromIGraphicBufferProducer(
1351 surface->swap_chain->context->jni_env_,
1352 new android::dvr::BufferHubQueueProducer(core));
1353}
1354
1355int32_t gvr_external_surface_get_surface_id(
1356 const gvr_external_surface* surface) {
1357 return surface->id;
1358}