mirror of
https://github.com/servo/servo.git
synced 2025-08-03 04:30:10 +01:00
Implement webrender::ExternalImageHandler for player
Added trait GLPlayerExternalImageApi and its implementation Implemented webrender::ExternalImageHandler using GLPlayerExternalImageApi
This commit is contained in:
parent
65f9e2161c
commit
e000c14eb2
2 changed files with 111 additions and 2 deletions
|
@ -2,8 +2,12 @@
|
|||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
||||
|
||||
use crate::media_thread::GLPlayerThread;
|
||||
use canvas_traits::media::{GLPlayerChan, GLPlayerMsg, GLPlayerPipeline, GLPlayerSender};
|
||||
use crate::media_thread::{GLPlayerExternalImageApi, GLPlayerExternalImageHandler, GLPlayerThread};
|
||||
use canvas_traits::media::glplayer_channel;
|
||||
use canvas_traits::media::{
|
||||
GLPlayerChan, GLPlayerMsg, GLPlayerPipeline, GLPlayerReceiver, GLPlayerSender,
|
||||
};
|
||||
use euclid::Size2D;
|
||||
|
||||
/// GLPlayer Threading API entry point that lives in the constellation.
|
||||
pub struct GLPlayerThreads(GLPlayerSender<GLPlayerMsg>);
|
||||
|
@ -28,3 +32,50 @@ impl GLPlayerThreads {
|
|||
.map_err(|_| "Failed to send Exit message")
|
||||
}
|
||||
}
|
||||
|
||||
/// Bridge between the webrender::ExternalImage callbacks and the
|
||||
/// GLPlayerThreads.
|
||||
struct GLPlayerExternalImages {
|
||||
// @FIXME(victor): this should be added when GstGLSyncMeta is
|
||||
// added
|
||||
//webrender_gl: Rc<dyn gl::Gl>,
|
||||
glplayer_channel: GLPlayerSender<GLPlayerMsg>,
|
||||
// Used to avoid creating a new channel on each received WebRender
|
||||
// request.
|
||||
lock_channel: (
|
||||
GLPlayerSender<(u32, Size2D<i32>, usize)>,
|
||||
GLPlayerReceiver<(u32, Size2D<i32>, usize)>,
|
||||
),
|
||||
}
|
||||
|
||||
impl GLPlayerExternalImages {
|
||||
fn new(channel: GLPlayerSender<GLPlayerMsg>) -> Self {
|
||||
Self {
|
||||
glplayer_channel: channel,
|
||||
lock_channel: glplayer_channel().unwrap(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl GLPlayerExternalImageApi for GLPlayerExternalImages {
|
||||
fn lock(&mut self, id: u64) -> (u32, Size2D<i32>) {
|
||||
// The GLPlayerMsgForward::Lock message inserts a fence in the
|
||||
// GLPlayer command queue.
|
||||
self.glplayer_channel
|
||||
.send(GLPlayerMsg::Lock(id, self.lock_channel.0.clone()))
|
||||
.unwrap();
|
||||
let (image_id, size, _gl_sync) = self.lock_channel.1.recv().unwrap();
|
||||
// The next glWaitSync call is run on the WR thread and it's
|
||||
// used to synchronize the two flows of OpenGL commands in
|
||||
// order to avoid WR using a semi-ready GLPlayer texture.
|
||||
// glWaitSync doesn't block WR thread, it affects only
|
||||
// internal OpenGL subsystem.
|
||||
//self.webrender_gl
|
||||
// .wait_sync(gl_sync as gl::GLsync, 0, gl::TIMEOUT_IGNORED);
|
||||
(image_id, size)
|
||||
}
|
||||
|
||||
fn unlock(&mut self, id: u64) {
|
||||
self.glplayer_channel.send(GLPlayerMsg::Unlock(id)).unwrap();
|
||||
}
|
||||
}
|
||||
|
|
|
@ -3,6 +3,7 @@
|
|||
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
||||
|
||||
use canvas_traits::media::*;
|
||||
use euclid::Size2D;
|
||||
use fnv::FnvHashMap;
|
||||
use std::thread;
|
||||
|
||||
|
@ -80,3 +81,60 @@ impl GLPlayerThread {
|
|||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// This trait is used as a bridge between the `GLPlayerThreads`
|
||||
/// implementation and the WR ExternalImageHandler API implemented in
|
||||
/// the `GLPlayerExternalImageHandler` struct.
|
||||
//
|
||||
/// `GLPlayerExternalImageHandler<T>` takes care of type conversions
|
||||
/// between WR and GLPlayer info (e.g keys, uvs).
|
||||
//
|
||||
/// It uses this trait to notify lock/unlock messages and get the
|
||||
/// required info that WR needs.
|
||||
//
|
||||
/// `GLPlayerThreads` receives lock/unlock message notifications and
|
||||
/// takes care of sending the unlock/lock messages to the appropiate
|
||||
/// `GLPlayerThread`.
|
||||
pub trait GLPlayerExternalImageApi {
|
||||
fn lock(&mut self, id: u64) -> (u32, Size2D<i32>);
|
||||
fn unlock(&mut self, id: u64);
|
||||
}
|
||||
|
||||
/// WebRender External Image Handler implementation
|
||||
pub struct GLPlayerExternalImageHandler<T: GLPlayerExternalImageApi> {
|
||||
handler: T,
|
||||
}
|
||||
|
||||
impl<T: GLPlayerExternalImageApi> GLPlayerExternalImageHandler<T> {
|
||||
pub fn new(handler: T) -> Self {
|
||||
Self { handler: handler }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: GLPlayerExternalImageApi> webrender::ExternalImageHandler
|
||||
for GLPlayerExternalImageHandler<T>
|
||||
{
|
||||
/// Lock the external image. Then, WR could start to read the
|
||||
/// image content.
|
||||
/// The WR client should not change the image content until the
|
||||
/// unlock() call.
|
||||
fn lock(
|
||||
&mut self,
|
||||
key: webrender_api::ExternalImageId,
|
||||
_channel_index: u8,
|
||||
_rendering: webrender_api::ImageRendering,
|
||||
) -> webrender::ExternalImage {
|
||||
let (texture_id, size) = self.handler.lock(key.0);
|
||||
|
||||
webrender::ExternalImage {
|
||||
uv: webrender_api::TexelRect::new(0.0, 0.0, size.width as f32, size.height as f32),
|
||||
source: webrender::ExternalImageSource::NativeTexture(texture_id),
|
||||
}
|
||||
}
|
||||
|
||||
/// Unlock the external image. The WR should not read the image
|
||||
/// content after this call.
|
||||
fn unlock(&mut self, key: webrender_api::ExternalImageId, _channel_index: u8) {
|
||||
self.handler.unlock(key.0);
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue