isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-28 02:50:41 -05:00
Code Issues Packages Projects Releases Wiki Activity

screen-cast-session: Add screen-cast window mode

Browse Source 
Window mode will cast the content of a single window using the
`MetaScreenCastWindow` interface.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/306
(cherry picked from commit dbe7279c7f)
This commit is contained in:
Olivier Fourdan 2018-10-09 15:35:14 +02:00 committed by Ray Strode
parent acca2962f1
commit 591e7c5760
5 changed files with 599 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Makefile.am
View File

@ -372,6 +372,10 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES += \
backends/meta-screen-cast-monitor-stream.h \ backends/meta-screen-cast-monitor-stream.h \
backends/meta-screen-cast-monitor-stream-src.c \ backends/meta-screen-cast-monitor-stream-src.c \
backends/meta-screen-cast-monitor-stream-src.h \ backends/meta-screen-cast-monitor-stream-src.h \
backends/meta-screen-cast-window-stream-src.c \
backends/meta-screen-cast-window-stream-src.h \
backends/meta-screen-cast-window-stream.c \
backends/meta-screen-cast-window-stream.h \
backends/meta-screen-cast-session.c \ backends/meta-screen-cast-session.c \
backends/meta-screen-cast-session.h \ backends/meta-screen-cast-session.h \
backends/meta-screen-cast-stream.c \ backends/meta-screen-cast-stream.c \

245
src/backends/meta-screen-cast-window-stream-src.c Normal file
View File

