media/mojo/mojom/renderer_extensions.mojom - chromium/src - Git at Google

 // Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 module media.mojom;

 import "media/mojo/mojom/media_types.mojom";
 import "mojo/public/mojom/base/time.mojom";
 import "mojo/public/mojom/base/unguessable_token.mojom";
 import "ui/gfx/geometry/mojom/geometry.mojom";

 [EnableIf=is_win]
 import "ui/gfx/mojom/buffer_types.mojom";
 // Extension of the mojo::RendererClient communication layer for HLS and Android
 // software rendering fallback paths.
 // This allows the Browser side to call back into the Renderer side. Concretely,
 // the MediaPlayerRenderer uses these methods to propagate events it raises to
 // the MediaPlayerRendererClient, which lives in the Renderer process.
 interface MediaPlayerRendererClientExtension {
   // Called when the first time the metadata is updated, and whenever the
   // metadata changes.
   OnVideoSizeChange(gfx.mojom.Size size);
   OnDurationChange(mojo_base.mojom.TimeDelta duration);
 };

 // Extension of the mojo::Renderer communication layer for HLS and Android
 // software rendering fallback paths.
 // This allows the Renderer side to call into the Browser side.
 // Concretely, the MediaPlayerRendererClient uses these methods to send commands
 // to MediaPlayerRenderer, which lives in the Browser process.
 interface MediaPlayerRendererExtension {
   // Registers a new request in the ScopedSurfaceRequestManager, and returns
   // its token.
   // Called once, during media::Renderer initialization, as part of
   // StreamTexture's set-up.
   InitiateScopedSurfaceRequest()
       => (mojo_base.mojom.UnguessableToken request_token);
 };

 // Extension of the mojo::RendererClient communication layer for media flinging,
 // a.k.a RemotePlayback, when playing media on a remote Cast device.
 // This allows the Browser side to call back into the Renderer side.
 // Concretely, the FlingingRenderer uses these methods to propagate events it
 // raises to the FlingingRendererClient, which lives in the Renderer process.
 interface FlingingRendererClientExtension {
   // Called when the play state of a casted device goes out of sync with WMPI's
   // play state (e.g. when another phone play/pauses a cast device on the same
   // network).
   OnRemotePlayStateChange(MediaStatusState state);
 };

 [EnableIf=is_win]
 struct FrameTextureInfo {
   gfx.mojom.GpuMemoryBufferHandle texture_handle;
   mojo_base.mojom.UnguessableToken token;
 };

 [EnableIf=is_win]
 struct FramePoolInitializationParameters {
   array<FrameTextureInfo> frame_textures;
   gfx.mojom.Size texture_size;
 };

 [EnableIf=is_win]
 // Extension of the mojo:RendererClient communication layer for Media
 // Foundation based Renderer.
 // This allows the MF_CDM utility process to call the blink Renderer process
 // side.
 // Concretely, the MediaFoundationRenderer (in the MF_CDM process) uses these
 // methods to send video frames as textures to the
 // MediaFoundationRendererClient which lives in the blink renderer process so
 // that the MediaFoundationRenderer can signal to the video stream sink that
 // the specific texture is ready to be displayed.
 interface MediaFoundationRendererClientExtension {
   // Provide the GPU textures (ID3D11Texture2D) to the
   // MediaFoundationRendererClient with the associated token so that the
   // MediaFoundationRendererClient can create the shared images in the GPU
   // process using the SharedImageInterface.
   InitializeFramePool(FramePoolInitializationParameters pool_info);

   // Signal to the MediaFoundationRendererClient that the texture associated
   // with the frame_token is ready to be displayed with the corresponding
   // frame size and timestamp which is the delta between the start of the
   // AV presentation and the time that the frame is to be presented.
   OnFrameAvailable(mojo_base.mojom.UnguessableToken frame_token,
     gfx.mojom.Size size, mojo_base.mojom.TimeDelta timestamp);
 };

 // The Media Foundation Media Engine has two modes for playback.
 // DirectComposition is when the media engine will render directly to a
 // direct composition visual, skipping the Chromium compositor.
 // FrameServer is when the media engine will render to a texture and
 // that textured is provided to the Chromium compositor.
 enum MediaFoundationRenderingMode {
   DirectComposition,
   FrameServer
 };

 [EnableIf=is_win]
 // Extension of the mojo::Renderer communication layer for MediaFoundation-based
 // Renderer.
 // This allows the MediaFoundationRendererClient in the render process to call
 // into the MediaFoundationRenderer in the MediaFoundationService (utility/LPAC)
 // process.
 // Please refer to media/renderers/win/media_foundation_renderer_extension.h
 // for its C++ interface equivalence.
 interface MediaFoundationRendererExtension {
   // Enables Direct Composition video rendering and gets the token associated
   // with the Direct Composition surface handle, which can be retrieved later
   // in the GPU process using the token. Returns a null `token` on failures when
   // `error` explains the failure reason.
   GetDCOMPSurface() => (mojo_base.mojom.UnguessableToken? token, string error);

   // Notifies whether video is enabled.
   SetVideoStreamEnabled(bool enabled);

   // Notifies of output composition parameters. It might fail if
   // MediaFoundationRenderer runs into error while setting the `rect`
   // information onto MFMediaEngine. It it fails, the video will be displayed
   // incorrectly (e.g. a smaller video rendered at the corner of the video
   // output area.). In case of failure, caller should not use the `rect` for
   // further operations.
   SetOutputRect(gfx.mojom.Rect rect) => (bool success);

   // Notify that the frame has been displayed and can be reused.
   NotifyFrameReleased(mojo_base.mojom.UnguessableToken frame_token);

   // Request a frame from the media engine if it is available
   // The frame will be returned async via the
   // MediaFoundationRendererClientExtension::OnFrameAvailable callback.
   RequestNextFrame();

   // Notify which rendering mode to be using for future video frames.
   SetMediaFoundationRenderingMode(MediaFoundationRenderingMode mode);
 };

 // This interface is used by the browser to determine if there are any renderers
 // actively using the Media Foundation Renderer. The number of Media Foundation
 // Renderers in use is determined by the number of active connections. The
 // remote lives in the renderer process and the receiver lives in the browser
 // process.
 interface MediaFoundationRendererObserver {
 };

 // This interface is used to notify the browser that the renderer is using the
 // Media Foundation Renderer which uses MediaFoundation to render audio
 // directly. Live Caption will not work in this case because Chrome is unable
 // to tap into the audio rendering pipeline. The remote lives in the renderer
 // process and the receiver lives in the browser process.
 interface MediaFoundationRendererNotifier {
   // Notify the browser than a Media Foundation Renderer has been created. The
   // browser will use this event to notify the user that some features
   // incompatible with the Media Foundation Renderer may not work.
   MediaFoundationRendererCreated(
     pending_receiver<MediaFoundationRendererObserver> observer);
 };
	// Copyright 2019 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	module media.mojom;

	import "media/mojo/mojom/media_types.mojom";
	import "mojo/public/mojom/base/time.mojom";
	import "mojo/public/mojom/base/unguessable_token.mojom";
	import "ui/gfx/geometry/mojom/geometry.mojom";

	[EnableIf=is_win]
	import "ui/gfx/mojom/buffer_types.mojom";
	// Extension of the mojo::RendererClient communication layer for HLS and Android
	// software rendering fallback paths.
	// This allows the Browser side to call back into the Renderer side. Concretely,
	// the MediaPlayerRenderer uses these methods to propagate events it raises to
	// the MediaPlayerRendererClient, which lives in the Renderer process.
	interface MediaPlayerRendererClientExtension {
	// Called when the first time the metadata is updated, and whenever the
	// metadata changes.
	OnVideoSizeChange(gfx.mojom.Size size);
	OnDurationChange(mojo_base.mojom.TimeDelta duration);
	};

	// Extension of the mojo::Renderer communication layer for HLS and Android
	// software rendering fallback paths.
	// This allows the Renderer side to call into the Browser side.
	// Concretely, the MediaPlayerRendererClient uses these methods to send commands
	// to MediaPlayerRenderer, which lives in the Browser process.
	interface MediaPlayerRendererExtension {
	// Registers a new request in the ScopedSurfaceRequestManager, and returns
	// its token.
	// Called once, during media::Renderer initialization, as part of
	// StreamTexture's set-up.
	InitiateScopedSurfaceRequest()
	=> (mojo_base.mojom.UnguessableToken request_token);
	};

	// Extension of the mojo::RendererClient communication layer for media flinging,
	// a.k.a RemotePlayback, when playing media on a remote Cast device.
	// This allows the Browser side to call back into the Renderer side.
	// Concretely, the FlingingRenderer uses these methods to propagate events it
	// raises to the FlingingRendererClient, which lives in the Renderer process.
	interface FlingingRendererClientExtension {
	// Called when the play state of a casted device goes out of sync with WMPI's
	// play state (e.g. when another phone play/pauses a cast device on the same
	// network).
	OnRemotePlayStateChange(MediaStatusState state);
	};

	[EnableIf=is_win]
	struct FrameTextureInfo {
	gfx.mojom.GpuMemoryBufferHandle texture_handle;
	mojo_base.mojom.UnguessableToken token;
	};

	[EnableIf=is_win]
	struct FramePoolInitializationParameters {
	array<FrameTextureInfo> frame_textures;
	gfx.mojom.Size texture_size;
	};

	[EnableIf=is_win]
	// Extension of the mojo:RendererClient communication layer for Media
	// Foundation based Renderer.
	// This allows the MF_CDM utility process to call the blink Renderer process
	// side.
	// Concretely, the MediaFoundationRenderer (in the MF_CDM process) uses these
	// methods to send video frames as textures to the
	// MediaFoundationRendererClient which lives in the blink renderer process so
	// that the MediaFoundationRenderer can signal to the video stream sink that
	// the specific texture is ready to be displayed.
	interface MediaFoundationRendererClientExtension {
	// Provide the GPU textures (ID3D11Texture2D) to the
	// MediaFoundationRendererClient with the associated token so that the
	// MediaFoundationRendererClient can create the shared images in the GPU
	// process using the SharedImageInterface.
	InitializeFramePool(FramePoolInitializationParameters pool_info);

	// Signal to the MediaFoundationRendererClient that the texture associated
	// with the frame_token is ready to be displayed with the corresponding
	// frame size and timestamp which is the delta between the start of the
	// AV presentation and the time that the frame is to be presented.
	OnFrameAvailable(mojo_base.mojom.UnguessableToken frame_token,
	gfx.mojom.Size size, mojo_base.mojom.TimeDelta timestamp);
	};

	// The Media Foundation Media Engine has two modes for playback.
	// DirectComposition is when the media engine will render directly to a
	// direct composition visual, skipping the Chromium compositor.
	// FrameServer is when the media engine will render to a texture and
	// that textured is provided to the Chromium compositor.
	enum MediaFoundationRenderingMode {
	DirectComposition,
	FrameServer
	};

	[EnableIf=is_win]
	// Extension of the mojo::Renderer communication layer for MediaFoundation-based
	// Renderer.
	// This allows the MediaFoundationRendererClient in the render process to call
	// into the MediaFoundationRenderer in the MediaFoundationService (utility/LPAC)
	// process.
	// Please refer to media/renderers/win/media_foundation_renderer_extension.h
	// for its C++ interface equivalence.
	interface MediaFoundationRendererExtension {
	// Enables Direct Composition video rendering and gets the token associated
	// with the Direct Composition surface handle, which can be retrieved later
	// in the GPU process using the token. Returns a null `token` on failures when
	// `error` explains the failure reason.
	GetDCOMPSurface() => (mojo_base.mojom.UnguessableToken? token, string error);

	// Notifies whether video is enabled.
	SetVideoStreamEnabled(bool enabled);

	// Notifies of output composition parameters. It might fail if
	// MediaFoundationRenderer runs into error while setting the `rect`
	// information onto MFMediaEngine. It it fails, the video will be displayed
	// incorrectly (e.g. a smaller video rendered at the corner of the video
	// output area.). In case of failure, caller should not use the `rect` for
	// further operations.
	SetOutputRect(gfx.mojom.Rect rect) => (bool success);

	// Notify that the frame has been displayed and can be reused.
	NotifyFrameReleased(mojo_base.mojom.UnguessableToken frame_token);

	// Request a frame from the media engine if it is available
	// The frame will be returned async via the
	// MediaFoundationRendererClientExtension::OnFrameAvailable callback.
	RequestNextFrame();

	// Notify which rendering mode to be using for future video frames.
	SetMediaFoundationRenderingMode(MediaFoundationRenderingMode mode);
	};

	// This interface is used by the browser to determine if there are any renderers
	// actively using the Media Foundation Renderer. The number of Media Foundation
	// Renderers in use is determined by the number of active connections. The
	// remote lives in the renderer process and the receiver lives in the browser
	// process.
	interface MediaFoundationRendererObserver {
	};

	// This interface is used to notify the browser that the renderer is using the
	// Media Foundation Renderer which uses MediaFoundation to render audio
	// directly. Live Caption will not work in this case because Chrome is unable
	// to tap into the audio rendering pipeline. The remote lives in the renderer
	// process and the receiver lives in the browser process.
	interface MediaFoundationRendererNotifier {
	// Notify the browser than a Media Foundation Renderer has been created. The
	// browser will use this event to notify the user that some features
	// incompatible with the Media Foundation Renderer may not work.
	MediaFoundationRendererCreated(
	pending_receiver<MediaFoundationRendererObserver> observer);
	};