static gint64
xmms_gvfs_seek (xmms_xform_t *xform, gint64 offset,
xmms_xform_seek_mode_t whence, xmms_error_t *error)
{
GSeekType type;
GError *err = NULL;
xmms_gvfs_data_t *data = xmms_xform_private_data_get (xform);
g_return_val_if_fail (data, -1);
g_return_val_if_fail (!g_input_stream_is_closed (data->handle), -1);
switch (whence) {
case XMMS_XFORM_SEEK_CUR:
type = G_SEEK_CUR;
break;
case XMMS_XFORM_SEEK_SET:
type = G_SEEK_SET;
break;
case XMMS_XFORM_SEEK_END:
type = G_SEEK_END;
break;
}
if (g_seekable_seek (G_SEEKABLE (data->handle), offset, type, NULL, &err)) {
return g_seekable_tell (G_SEEKABLE (data->handle));
}
xmms_error_set (error, XMMS_ERROR_GENERIC, err->message);
return -1;
}
static gboolean
try_seek_on_read (GVfsBackend *backend,
GVfsJobSeekRead *job,
GVfsBackendHandle handle,
goffset offset,
GSeekType type)
{
GInputStream *stream;
GError *error = NULL;
stream = G_INPUT_STREAM (handle);
if (!g_seekable_seek (G_SEEKABLE (stream), offset, type,
G_VFS_JOB (job)->cancellable, &error))
{
g_vfs_job_failed_literal (G_VFS_JOB (job),
error->domain,
error->code,
error->message);
g_error_free (error);
return FALSE;
}
else
{
g_vfs_job_seek_read_set_offset (job, g_seekable_tell (G_SEEKABLE (stream)));
g_vfs_job_succeeded (G_VFS_JOB (job));
}
return TRUE;
}
static void
extract_gibest_hash (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GFile *file = source_object;
guint64 buffer[2][CHUNK_N_BYTES/8];
GInputStream *stream = NULL;
gssize n_bytes, file_size;
GError *error = NULL;
guint64 hash = 0;
gint i;
char *str;
ResolveData *resolve_data = task_data;
GrlLocalMetadataSourcePriv *priv;
priv = GRL_LOCAL_METADATA_SOURCE_GET_PRIVATE (resolve_data->source);
stream = G_INPUT_STREAM (g_file_read (file, cancellable, &error));
if (stream == NULL)
goto fail;
/* Extract start/end chunks of the file */
n_bytes = g_input_stream_read (stream, buffer[0], CHUNK_N_BYTES, cancellable, &error);
if (n_bytes == -1)
goto fail;
if (!g_seekable_seek (G_SEEKABLE (stream), -CHUNK_N_BYTES, G_SEEK_END, cancellable, &error))
goto fail;
n_bytes = g_input_stream_read (stream, buffer[1], CHUNK_N_BYTES, cancellable, &error);
if (n_bytes == -1)
goto fail;
for (i = 0; i < G_N_ELEMENTS (buffer[0]); i++)
hash += buffer[0][i] + buffer[1][i];
file_size = g_seekable_tell (G_SEEKABLE (stream));
if (file_size < CHUNK_N_BYTES)
goto fail;
/* Include file size */
hash += file_size;
g_object_unref (stream);
str = g_strdup_printf ("%" G_GINT64_FORMAT, hash);
grl_data_set_string (GRL_DATA (resolve_data->rs->media), priv->hash_keyid, str);
g_free (str);
g_task_return_boolean (task, TRUE);
return;
fail:
GRL_DEBUG ("Could not get file hash: %s\n", error ? error->message : "Unknown error");
g_task_return_error (task, error);
g_clear_object (&stream);
}
static void
ddb_gvfs_rewind (DB_FILE *stream)
{
vfs_gvfs_data_t *data = (vfs_gvfs_data_t *) stream;
g_return_if_fail (data != NULL);
if (g_seekable_can_seek (G_SEEKABLE (data->handle)))
g_seekable_seek (G_SEEKABLE (data->handle), 0, G_SEEK_SET, NULL, NULL);
}
gint
test_message_compare (CamelMimeMessage *msg)
{
CamelMimeMessage *msg2;
CamelStream *stream1;
CamelStream *stream2;
GByteArray *byte_array1;
GByteArray *byte_array2;
byte_array1 = g_byte_array_new ();
stream1 = camel_stream_mem_new_with_byte_array (byte_array1);
check_msg (camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (msg), stream1, NULL, NULL) != -1,
"write_to_stream 1 failed", NULL);
g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL);
msg2 = camel_mime_message_new ();
check_msg (camel_data_wrapper_construct_from_stream_sync (
CAMEL_DATA_WRAPPER (msg2), stream1, NULL, NULL) != -1,
"construct_from_stream 1 failed");
g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL);
byte_array2 = g_byte_array_new ();
stream2 = camel_stream_mem_new_with_byte_array (byte_array2);
check_msg (camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (msg2), stream2, NULL, NULL) != -1,
"write_to_stream 2 failed");
g_seekable_seek (G_SEEKABLE (stream2), 0, G_SEEK_SET, NULL, NULL);
if (byte_array1->len != byte_array2->len) {
CamelDataWrapper *content;
printf ("stream1 stream:\n%.*s\n", byte_array1->len, byte_array1->data);
printf ("stream2 stream:\n%.*s\n\n", byte_array2->len, byte_array2->data);
printf ("msg1:\n");
test_message_dump_structure (msg);
printf ("msg2:\n");
test_message_dump_structure (msg2);
content = camel_medium_get_content ((CamelMedium *) msg);
}
check_unref (msg2, 1);
check_msg (
byte_array1->len == byte_array2->len,
"byte_array1->len = %d, byte_array2->len = %d",
byte_array1->len, byte_array2->len);
check_msg (memcmp (byte_array1->data, byte_array2->data, byte_array1->len) == 0, "msg/stream compare");
g_object_unref (stream1);
g_object_unref (stream2);
return 0;
}
/* Called from gpgme to seek a file */
static off_t
vfs_data_seek (void *handle, off_t offset, int whence)
{
VfsAsyncHandle* ah = (VfsAsyncHandle*)handle;
GSeekable *seekable = NULL;
GSeekType wh;
/* If the file isn't open yet, then do that now */
if (!ah->ostream && !ah->istream && ah->state == VFS_ASYNC_READY)
vfs_data_open_helper (ah);
/* Just in case we have an operation, like open */
if (!vfs_data_wait_results(ah, TRUE))
return (off_t)-1;
g_assert (ah->state == VFS_ASYNC_READY);
if (ah->writer && G_IS_SEEKABLE (ah->ostream))
seekable = G_SEEKABLE (ah->ostream);
else
seekable = G_SEEKABLE (ah->istream);
if (!seekable || !g_seekable_can_seek (seekable)) {
errno = ENOTSUP;
return -1;
}
switch(whence)
{
case SEEK_SET:
wh = G_SEEK_SET;
break;
case SEEK_CUR:
wh = G_SEEK_CUR;
break;
case SEEK_END:
wh = G_SEEK_END;
break;
default:
g_assert_not_reached();
break;
}
/* All seek operations are not async */
g_clear_error (&ah->error);
g_seekable_seek (seekable, (goffset)offset, wh, ah->cancellable, &ah->error);
/* Start async operation */
ah->state = VFS_ASYNC_READY;
if (!vfs_data_wait_results (ah, TRUE))
return -1;
/* Return results */
ah->state = VFS_ASYNC_READY;
return offset;
}
static toff_t
seek_in_stream(thandle_t handle,
toff_t offset,
int whence)
{
Priv *p = (Priv*) handle;
GError *error = NULL;
gboolean sought = FALSE;
goffset position = -1;
g_assert(p->stream);
if (p->can_seek)
{
sought = g_seekable_seek(G_SEEKABLE(p->stream),
(goffset) offset, lseek_to_seek_type(whence),
NULL, &error);
if (sought)
position = g_seekable_tell(G_SEEKABLE(p->stream));
else
{
g_warning("%s", error->message);
g_error_free(error);
}
}
else
{
switch (whence)
{
default:
case SEEK_SET:
if (offset <= p->allocated)
position = p->position = offset;
break;
case SEEK_CUR:
if (p->position + offset <= p->allocated)
position = p->position += offset;
break;
case G_SEEK_END:
position = p->position = p->allocated + offset;
break;
}
}
return (toff_t) position;
}
/**
* seahorse_util_read_to_memory:
* @input: Data to read. The #GInputStream is read till the end.
* @len: Length of the data read (out)
*
* Reads data from the input stream and returns them as #guchar
*
* Returns: The string read from data. The returned string should be freed
* with #g_free when no longer needed.
**/
guchar*
seahorse_util_read_to_memory (GInputStream *input, guint *len)
{
gsize size = 128;
gchar *buffer, *text;
gsize nread = 0;
GString *string;
GSeekable *seek;
if (G_IS_SEEKABLE (input)) {
seek = G_SEEKABLE (input);
g_seekable_seek (seek, 0, SEEK_SET, NULL, NULL);
}
string = g_string_new ("");
buffer = g_new (gchar, size);
while (g_input_stream_read_all (input, buffer, size, &nread, NULL, NULL)) {
string = g_string_append_len (string, buffer, nread);
if (nread != size)
break;
}
if (len)
*len = string->len;
text = g_string_free (string, FALSE);
g_free (buffer);
return (guchar*)text;
}
static void
cache_replace_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GFileOutputStream *cache_stream;
GError *error = NULL;
NemoPreviewCoverArtFetcher *self = user_data;
cache_stream = g_file_replace_finish (G_FILE (source),
res, &error);
if (error != NULL) {
g_warning ("Can't save the cover art image in the cache: %s\n", error->message);
g_error_free (error);
return;
}
g_seekable_seek (G_SEEKABLE (self->priv->input_stream), 0, G_SEEK_SET,
NULL, NULL);
g_output_stream_splice_async (G_OUTPUT_STREAM (cache_stream),
self->priv->input_stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT,
NULL,
cache_splice_ready_cb, self);
g_object_unref (cache_stream);
}
static gboolean
gegl_tile_backend_file_write_header (GeglTileBackendFile *self)
{
gboolean success;
gegl_tile_backend_file_ensure_exist (self);
#if HAVE_GIO
success = g_seekable_seek (G_SEEKABLE (self->o), 0, G_SEEK_SET,
NULL, NULL);
#else
success = (lseek (self->o, 0, SEEK_SET) != -1);
#endif
if (success == FALSE)
{
g_warning ("unable to seek in buffer");
return FALSE;
}
#if HAVE_GIO
g_output_stream_write (self->o, &(self->header), 256, NULL, NULL);
#else
write (self->o, &(self->header), 256);
#endif
GEGL_NOTE (GEGL_DEBUG_TILE_BACKEND, "Wrote header, next=%i", (gint)self->header.next);
return TRUE;
}
static gboolean
gimp_curves_tool_settings_import (GimpImageMapTool *image_map_tool,
GInputStream *input,
GError **error)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool);
gchar header[64];
gsize bytes_read;
if (! g_input_stream_read_all (input, header, sizeof (header),
&bytes_read, NULL, error) ||
bytes_read != sizeof (header))
{
g_prefix_error (error, _("Could not read header: "));
return FALSE;
}
g_seekable_seek (G_SEEKABLE (input), 0, G_SEEK_SET, NULL, NULL);
if (g_str_has_prefix (header, "# GIMP Curves File\n"))
return gimp_curves_config_load_cruft (tool->config, input, error);
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_import (image_map_tool,
input,
error);
}
/*
* et_ogg_tell_func:
* @datasource: the Ogg parser state
*
* Tell the current position of the stream from the beginning of the Ogg file.
*
* Returns: the current position in the Ogg file
*/
static long
et_ogg_tell_func (void *datasource)
{
EtOggState *state = (EtOggState *)datasource;
return g_seekable_tell (G_SEEKABLE (state->istream));
}
static gboolean
gst_gio_base_sink_event (GstBaseSink * base_sink, GstEvent * event)
{
GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);
GstFlowReturn ret = GST_FLOW_OK;
if (sink->stream == NULL)
return TRUE;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEGMENT:
if (G_IS_OUTPUT_STREAM (sink->stream)) {
const GstSegment *segment;
gst_event_parse_segment (event, &segment);
if (segment->format != GST_FORMAT_BYTES) {
GST_WARNING_OBJECT (sink, "ignored SEGMENT event in %s format",
gst_format_get_name (segment->format));
break;
}
if (GST_GIO_STREAM_IS_SEEKABLE (sink->stream)) {
ret = gst_gio_seek (sink, G_SEEKABLE (sink->stream), segment->start,
sink->cancel);
if (ret == GST_FLOW_OK)
sink->position = segment->start;
} else {
ret = GST_FLOW_NOT_SUPPORTED;
}
}
break;
case GST_EVENT_EOS:
case GST_EVENT_FLUSH_START:
if (G_IS_OUTPUT_STREAM (sink->stream)) {
gboolean success;
GError *err = NULL;
success = g_output_stream_flush (sink->stream, sink->cancel, &err);
if (!success && !gst_gio_error (sink, "g_output_stream_flush", &err,
&ret)) {
GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (NULL),
("flush failed: %s", err->message));
g_clear_error (&err);
}
}
break;
default:
break;
}
if (ret == GST_FLOW_OK)
return GST_BASE_SINK_CLASS (parent_class)->event (base_sink, event);
else {
gst_event_unref (event);
return FALSE;
}
}
static void on_file_read_ready (GObject * object, GAsyncResult * res, gpointer data)
{
GError *error = NULL;
GDownloadable *download = G_DOWNLOADABLE (data);
GioDownload *gio_download = GIO_DOWNLOAD (data);
g_assert (download != NULL);
gio_download->priv->input = g_file_read_finish (G_FILE(object), res, &error);
handle_critical_error (error);
if (gio_download->priv->input == NULL) {
// TODO: Error details
g_downloadable_set_status (download, G_DOWNLOADABLE_NETWORK_ERROR);
} else {
if (g_seekable_can_seek(G_SEEKABLE(gio_download->priv->input))
&& g_file_query_exists (download->priv->local_file, NULL)) {
//g_message ("appeding file ...\n");
g_file_append_to_async (download->priv->local_file, 0,G_PRIORITY_DEFAULT,
NULL, on_file_append_to_ready, download);
} else {
//g_message ("replacing file ...\n");
g_file_replace_async (download->priv->local_file, NULL, FALSE, 0, G_PRIORITY_DEFAULT,
NULL, on_file_replace_ready, download);
}
g_downloadable_set_status (download, G_DOWNLOADABLE_DOWNLOADING);
}
}
static gboolean
gst_gio_base_src_start (GstBaseSrc * base_src)
{
GstGioBaseSrc *src = GST_GIO_BASE_SRC (base_src);
GstGioBaseSrcClass *gbsrc_class = GST_GIO_BASE_SRC_GET_CLASS (src);
src->position = 0;
/* FIXME: This will likely block */
src->stream = gbsrc_class->get_stream (src);
if (G_UNLIKELY (!G_IS_INPUT_STREAM (src->stream))) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL),
("No input stream provided by subclass"));
return FALSE;
} else if (G_UNLIKELY (g_input_stream_is_closed (src->stream))) {
GST_ELEMENT_ERROR (src, LIBRARY, FAILED, (NULL),
("Input stream is already closed"));
return FALSE;
}
if (G_IS_SEEKABLE (src->stream))
src->position = g_seekable_tell (G_SEEKABLE (src->stream));
GST_DEBUG_OBJECT (src, "started source");
return TRUE;
}
static unsigned long
vfs_stream_read (FT_Stream stream,
unsigned long offset,
unsigned char *buffer,
unsigned long count)
{
GFileInputStream *handle = stream->descriptor.pointer;
gssize bytes_read = 0;
if (!count && offset > stream->size)
return 1;
if (!g_seekable_seek (G_SEEKABLE (handle), offset, G_SEEK_SET, NULL, NULL))
return (count ? 0 : 1);
if (count > 0) {
bytes_read = g_input_stream_read (G_INPUT_STREAM (handle), buffer,
count, NULL, NULL);
if (bytes_read == -1)
return 0;
}
return bytes_read;
}
/**
* seahorse_util_memory_output_length:
* @output: a stream
*
* A replacement for #g_memory_output_stream_get_data_size (since 2.18)
*
* Returns: The length of the stream
*/
gsize
seahorse_util_memory_output_length (GMemoryOutputStream *output)
{
GSeekable *seekable;
goffset offset, end;
/*
* This is a replacement for g_memory_output_stream_get_data_size()
* which is not available in current version of glib.
*/
g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (output), 0);
g_return_val_if_fail (G_IS_SEEKABLE (output), 0);
seekable = G_SEEKABLE (output);
offset = g_seekable_tell (seekable);
if (!g_seekable_seek (seekable, 0, G_SEEK_END, NULL, NULL))
g_return_val_if_reached (0);
end = g_seekable_tell (seekable);
if (offset != end) {
if (!g_seekable_seek (seekable, offset, G_SEEK_SET, NULL, NULL))
g_return_val_if_reached (0);
}
return (gsize)end;
}
static gboolean
g_resource_file_input_stream_can_seek (GFileInputStream *stream)
{
GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);
return G_IS_SEEKABLE (file->stream) && g_seekable_can_seek (G_SEEKABLE (file->stream));
}
static gboolean
can_seek (GInputStream *stream)
{
if (!G_IS_SEEKABLE (stream))
return FALSE;
return g_seekable_can_seek (G_SEEKABLE (stream));
}
gint main (gint argc, gchar **argv)
{
struct dirent *dent;
DIR *dir;
gint fd;
camel_test_init (argc, argv);
camel_test_start ("Message Test Suite");
if (!(dir = opendir ("../data/messages")))
return 77;
while ((dent = readdir (dir)) != NULL) {
CamelMimeMessage *message;
CamelStream *stream;
gchar *filename;
struct stat st;
if (dent->d_name[0] == '.')
continue;
filename = g_strdup_printf ("../data/messages/%s", dent->d_name);
if (g_stat (filename, &st) == -1 || !S_ISREG (st.st_mode)) {
g_free (filename);
continue;
}
if ((fd = open (filename, O_RDONLY)) == -1) {
g_free (filename);
continue;
}
push ("testing message '%s'", filename);
g_free (filename);
stream = camel_stream_fs_new_with_fd (fd);
message = camel_mime_message_new ();
camel_data_wrapper_construct_from_stream_sync (
CAMEL_DATA_WRAPPER (message), stream, NULL, NULL);
g_seekable_seek (
G_SEEKABLE (stream), 0, G_SEEK_SET, NULL, NULL);
/*dump_mime_struct ((CamelMimePart *) message, 0);*/
test_message_compare (message);
g_object_unref (message);
g_object_unref (stream);
pull ();
}
closedir (dir);
camel_test_end ();
return 0;
}
static gboolean
process(GeglOperation *operation,
GeglBuffer *input,
const GeglRectangle *result,
int level)
{
GeglProperties *o = GEGL_PROPERTIES(operation);
Priv *p = g_new0(Priv, 1);
gboolean status = TRUE;
GError *error = NULL;
g_assert(p != NULL);
o->user_data = (void*) p;
p->stream = gegl_gio_open_output_stream(NULL, o->path, &p->file, &error);
if (p->stream != NULL && p->file != NULL)
p->can_seek = g_seekable_can_seek(G_SEEKABLE(p->stream));
if (p->stream == NULL)
{
status = FALSE;
g_warning("%s", error->message);
goto cleanup;
}
TIFFSetErrorHandler(error_handler);
TIFFSetWarningHandler(warning_handler);
p->tiff = TIFFClientOpen("GEGL-tiff-save", "w", (thandle_t) p,
read_from_stream, write_to_stream,
seek_in_stream, close_stream,
get_file_size, NULL, NULL);
if (p->tiff == NULL)
{
status = FALSE;
g_warning("failed to open TIFF from %s", o->path);
goto cleanup;
}
if (export_tiff(operation, input, result))
{
status = FALSE;
g_warning("could not export TIFF file");
goto cleanup;
}
cleanup:
cleanup(operation);
if (o->user_data != NULL)
g_free(o->user_data);
o->user_data = NULL;
if (error != NULL)
g_error_free(error);
return status;
}
static goffset
g_resource_file_input_stream_tell (GFileInputStream *stream)
{
GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);;
if (!G_IS_SEEKABLE (file->stream));
return 0;
return g_seekable_tell (G_SEEKABLE (file->stream));
}
static int64_t
ddb_gvfs_tell (DB_FILE *stream)
{
vfs_gvfs_data_t *data = (vfs_gvfs_data_t *) stream;
g_return_val_if_fail (data != NULL, -1);
g_return_val_if_fail (! g_input_stream_is_closed (data->handle), -1);
return g_seekable_tell (G_SEEKABLE (data->handle));
}
static guint64 get_code( GbdEmitter* _self,gchar* key ) {
GbdX11emitter* const self = GBD_X11EMITTER( _self );
GbdX11emitterPrivate* const priv = self->priv;
if( !priv->srcdata ) {
GFile* file = g_file_new_for_path( GBD_X11EMITTER_SRC );
if( !load_file( self,file,NULL ) ) {
g_critical( "GBoard X11-Emitter could not parse X11 keysymdef.h at " GBD_X11EMITTER_SRC );
return 0;
}
g_object_unref( file );
}
guint64* code,symval = 0;
if( ( code = g_datalist_get_data( &priv->mapcache,key ) ) )
return *code;
else
code = g_malloc( sizeof( guint64 ) );
g_seekable_seek( G_SEEKABLE( priv->srcstream ),0,G_SEEK_SET,NULL,NULL );
GDataInputStream* dis = priv->srcdata;
gchar* line;
gsize len = strlen( key );
gchar* keytoken = g_malloc( sizeof( gchar )*len+sizeof( KEYDEF_PREFIX )+1 );
sprintf( keytoken,KEYDEF_PREFIX "%s",key );
len = strlen( keytoken );
GError* err = NULL;
while( line = g_data_input_stream_read_line( dis,NULL,NULL,&err ) ) {
if( !strncmp( keytoken,line,len )&& g_ascii_isspace( line[ len ] ) ) {
if( sscanf( line+len," %" G_GINT64_MODIFIER "x ",&symval ) ) {
g_free( line );
break;
}
}
g_free( line );
}
if( err ) {
g_error( "%s",err->message );
g_error_unref( &err );
}
if( symval ) {
guint64 codeval = XKeysymToKeycode( priv->dpy,symval );
*code = codeval;
g_datalist_set_data_full( &priv->mapcache,key,code,g_free );
if( !codeval )
g_warning( "Could not find code for key '%s', Keysym-Value " G_GINT64_FORMAT,key,symval );
return codeval;
}
return 0;
}
static gboolean
gsf_input_gio_seek (GsfInput *input, gsf_off_t offset, GSeekType whence)
{
GsfInputGio *gio = GSF_INPUT_GIO (input);
g_return_val_if_fail (gio != NULL, TRUE);
g_return_val_if_fail (gio->stream != NULL, TRUE);
g_return_val_if_fail (can_seek (gio->stream), TRUE);
return (g_seekable_seek (G_SEEKABLE (gio->stream), offset, whence, NULL, NULL) ? FALSE : TRUE);
}
arrow::Status Tell(int64_t *position) const override {
if (!G_IS_SEEKABLE(output_stream_)) {
std::string message("[gio-output-stream][tell] "
"not seekable output stream: <");
message += G_OBJECT_CLASS_NAME(G_OBJECT_GET_CLASS(output_stream_));
message += ">";
return arrow::Status::NotImplemented(message);
}
*position = g_seekable_tell(G_SEEKABLE(output_stream_));
return arrow::Status::OK();
}
/*
* et_ogg_seek_func:
* @datasource: the Ogg parser state
* @offset: the number of bytes to seek
* @whence: either %SEEK_SET, %SEEK_CUR or %SEEK_END
*
* Seek in the currently-open Ogg file.
*
* Returns: 0 on success, -1 and sets errno on error
*/
static int
et_ogg_seek_func (void *datasource, ogg_int64_t offset, int whence)
{
EtOggState *state = (EtOggState *)datasource;
GSeekType seektype;
if (!g_seekable_can_seek (G_SEEKABLE (state->istream)))
{
return -1;
}
else
{
switch (whence)
{
case SEEK_SET:
seektype = G_SEEK_SET;
break;
case SEEK_CUR:
seektype = G_SEEK_CUR;
break;
case SEEK_END:
seektype = G_SEEK_END;
break;
default:
errno = EINVAL;
return -1;
}
if (g_seekable_seek (G_SEEKABLE (state->istream), offset, seektype,
NULL, &state->error))
{
return 0;
}
else
{
errno = EBADF;
return -1;
}
}
}
static inline void
gegl_tile_backend_file_file_entry_read (GeglTileBackendFile *self,
GeglBufferTile *entry,
guchar *dest)
{
gint to_be_read;
gboolean success;
gint tile_size = gegl_tile_backend_get_tile_size (GEGL_TILE_BACKEND (self));
goffset offset = entry->offset;
gegl_tile_backend_file_ensure_exist (self);
#if HAVE_GIO
success = g_seekable_seek (G_SEEKABLE (self->i),
offset, G_SEEK_SET,
NULL, NULL);
#else
success = (lseek (self->i, offset, SEEK_SET) >= 0);
#endif
if (success == FALSE)
{
g_warning ("unable to seek to tile in buffer: %s", g_strerror (errno));
return;
}
to_be_read = tile_size;
while (to_be_read > 0)
{
gint byte_read;
#if HAVE_GIO
byte_read = g_input_stream_read (G_INPUT_STREAM (self->i),
dest + tile_size - to_be_read, to_be_read,
NULL, NULL);
#else
byte_read = read (self->i, dest + tile_size - to_be_read, to_be_read);
#endif
if (byte_read <= 0)
{
g_message ("unable to read tile data from self: "
"%s (%d/%d bytes read)",
g_strerror (errno), byte_read, to_be_read);
return;
}
to_be_read -= byte_read;
}
GEGL_NOTE (GEGL_DEBUG_TILE_BACKEND, "read entry %i,%i,%i at %i", entry->x, entry->y, entry->z, (gint)offset);
}
static int
ddb_gvfs_seek (DB_FILE *stream, int64_t offset, int whence)
{
vfs_gvfs_data_t *data = (vfs_gvfs_data_t *) stream;
g_return_val_if_fail (data != NULL, -1);
if (!g_seekable_can_seek (G_SEEKABLE (data->handle)))
return -1;
g_return_val_if_fail (! g_input_stream_is_closed (data->handle), -1);
GSeekType seektype;
switch (whence) {
case SEEK_CUR:
seektype = G_SEEK_CUR;
break;
case SEEK_END:
seektype = G_SEEK_END;
break;
default:
seektype = G_SEEK_SET;
break;
}
GError *error = NULL;
if (g_seekable_seek (G_SEEKABLE (data->handle), offset, seektype, NULL, &error))
return 0;
g_warning ("Could not seek: %s", error->message);
g_error_free (error);
return -1;
}
static inline void
gegl_tile_backend_file_file_entry_write (GeglTileBackendFile *self,
GeglBufferTile *entry,
guchar *source)
{
gint to_be_written;
gboolean success;
gint tile_size = gegl_tile_backend_get_tile_size (GEGL_TILE_BACKEND (self));
goffset offset = entry->offset;
gegl_tile_backend_file_ensure_exist (self);
#if HAVE_GIO
success = g_seekable_seek (G_SEEKABLE (self->o),
offset, G_SEEK_SET,
NULL, NULL);
#else
success = (lseek (self->o, offset, SEEK_SET) >= 0);
#endif
if (success == FALSE)
{
g_warning ("unable to seek to tile in buffer: %s", g_strerror (errno));
return;
}
to_be_written = tile_size;
while (to_be_written > 0)
{
gint wrote;
#if HAVE_GIO
wrote = g_output_stream_write (self->o,
source + tile_size - to_be_written,
to_be_written, NULL, NULL);
#else
wrote = write (self->o,
source + tile_size - to_be_written,
to_be_written);
#endif
if (wrote <= 0)
{
g_message ("unable to write tile data to self: "
"%s (%d/%d bytes written)",
g_strerror (errno), wrote, to_be_written);
return;
}
to_be_written -= wrote;
}
GEGL_NOTE (GEGL_DEBUG_TILE_BACKEND, "wrote entry %i,%i,%i at %i", entry->x, entry->y, entry->z, (gint)offset);
}
