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); }