gtk/gdk/gdkpipeiostream.c
2020-07-25 00:47:36 +02:00

475 lines
13 KiB
C

/* GDK - The GIMP Drawing Kit
*
* Copyright (C) 2017 Benjamin Otte <otte@gnome.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkpipeiostreamprivate.h"
#include <string.h>
/* PIPE */
typedef enum {
GDK_IO_PIPE_EMPTY,
GDK_IO_PIPE_INPUT_BUFFER,
GDK_IO_PIPE_OUTPUT_BUFFER
} GdkIOPipeState;
typedef struct _GdkIOPipe GdkIOPipe;
struct _GdkIOPipe
{
int ref_count;
GMutex mutex;
GCond cond;
guchar *buffer;
gsize size;
GdkIOPipeState state : 2;
guint input_closed : 1;
guint output_closed : 1;
};
static GdkIOPipe *
gdk_io_pipe_new (void)
{
GdkIOPipe *pipe;
pipe = g_slice_new0 (GdkIOPipe);
pipe->ref_count = 1;
g_mutex_init (&pipe->mutex);
g_cond_init (&pipe->cond);
return pipe;
}
static GdkIOPipe *
gdk_io_pipe_ref (GdkIOPipe *pipe)
{
g_atomic_int_inc (&pipe->ref_count);
return pipe;
}
static void
gdk_io_pipe_unref (GdkIOPipe *pipe)
{
if (!g_atomic_int_dec_and_test (&pipe->ref_count))
return;
g_cond_clear (&pipe->cond);
g_mutex_clear (&pipe->mutex);
}
static void
gdk_io_pipe_lock (GdkIOPipe *pipe)
{
g_mutex_lock (&pipe->mutex);
}
static void
gdk_io_pipe_unlock (GdkIOPipe *pipe)
{
g_mutex_unlock (&pipe->mutex);
}
/* INPUT STREAM */
#define GDK_TYPE_PIPE_INPUT_STREAM (gdk_pipe_input_stream_get_type ())
#define GDK_PIPE_INPUT_STREAM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_PIPE_INPUT_STREAM, GdkPipeInputStream))
#define GDK_IS_PIPE_INPUT_STREAM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_PIPE_INPUT_STREAM))
#define GDK_PIPE_INPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIPE_INPUT_STREAM, GdkPipeInputStreamClass))
#define GDK_IS_PIPE_INPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIPE_INPUT_STREAM))
#define GDK_PIPE_INPUT_STREAM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIPE_INPUT_STREAM, GdkPipeInputStreamClass))
typedef struct _GdkPipeInputStream GdkPipeInputStream;
typedef struct _GdkPipeInputStreamClass GdkPipeInputStreamClass;
struct _GdkPipeInputStream
{
GInputStream parent;
GdkIOPipe *pipe;
};
struct _GdkPipeInputStreamClass
{
GInputStreamClass parent_class;
};
GType gdk_pipe_input_stream_get_type (void) G_GNUC_CONST;
G_DEFINE_TYPE (GdkPipeInputStream, gdk_pipe_input_stream, G_TYPE_INPUT_STREAM)
static void
gdk_pipe_input_stream_finalize (GObject *object)
{
GdkPipeInputStream *pipe = GDK_PIPE_INPUT_STREAM (object);
g_clear_pointer (&pipe->pipe, gdk_io_pipe_unref);
G_OBJECT_CLASS (gdk_pipe_input_stream_parent_class)->finalize (object);
}
static gssize
gdk_pipe_input_stream_read (GInputStream *stream,
void *buffer,
gsize count,
GCancellable *cancellable,
GError **error)
{
GdkPipeInputStream *pipe_stream = GDK_PIPE_INPUT_STREAM (stream);
GdkIOPipe *pipe = pipe_stream->pipe;
gsize amount;
gdk_io_pipe_lock (pipe);
switch (pipe->state)
{
case GDK_IO_PIPE_EMPTY:
if (pipe->output_closed)
{
amount = 0;
break;
}
pipe->buffer = buffer;
pipe->size = count;
pipe->state = GDK_IO_PIPE_INPUT_BUFFER;
do
g_cond_wait (&pipe->cond, &pipe->mutex);
while (pipe->size == count &&
pipe->state == GDK_IO_PIPE_INPUT_BUFFER &&
!pipe->output_closed);
if (pipe->state == GDK_IO_PIPE_INPUT_BUFFER)
{
amount = count - pipe->size;
pipe->state = GDK_IO_PIPE_EMPTY;
pipe->size = 0;
}
else
{
amount = count;
}
break;
case GDK_IO_PIPE_OUTPUT_BUFFER:
amount = MIN (count, pipe->size);
memcpy (buffer, pipe->buffer, amount);
pipe->size -= amount;
if (pipe->size == 0)
pipe->state = GDK_IO_PIPE_EMPTY;
else
pipe->buffer += amount;
break;
case GDK_IO_PIPE_INPUT_BUFFER:
default:
g_assert_not_reached ();
amount = 0;
break;
}
g_cond_broadcast (&pipe->cond);
gdk_io_pipe_unlock (pipe);
return amount;
}
static gboolean
gdk_pipe_input_stream_close (GInputStream *stream,
GCancellable *cancellable,
GError **error)
{
GdkPipeInputStream *pipe_stream = GDK_PIPE_INPUT_STREAM (stream);
GdkIOPipe *pipe = pipe_stream->pipe;
gdk_io_pipe_lock (pipe);
pipe->input_closed = TRUE;
g_cond_broadcast (&pipe->cond);
gdk_io_pipe_unlock (pipe);
return TRUE;
}
static void
gdk_pipe_input_stream_class_init (GdkPipeInputStreamClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
GInputStreamClass *input_stream_class = G_INPUT_STREAM_CLASS (class);
object_class->finalize = gdk_pipe_input_stream_finalize;
input_stream_class->read_fn = gdk_pipe_input_stream_read;
input_stream_class->close_fn = gdk_pipe_input_stream_close;
}
static void
gdk_pipe_input_stream_init (GdkPipeInputStream *pipe)
{
}
/* OUTPUT STREAM */
#define GDK_TYPE_PIPE_OUTPUT_STREAM (gdk_pipe_output_stream_get_type ())
#define GDK_PIPE_OUTPUT_STREAM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_PIPE_OUTPUT_STREAM, GdkPipeOutputStream))
#define GDK_IS_PIPE_OUTPUT_STREAM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_PIPE_OUTPUT_STREAM))
#define GDK_PIPE_OUTPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIPE_OUTPUT_STREAM, GdkPipeOutputStreamClass))
#define GDK_IS_PIPE_OUTPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIPE_OUTPUT_STREAM))
#define GDK_PIPE_OUTPUT_STREAM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIPE_OUTPUT_STREAM, GdkPipeOutputStreamClass))
typedef struct _GdkPipeOutputStream GdkPipeOutputStream;
typedef struct _GdkPipeOutputStreamClass GdkPipeOutputStreamClass;
struct _GdkPipeOutputStream
{
GOutputStream parent;
GdkIOPipe *pipe;
};
struct _GdkPipeOutputStreamClass
{
GOutputStreamClass parent_class;
};
GType gdk_pipe_output_stream_get_type (void) G_GNUC_CONST;
G_DEFINE_TYPE (GdkPipeOutputStream, gdk_pipe_output_stream, G_TYPE_OUTPUT_STREAM)
static void
gdk_pipe_output_stream_finalize (GObject *object)
{
GdkPipeOutputStream *pipe = GDK_PIPE_OUTPUT_STREAM (object);
g_clear_pointer (&pipe->pipe, gdk_io_pipe_unref);
G_OBJECT_CLASS (gdk_pipe_output_stream_parent_class)->finalize (object);
}
static gssize
gdk_pipe_output_stream_write (GOutputStream *stream,
const void *buffer,
gsize count,
GCancellable *cancellable,
GError **error)
{
GdkPipeOutputStream *pipe_stream = GDK_PIPE_OUTPUT_STREAM (stream);
GdkIOPipe *pipe = pipe_stream->pipe;
gsize amount;
gdk_io_pipe_lock (pipe);
switch (pipe->state)
{
case GDK_IO_PIPE_EMPTY:
pipe->buffer = (void *) buffer;
pipe->size = count;
pipe->state = GDK_IO_PIPE_OUTPUT_BUFFER;
while (pipe->size == count &&
pipe->state == GDK_IO_PIPE_OUTPUT_BUFFER &&
!pipe->input_closed)
g_cond_wait (&pipe->cond, &pipe->mutex);
if (pipe->state == GDK_IO_PIPE_OUTPUT_BUFFER)
{
amount = count - pipe->size;
pipe->state = GDK_IO_PIPE_EMPTY;
pipe->size = 0;
if (pipe->input_closed && amount == 0)
amount = count;
}
else
{
amount = count;
}
break;
case GDK_IO_PIPE_INPUT_BUFFER:
amount = MIN (count, pipe->size);
memcpy (pipe->buffer, buffer, amount);
pipe->size -= amount;
if (pipe->size == 0)
pipe->state = GDK_IO_PIPE_EMPTY;
else
pipe->buffer += amount;
break;
case GDK_IO_PIPE_OUTPUT_BUFFER:
default:
g_assert_not_reached ();
amount = 0;
break;
}
g_cond_broadcast (&pipe->cond);
gdk_io_pipe_unlock (pipe);
return amount;
}
static gboolean
gdk_pipe_output_stream_close (GOutputStream *stream,
GCancellable *cancellable,
GError **error)
{
GdkPipeOutputStream *pipe_stream = GDK_PIPE_OUTPUT_STREAM (stream);
GdkIOPipe *pipe = pipe_stream->pipe;
gdk_io_pipe_lock (pipe);
pipe->output_closed = TRUE;
g_cond_broadcast (&pipe->cond);
gdk_io_pipe_unlock (pipe);
return TRUE;
}
static void
gdk_pipe_output_stream_class_init (GdkPipeOutputStreamClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
GOutputStreamClass *output_stream_class = G_OUTPUT_STREAM_CLASS (class);
object_class->finalize = gdk_pipe_output_stream_finalize;
output_stream_class->write_fn = gdk_pipe_output_stream_write;
output_stream_class->close_fn = gdk_pipe_output_stream_close;
}
static void
gdk_pipe_output_stream_init (GdkPipeOutputStream *pipe)
{
}
/* IOSTREAM */
#define GDK_TYPE_PIPE_IO_STREAM (gdk_pipe_io_stream_get_type ())
#define GDK_PIPE_IO_STREAM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_PIPE_IO_STREAM, GdkPipeIOStream))
#define GDK_IS_PIPE_IO_STREAM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_PIPE_IO_STREAM))
#define GDK_PIPE_IO_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIPE_IO_STREAM, GdkPipeIOStreamClass))
#define GDK_IS_PIPE_IO_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIPE_IO_STREAM))
#define GDK_PIPE_IO_STREAM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIPE_IO_STREAM, GdkPipeIOStreamClass))
typedef struct _GdkPipeIOStream GdkPipeIOStream;
typedef struct _GdkPipeIOStreamClass GdkPipeIOStreamClass;
struct _GdkPipeIOStream
{
GIOStream parent;
GInputStream *input_stream;
GOutputStream *output_stream;
GdkIOPipe *pipe;
};
struct _GdkPipeIOStreamClass
{
GIOStreamClass parent_class;
};
GType gdk_pipe_io_stream_get_type (void) G_GNUC_CONST;
G_DEFINE_TYPE (GdkPipeIOStream, gdk_pipe_io_stream, G_TYPE_IO_STREAM)
static void
gdk_pipe_io_stream_finalize (GObject *object)
{
GdkPipeIOStream *pipe = GDK_PIPE_IO_STREAM (object);
g_clear_object (&pipe->input_stream);
g_clear_object (&pipe->output_stream);
g_clear_pointer (&pipe->pipe, gdk_io_pipe_unref);
G_OBJECT_CLASS (gdk_pipe_io_stream_parent_class)->finalize (object);
}
static GInputStream *
gdk_pipe_io_stream_get_input_stream (GIOStream *stream)
{
GdkPipeIOStream *pipe = GDK_PIPE_IO_STREAM (stream);
return pipe->input_stream;
}
static GOutputStream *
gdk_pipe_io_stream_get_output_stream (GIOStream *stream)
{
GdkPipeIOStream *pipe = GDK_PIPE_IO_STREAM (stream);
return pipe->output_stream;
}
static gboolean
gdk_pipe_io_stream_close (GIOStream *stream,
GCancellable *cancellable,
GError **error)
{
/* overwrite so we don't close the 2 streams */
return TRUE;
}
static void
gdk_pipe_io_stream_class_init (GdkPipeIOStreamClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
GIOStreamClass *io_class = G_IO_STREAM_CLASS (class);
object_class->finalize = gdk_pipe_io_stream_finalize;
io_class->get_input_stream = gdk_pipe_io_stream_get_input_stream;
io_class->get_output_stream = gdk_pipe_io_stream_get_output_stream;
io_class->close_fn = gdk_pipe_io_stream_close;
}
static void
gdk_pipe_io_stream_init (GdkPipeIOStream *pipe)
{
pipe->pipe = gdk_io_pipe_new ();
pipe->input_stream = g_object_new (GDK_TYPE_PIPE_INPUT_STREAM, NULL);
GDK_PIPE_INPUT_STREAM (pipe->input_stream)->pipe = gdk_io_pipe_ref (pipe->pipe);
pipe->output_stream = g_object_new (GDK_TYPE_PIPE_OUTPUT_STREAM, NULL);
GDK_PIPE_OUTPUT_STREAM (pipe->output_stream)->pipe = gdk_io_pipe_ref (pipe->pipe);
}
/**
* gdk_pipe_io_stream_new:
*
* Creates a #GIOStream whose input- and output-stream behave like a pipe.
* Data written into the output stream becomes available for reading on
* the input stream.
*
* Note that this is data transfer in the opposite direction to
* g_output_stream_splice().
*
* Returns: a new #GIOStream
**/
GIOStream *
gdk_pipe_io_stream_new (void)
{
return g_object_new (GDK_TYPE_PIPE_IO_STREAM, NULL);
}