@ -0,0 +1,245 @@
/*
* Copyright (C) 2018 Red Hat Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
*/
#include "config.h"
#include "backends/meta-screen-cast-window-stream-src.h"
#include "backends/meta-backend-private.h"
#include "backends/meta-screen-cast-window.h"
#include "backends/meta-screen-cast-window-stream.h"
#include "compositor/meta-window-actor-private.h"
struct _MetaScreenCastWindowStreamSrc
{
MetaScreenCastStreamSrc parent;
MetaWindowActor *window_actor;
unsigned long actor_painted_handler_id;
unsigned long actor_destroyed_handler_id;
};
G_DEFINE_TYPE (MetaScreenCastWindowStreamSrc,
meta_screen_cast_window_stream_src,
META_TYPE_SCREEN_CAST_STREAM_SRC)
static MetaScreenCastWindowStream *
get_window_stream (MetaScreenCastWindowStreamSrc *window_src)
{
MetaScreenCastStreamSrc *src;
MetaScreenCastStream *stream;
src = META_SCREEN_CAST_STREAM_SRC (window_src);
stream = meta_screen_cast_stream_src_get_stream (src);
return META_SCREEN_CAST_WINDOW_STREAM (stream);
}
static MetaWindow *
get_window (MetaScreenCastWindowStreamSrc *window_src)
{
MetaScreenCastWindowStream *window_stream;
window_stream = get_window_stream (window_src);
return meta_screen_cast_window_stream_get_window (window_stream);
}
static int
get_stream_width (MetaScreenCastWindowStreamSrc *window_src)
{
MetaScreenCastWindowStream *window_stream;
window_stream = get_window_stream (window_src);
return meta_screen_cast_window_stream_get_width (window_stream);
}
static int
get_stream_height (MetaScreenCastWindowStreamSrc *window_src)
{
MetaScreenCastWindowStream *window_stream;
window_stream = get_window_stream (window_src);
return meta_screen_cast_window_stream_get_height (window_stream);
}
static gboolean
capture_into (MetaScreenCastWindowStreamSrc *window_src,
uint8_t *data)
{
MetaRectangle stream_rect;
MetaScreenCastWindow *screen_cast_window;
stream_rect.x = 0;
stream_rect.y = 0;
stream_rect.width = get_stream_width (window_src);
stream_rect.height = get_stream_height (window_src);
screen_cast_window = META_SCREEN_CAST_WINDOW (window_src->window_actor);
meta_screen_cast_window_capture_into (screen_cast_window, &stream_rect, data);
return TRUE;
}
static void
meta_screen_cast_window_stream_src_get_specs (MetaScreenCastStreamSrc *src,
int *width,
int *height,
float *frame_rate)
{
MetaScreenCastWindowStreamSrc *window_src =
META_SCREEN_CAST_WINDOW_STREAM_SRC (src);
*width = get_stream_width (window_src);
*height = get_stream_height (window_src);
*frame_rate = 60.0f;
}
static gboolean
meta_screen_cast_window_stream_src_get_videocrop (MetaScreenCastStreamSrc *src,
MetaRectangle *crop_rect)
{
MetaScreenCastWindowStreamSrc *window_src =
META_SCREEN_CAST_WINDOW_STREAM_SRC (src);
MetaScreenCastWindow *screen_cast_window;
MetaRectangle stream_rect;
screen_cast_window = META_SCREEN_CAST_WINDOW (window_src->window_actor);
meta_screen_cast_window_get_frame_bounds (screen_cast_window, crop_rect);
stream_rect.x = 0;
stream_rect.y = 0;
stream_rect.width = get_stream_width (window_src);
stream_rect.height = get_stream_height (window_src);
meta_rectangle_intersect (crop_rect, &stream_rect, crop_rect);
return TRUE;
}
static void
meta_screen_cast_window_stream_src_stop (MetaScreenCastWindowStreamSrc *window_src)
{
if (!window_src->window_actor)
return;
if (window_src->actor_painted_handler_id)
g_signal_handler_disconnect (window_src->window_actor,
window_src->actor_painted_handler_id);
window_src->actor_painted_handler_id = 0;
if (window_src->actor_destroyed_handler_id)
g_signal_handler_disconnect (window_src->window_actor,
window_src->actor_destroyed_handler_id);
window_src->actor_destroyed_handler_id = 0;
}
static void
window_actor_painted (MetaWindowActor *actor,
MetaScreenCastWindowStreamSrc *window_src)
{
MetaScreenCastStreamSrc *src = META_SCREEN_CAST_STREAM_SRC (window_src);
meta_screen_cast_stream_src_maybe_record_frame (src);
}
static void
window_actor_destroyed (MetaWindowActor *actor,
MetaScreenCastWindowStreamSrc *window_src)
{
meta_screen_cast_window_stream_src_stop (window_src);
window_src->window_actor = NULL;
}
static void
meta_screen_cast_window_stream_src_enable (MetaScreenCastStreamSrc *src)
{
MetaScreenCastWindowStreamSrc *window_src =
META_SCREEN_CAST_WINDOW_STREAM_SRC (src);
MetaWindowActor *window_actor;
window_actor = meta_window_actor_from_window (get_window (window_src));
if (!window_actor)
return;
window_src->window_actor = window_actor;
window_src->actor_painted_handler_id =
g_signal_connect_after (window_src->window_actor,
"paint",
G_CALLBACK (window_actor_painted),
window_src);
window_src->actor_destroyed_handler_id =
g_signal_connect (window_src->window_actor,
"destroy",
G_CALLBACK (window_actor_destroyed),
window_src);
}
static void
meta_screen_cast_window_stream_src_disable (MetaScreenCastStreamSrc *src)
{
MetaScreenCastWindowStreamSrc *window_src =
META_SCREEN_CAST_WINDOW_STREAM_SRC (src);
meta_screen_cast_window_stream_src_stop (window_src);
}
static void
meta_screen_cast_window_stream_src_record_frame (MetaScreenCastStreamSrc *src,
uint8_t *data)
{
MetaScreenCastWindowStreamSrc *window_src =
META_SCREEN_CAST_WINDOW_STREAM_SRC (src);
capture_into (window_src, data);
}
MetaScreenCastWindowStreamSrc *
meta_screen_cast_window_stream_src_new (MetaScreenCastWindowStream *window_stream,
GError **error)
{
return g_initable_new (META_TYPE_SCREEN_CAST_WINDOW_STREAM_SRC, NULL, error,
"stream", window_stream,
NULL);
}
static void
meta_screen_cast_window_stream_src_init (MetaScreenCastWindowStreamSrc *window_src)
{
}
static void
meta_screen_cast_window_stream_src_class_init (MetaScreenCastWindowStreamSrcClass *klass)
{
MetaScreenCastStreamSrcClass *src_class =
META_SCREEN_CAST_STREAM_SRC_CLASS (klass);
src_class->get_specs = meta_screen_cast_window_stream_src_get_specs;
src_class->enable = meta_screen_cast_window_stream_src_enable;
src_class->disable = meta_screen_cast_window_stream_src_disable;
src_class->record_frame = meta_screen_cast_window_stream_src_record_frame;
src_class->get_videocrop = meta_screen_cast_window_stream_src_get_videocrop;
}

