void egl_context_term(EGL_CONTEXT_T *context)
{
   /* If we're current then there should still be a reference to us */
   /* (if this wasn't the case we should call egl_context_release_surfaces here) */
   vcos_assert(!context->is_current);
   vcos_assert(context->is_destroyed);

   switch (context->type) {
#ifndef NO_OPENVG
   case OPENVG:
      RPC_CALL1(eglIntDestroyVG_impl,
                EGLINTDESTROYVG_ID,
                RPC_UINT(context->servercontext));
      vg_client_state_free((VG_CLIENT_STATE_T *)context->state);
      break;
#endif
   case OPENGL_ES_11:
   case OPENGL_ES_20:
      RPC_CALL1(eglIntDestroyGL_impl,
                EGLINTDESTROYGL_ID,
                RPC_UINT(context->servercontext));
      glxx_client_state_free((GLXX_CLIENT_STATE_T *)context->state);
      break;
   default:
      UNREACHABLE();
   }

   context->state = 0;
}
static void set_egl_image_color_data(EGLImageKHR egl_image, KHRN_IMAGE_WRAP_T *image)
{
   int line_size = (image->stride < 0) ? -image->stride : image->stride;
   int lines = KHDISPATCH_WORKSPACE_SIZE / line_size;
   int offset = 0;
   int height = image->height;

   if (khrn_image_is_tformat(image->format))
      lines &= ~63;

   assert(lines > 0);

   while (height > 0) {
      int batch = _min(lines, height);
      uint32_t len = batch * line_size;

      int adjusted_offset = (image->stride < 0) ? (offset + (batch - 1)) : offset;

      RPC_CALL7_IN_BULK(eglImageSetColorData_impl,
         EGLIMAGESETCOLORDATA_ID,
         RPC_EGLID(egl_image),
         RPC_UINT(image->format),
         RPC_UINT(image->width),
         RPC_INT(batch),
         RPC_UINT(image->stride),
         RPC_INT(offset),
         (const char *)image->storage + adjusted_offset * image->stride,
         len);

      offset += batch;
      height -= batch;
   }
}
Exemplo n.º 3
0
void wfc_commit_callback(WFC_ELEMENT_T *element)
{
   WFCNativeStreamType source_stream =
      element->source ? element->source->stream : WFC_INVALID_HANDLE;
   WFCNativeStreamType mask_stream =
      element->mask ? element->mask->stream : WFC_INVALID_HANDLE;

#ifdef RPC_DIRECT
   wfcIntCommitAdd_impl((WFCContext) element->context,
      (WFCElement) element, &element->attributes, source_stream, mask_stream);
#else
   RPC_CALL18(wfcIntCommitAdd_impl,
      WFCINTCOMMITADD_ID,
      RPC_UINT((WFCContext) element->context),
      RPC_UINT((WFCElement) element),
      RPC_INT(element->attributes.dest_rect[0]),
      RPC_INT(element->attributes.dest_rect[1]),
      RPC_INT(element->attributes.dest_rect[2]),
      RPC_INT(element->attributes.dest_rect[3]),
      RPC_FLOAT(element->attributes.src_rect[0]),
      RPC_FLOAT(element->attributes.src_rect[1]),
      RPC_FLOAT(element->attributes.src_rect[2]),
      RPC_FLOAT(element->attributes.src_rect[3]),
      RPC_BOOLEAN(element->attributes.flip),
      RPC_ENUM(element->attributes.rotation),
      RPC_ENUM(element->attributes.scale_filter),
      RPC_BITFIELD(element->attributes.transparency_types),
      RPC_FLOAT(element->attributes.global_alpha),
      RPC_UINT(source_stream),
      RPC_UINT(mask_stream),
      RPC_UINT(0)); // dummy parameter; currently unused.
#endif

} // wfc_commit_callback()
Exemplo n.º 4
0
GL_API void GL_APIENTRY glEGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image)
{
   CLIENT_THREAD_STATE_T *thread = CLIENT_GET_THREAD_STATE();

   if (IS_OPENGLES_11_OR_20(thread)) {
#if EGL_BRCM_global_image
      if ((uintptr_t)image & (1u << 31)) {
         GLuint global_image_id[2];
         if (check_global_image_egl_image(global_image_id, image, thread, false)) {
            RPC_CALL3(glGlobalImageTexture2DOES_impl,
                      thread,
                      GLGLOBALIMAGETEXTURE2DOES_ID,
                      RPC_ENUM(target),
                      RPC_UINT(global_image_id[0]),
                      RPC_UINT(global_image_id[1]));
         } else {
            set_error(GLXX_GET_CLIENT_STATE(thread), GL_INVALID_VALUE);
         }
      } else {
#endif
         vcos_log_trace("[%s] target 0x%x image %d", __FUNCTION__, target, (uint32_t)image);
         RPC_CALL2(glEGLImageTargetTexture2DOES_impl,
                   thread,
                   GLEGLIMAGETARGETTEXTURE2DOES_ID,
                   RPC_ENUM(target),
                   RPC_EGLID(image));
         RPC_FLUSH(thread);
#if EGL_BRCM_global_image
      }
#endif
   }
}
Exemplo n.º 5
0
WFC_CONTEXT_T *wfc_context_create
   (WFC_DEVICE_T *device_ptr, WFCContextType context_type,
      uint32_t screen_or_stream_num, WFCErrorCode *error)
{
   WFC_CONTEXT_T *context_ptr =
      khrn_platform_malloc(sizeof(WFC_CONTEXT_T), "WFC_CONTEXT_T");
   const WFC_CONTEXT_ATTRIB_T context_attrib_default = WFC_CONTEXT_ATTRIB_DEFAULT;

   if(context_ptr != NULL)
   {
      uint32_t response = RPC_CALL3_RES(wfcIntCreateContext_impl,
                                   WFCINTCREATECONTEXT_ID,
                                   RPC_UINT((uint32_t) context_ptr),
                                   RPC_ENUM(context_type),
                                   RPC_UINT(screen_or_stream_num));

      uint32_t height_or_err = WFC_CONTEXT_HEIGHT_OR_ERR(response);
      uint32_t width = WFC_CONTEXT_WIDTH(response);

      if(width != 0)
      {
         wfc_link_init_null(&context_ptr->link);

         context_ptr->device = device_ptr;
         wfc_link_init_empty(&context_ptr->sources);
         wfc_link_init_empty(&context_ptr->masks);

         wfc_link_init_empty(&context_ptr->elements_not_in_scene);
         wfc_link_init_empty(&context_ptr->elements_in_scene);
         context_ptr->active = false;

         context_ptr->type = context_type;
         context_ptr->height = height_or_err;
         context_ptr->width = width;
         context_ptr->attributes = context_attrib_default;
      } // if
      else
      {
         khrn_platform_free(context_ptr);

         context_ptr = NULL;

         *error = (WFCErrorCode) response;
      } // else
   } // if
   else
      {*error = WFC_ERROR_OUT_OF_MEMORY;}

   return context_ptr;
} // wfc_context_create()
void egl_sync_term(EGL_SYNC_T *sync)
{
   RPC_CALL1(eglIntDestroySync_impl,
             EGLINTDESTROYSYNC_ID,
             RPC_UINT(sync->serversync));

#ifdef __SYMBIAN32__ 
   RPC_FLUSH(); // now videocore requests semaphore deletion
#else
   khronos_platform_semaphore_destroy(&sync->master); 
#endif
}
static EGL_SYNC_T *egl_sync_create(EGLSyncKHR name, EGLint condition, EGLint threshold)
{
   EGL_SYNC_T *sync = (EGL_SYNC_T *)khrn_platform_malloc(sizeof(EGL_SYNC_T), "EGL_SYNC_T");
   uint64_t pid = khronos_platform_get_process_id();
   uint32_t token;

   if (!sync)
      return 0;

   sync->condition = condition;
   sync->threshold = threshold;

   sync->sem[0] = (int)pid;
   sync->sem[1] = (int)(pid >> 32);
   sync->sem[2] = (int)name;

   if (khronos_platform_semaphore_create(&sync->master, sync->sem, 0) != KHR_SUCCESS) {
      khrn_platform_free(sync);
      return 0;
   }

#ifdef __SYMBIAN32__
   token = (uint32_t)sync->master;
#else
   token = (uint32_t)name;
#endif
   sync->serversync = RPC_UINT_RES(RPC_CALL3_RES(eglIntCreateSync_impl,
                                                 EGLINTCREATESYNC_ID,
                                                 RPC_UINT(condition),
                                                 RPC_INT(threshold),
                                                 RPC_UINT(token)));

   if (sync->serversync)
      return sync;
   else {
      khronos_platform_semaphore_destroy(&sync->master);
      khrn_platform_free(sync);
      return 0;
   }
}
Exemplo n.º 8
0
GL_API void GL_APIENTRY glEGLImageTargetRenderbufferStorageOES (GLenum target, GLeglImageOES image)
{
   CLIENT_THREAD_STATE_T *thread = CLIENT_GET_THREAD_STATE();

   if (IS_OPENGLES_11(thread)) {
      /* OES_framebuffer_object not supported for GLES1.1 */
      GLXX_CLIENT_STATE_T *state = GLXX_GET_CLIENT_STATE(thread);
      if (state->error == GL_NO_ERROR)
         state->error = GL_INVALID_OPERATION;
   }
   else if (IS_OPENGLES_20(thread)) {
#if EGL_BRCM_global_image
      if ((uintptr_t)image & (1u << 31)) {
         GLuint global_image_id[2];
         if (check_global_image_egl_image(global_image_id, image, thread, true)) {
            RPC_CALL3(glGlobalImageRenderbufferStorageOES_impl_20,
                      thread,
                      GLGLOBALIMAGERENDERBUFFERSTORAGEOES_ID_20,
                      RPC_ENUM(target),
                      RPC_UINT(global_image_id[0]),
                      RPC_UINT(global_image_id[1]));
         } else {
            set_error(GLXX_GET_CLIENT_STATE(thread), GL_INVALID_VALUE);
         }
      } else {
#endif
         RPC_CALL2(glEGLImageTargetRenderbufferStorageOES_impl_20,
                   thread,
                   GLEGLIMAGETARGETRENDERBUFFERSTORAGEOES_ID_20,
                   RPC_ENUM(target),
                   RPC_EGLID(image));
#if EGL_BRCM_global_image
      }
#endif
   }
}
Exemplo n.º 9
0
void wfc_context_destroy(WFC_CONTEXT_T *context)
{
   // Remove from parent device's list of contexts.
   wfc_link_detach(&context->link);

   // Destroy all components
   wfc_link_iterate(&context->elements_in_scene, (WFC_LINK_CALLBACK_T) wfc_element_destroy);
   wfc_link_iterate(&context->elements_not_in_scene, (WFC_LINK_CALLBACK_T) wfc_element_destroy);
   wfc_link_iterate(&context->sources, (WFC_LINK_CALLBACK_T) wfc_source_or_mask_destroy_actual);
   wfc_link_iterate(&context->masks, (WFC_LINK_CALLBACK_T) wfc_source_or_mask_destroy_actual);

   RPC_CALL1(wfcIntDestroyContext_impl,
             WFCINTDESTROYCONTEXT_ID,
             RPC_UINT((WFCContext) context));
   RPC_FLUSH();

   khrn_platform_free(context);
} // wfc_context_destroy()