37
src/backends/meta-screen-cast-window-stream-src.h Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (C) 2018 Red Hat Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
*/
#ifndef META_SCREEN_CAST_WINDOW_STREAM_SRC_H
#define META_SCREEN_CAST_WINDOW_STREAM_SRC_H
#include "backends/meta-screen-cast-stream-src.h"
typedef struct _MetaScreenCastWindowStream MetaScreenCastWindowStream;
#define META_TYPE_SCREEN_CAST_WINDOW_STREAM_SRC (meta_screen_cast_window_stream_src_get_type ())
G_DECLARE_FINAL_TYPE (MetaScreenCastWindowStreamSrc,
meta_screen_cast_window_stream_src,
META, SCREEN_CAST_WINDOW_STREAM_SRC,
MetaScreenCastStreamSrc)
MetaScreenCastWindowStreamSrc * meta_screen_cast_window_stream_src_new (MetaScreenCastWindowStream *window_stream,
GError **error);
#endif /* META_SCREEN_CAST_WINDOW_STREAM_SRC_H */

270
src/backends/meta-screen-cast-window-stream.c Normal file
View File

@ -0,0 +1,270 @@
/*
* Copyright (C) 2018 Red Hat Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
*/
#include "config.h"
#include "backends/meta-screen-cast-window-stream.h"
#include "backends/meta-logical-monitor.h"
#include "backends/meta-monitor-manager-private.h"
#include "backends/meta-screen-cast-window.h"
#include "backends/meta-screen-cast-window-stream-src.h"
#include "compositor/meta-window-actor-private.h"
#include "core/window-private.h"
enum
{
PROP_0,
PROP_WINDOW,
};
struct _MetaScreenCastWindowStream
{
MetaScreenCastStream parent;
MetaWindow *window;
int stream_width;
int stream_height;
unsigned long window_unmanaged_handler_id;
};
G_DEFINE_TYPE (MetaScreenCastWindowStream,
meta_screen_cast_window_stream,
META_TYPE_SCREEN_CAST_STREAM)
MetaWindow *
meta_screen_cast_window_stream_get_window (MetaScreenCastWindowStream *window_stream)
{
return window_stream->window;
}
int
meta_screen_cast_window_stream_get_width (MetaScreenCastWindowStream *window_stream)
{
return window_stream->stream_width;
}
int
meta_screen_cast_window_stream_get_height (MetaScreenCastWindowStream *window_stream)
{
return window_stream->stream_height;
}
MetaScreenCastWindowStream *
meta_screen_cast_window_stream_new (GDBusConnection *connection,
MetaWindow *window,
GError **error)
{
MetaScreenCastWindowStream *window_stream;
MetaLogicalMonitor *logical_monitor;
int scale;
logical_monitor = meta_window_get_main_logical_monitor (window);
if (!logical_monitor)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Main logical monitor not found");
return NULL;
}
window_stream = g_initable_new (META_TYPE_SCREEN_CAST_WINDOW_STREAM,
NULL,
error,
"connection", connection,
"window", window,
NULL);
if (!window_stream)
return NULL;
window_stream->window = window;
/* We cannot set the stream size to the exact size of the window, because
* windows can be resized, whereas streams cannot.
* So we set a size equals to the size of the logical monitor for the window.
*/
scale = (int) ceil (meta_logical_monitor_get_scale (logical_monitor));
window_stream->stream_width = logical_monitor->rect.width * scale;
window_stream->stream_height = logical_monitor->rect.height * scale;
return window_stream;
}
static MetaScreenCastStreamSrc *
meta_screen_cast_window_stream_create_src (MetaScreenCastStream *stream,
GError **error)
{
MetaScreenCastWindowStream *window_stream =
META_SCREEN_CAST_WINDOW_STREAM (stream);
MetaScreenCastWindowStreamSrc *window_stream_src;
window_stream_src = meta_screen_cast_window_stream_src_new (window_stream,
error);
if (!window_stream_src)
return NULL;
return META_SCREEN_CAST_STREAM_SRC (window_stream_src);
}
static void
meta_screen_cast_window_stream_set_parameters (MetaScreenCastStream *stream,
GVariantBuilder *parameters_builder)
{
MetaScreenCastWindowStream *window_stream =
META_SCREEN_CAST_WINDOW_STREAM (stream);
MetaScreenCastWindow *screen_cast_window =
META_SCREEN_CAST_WINDOW (meta_window_actor_from_window (window_stream->window));
MetaRectangle bounds;
meta_screen_cast_window_get_buffer_bounds (screen_cast_window, &bounds);
g_variant_builder_add (parameters_builder, "{sv}",
"position",
g_variant_new ("(ii)",
bounds.x, bounds.y));
g_variant_builder_add (parameters_builder, "{sv}",
"size",
g_variant_new ("(ii)",
bounds.width,
bounds.height));
}
static void
meta_screen_cast_window_stream_transform_position (MetaScreenCastStream *stream,
double stream_x,
double stream_y,
double *x,
double *y)
{
MetaScreenCastWindowStream *window_stream =
META_SCREEN_CAST_WINDOW_STREAM (stream);
MetaScreenCastWindow *screen_cast_window =
META_SCREEN_CAST_WINDOW (meta_window_actor_from_window (window_stream->window));
meta_screen_cast_window_transform_relative_position (screen_cast_window,
stream_x,
stream_y,
x,
y);
}
static void
on_window_unmanaged (MetaScreenCastWindowStream *window_stream)
{
meta_screen_cast_stream_close (META_SCREEN_CAST_STREAM (window_stream));
}
static void
meta_screen_cast_window_stream_constructed (GObject *object)
{
MetaScreenCastWindowStream *window_stream =
META_SCREEN_CAST_WINDOW_STREAM (object);
window_stream->window_unmanaged_handler_id =
g_signal_connect_swapped (window_stream->window, "unmanaged",
G_CALLBACK (on_window_unmanaged),
window_stream);
G_OBJECT_CLASS (meta_screen_cast_window_stream_parent_class)->constructed (object);
}
static void
meta_screen_cast_window_stream_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MetaScreenCastWindowStream *window_stream =
META_SCREEN_CAST_WINDOW_STREAM (object);
switch (prop_id)
{
case PROP_WINDOW:
window_stream->window = g_value_get_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
meta_screen_cast_window_stream_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MetaScreenCastWindowStream *window_stream =
META_SCREEN_CAST_WINDOW_STREAM (object);
switch (prop_id)
{
case PROP_WINDOW:
g_value_set_object (value, window_stream->window);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
meta_screen_cast_window_stream_finalize (GObject *object)
{
MetaScreenCastWindowStream *window_stream =
META_SCREEN_CAST_WINDOW_STREAM (object);
g_signal_handler_disconnect (window_stream->window,
window_stream->window_unmanaged_handler_id);
G_OBJECT_CLASS (meta_screen_cast_window_stream_parent_class)->finalize (object);
}
static void
meta_screen_cast_window_stream_init (MetaScreenCastWindowStream *window_stream)
{
}
static void
meta_screen_cast_window_stream_class_init (MetaScreenCastWindowStreamClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
MetaScreenCastStreamClass *stream_class =
META_SCREEN_CAST_STREAM_CLASS (klass);
object_class->constructed = meta_screen_cast_window_stream_constructed;
object_class->set_property = meta_screen_cast_window_stream_set_property;
object_class->get_property = meta_screen_cast_window_stream_get_property;
object_class->finalize = meta_screen_cast_window_stream_finalize;
stream_class->create_src = meta_screen_cast_window_stream_create_src;
stream_class->set_parameters = meta_screen_cast_window_stream_set_parameters;
stream_class->transform_position = meta_screen_cast_window_stream_transform_position;
g_object_class_install_property (object_class,
PROP_WINDOW,
g_param_spec_object ("window",
"window",
"MetaWindow",
META_TYPE_WINDOW,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
}

43
src/backends/meta-screen-cast-window-stream.h Normal file
View File

@ -0,0 +1,43 @@
/*
* Copyright (C) 2018 Red Hat Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
*/
#ifndef META_SCREEN_CAST_WINDOW_STREAM_H
#define META_SCREEN_CAST_WINDOW_STREAM_H
#include <glib-object.h>
#include "backends/meta-screen-cast-stream.h"
#include "meta/window.h"
#define META_TYPE_SCREEN_CAST_WINDOW_STREAM (meta_screen_cast_window_stream_get_type ())
G_DECLARE_FINAL_TYPE (MetaScreenCastWindowStream,
meta_screen_cast_window_stream,
META, SCREEN_CAST_WINDOW_STREAM,
MetaScreenCastStream)
MetaScreenCastWindowStream * meta_screen_cast_window_stream_new (GDBusConnection *connection,
MetaWindow *window,
GError **error);
MetaWindow * meta_screen_cast_window_stream_get_window (MetaScreenCastWindowStream *window_stream);
int meta_screen_cast_window_stream_get_width (MetaScreenCastWindowStream *window_stream);
int meta_screen_cast_window_stream_get_height (MetaScreenCastWindowStream *window_stream);
#endif /* META_SCREEN_CAST_WINDOW_STREAM_H */