static int write_blank( VipsForeignSaveDz *dz ) { VipsImage *x, *t; int n; VipsArea *ones; double *d; int i; void *buf; size_t len; GsfOutput *out; if( vips_black( &x, dz->tile_size, dz->tile_size, NULL ) ) return( -1 ); vips_area_get_data( (VipsArea *) dz->background, NULL, &n, NULL, NULL ); ones = vips_area_new_array( G_TYPE_DOUBLE, sizeof( double ), n ); d = (double *) vips_area_get_data( ones, NULL, NULL, NULL, NULL ); for( i = 0; i < n; i++ ) d[i] = 1.0; if( vips_linear( x, &t, d, (double *) vips_area_get_data( (VipsArea *) dz->background, NULL, NULL, NULL, NULL ), n, NULL ) ) { vips_area_unref( ones ); g_object_unref( x ); return( -1 ); } vips_area_unref( ones ); g_object_unref( x ); x = t; if( vips_pngsave_buffer( x, &buf, &len, NULL ) ) { g_object_unref( x ); return( -1 ); } g_object_unref( x ); out = vips_gsf_path( dz->tree, "blank.png", NULL ); gsf_output_write( out, len, buf ); gsf_output_close( out ); g_object_unref( out ); g_free( buf ); return( 0 ); }
void VImage::write_to_buffer( const char *suffix, void **buf, size_t *size, VOption *options ) { char filename[VIPS_PATH_MAX]; char option_string[VIPS_PATH_MAX]; const char *operation_name; VipsBlob *blob; vips__filename_split8( suffix, filename, option_string ); if( !(operation_name = vips_foreign_find_save_buffer( filename )) ) { delete options; throw VError(); } call_option_string( operation_name, option_string, (options ? options : VImage::option())-> set( "in", *this )-> set( "buffer", &blob ) ); if( blob ) { if( buf ) { *buf = VIPS_AREA( blob )->data; VIPS_AREA( blob )->free_fn = NULL; } if( size ) *size = VIPS_AREA( blob )->length; vips_area_unref( VIPS_AREA( blob ) ); } }
VImage VImage::new_from_buffer( void *buf, size_t len, const char *option_string, VOption *options ) { const char *operation_name; VipsBlob *blob; VImage out; if( !(operation_name = vips_foreign_find_load_buffer( buf, len )) ) { delete options; throw( VError() ); } /* We don't take a copy of the data or free it. */ blob = vips_blob_new( NULL, buf, len ); options = (options ? options : VImage::option())-> set( "buffer", blob )-> set( "out", &out ); vips_area_unref( VIPS_AREA( blob ) ); call_option_string( operation_name, option_string, options ); return( out ); }
/** * vips_value_set_array: * @value: (out): %GValue to set * @n: number of elements * @type: the type of each element * @sizeof_type: the sizeof each element * * Set @value to be an array of things. * * This allocates memory but does not * initialise the contents: get the pointer and write instead. */ void vips_value_set_array( GValue *value, int n, GType type, size_t sizeof_type ) { VipsArea *area; area = vips_area_new_array( type, sizeof_type, n ); g_value_set_boxed( value, area ); vips_area_unref( area ); }
/** * vips_value_set_area: * @value: (out): set this value * @free_fn: (scope async): data will be freed with this function * @data: set @value to track this pointer * * Set value to be a ref-counted area of memory with a free function. */ void vips_value_set_area( GValue *value, VipsCallbackFn free_fn, void *data ) { VipsArea *area; area = vips_area_new( free_fn, data ); g_value_init( value, VIPS_TYPE_AREA ); g_value_set_boxed( value, area ); vips_area_unref( area ); }
/** * vips_array_object_set: * @value: (out): %GValue to set * @n: the number of elements * * Set @value to hold an array of GObject. Pass in the array length in @n. * * See also: vips_array_object_get(). * * Returns: 0 on success, -1 otherwise. */ int vips_value_set_array_object( GValue *value, int n ) { VipsArea *area; if( !(area = vips_area_new_array_object( n )) ) return( -1 ); g_value_set_boxed( value, area ); vips_area_unref( area ); return( 0 ); }
/** * vips_value_set_blob: * @value: (out): GValue to set * @free_fn: (scope async): free function for @data * @data: pointer to area of memory * @length: length of memory area * * Sets @value to hold a @data. When @value is freed, @data will be * freed with @free_fn. @value also holds a note of the length of the memory * area. * * blobs are things like ICC profiles or EXIF data. They are relocatable, and * are saved to VIPS files for you coded as base64 inside the XML. They are * copied by copying reference-counted pointers. * * See also: vips_value_get_blob() */ void vips_value_set_blob( GValue *value, VipsCallbackFn free_fn, void *data, size_t length ) { VipsArea *area; g_assert( G_VALUE_TYPE( value ) == VIPS_TYPE_BLOB ); area = vips_area_new_blob( free_fn, data, length ); g_value_set_boxed( value, area ); vips_area_unref( area ); }
/** * vips_value_set_ref_string: * @value: (out): GValue to set * @str: C string to copy into the GValue * * Copies the C string @str into @value. * * vips_ref_string are immutable C strings that are copied between images by * copying reference-counted pointers, making the much more efficient than * regular GValue strings. * * Returns: 0 on success, -1 otherwise. */ int vips_value_set_ref_string( GValue *value, const char *str ) { VipsArea *area; char *str_copy; g_assert( G_VALUE_TYPE( value ) == VIPS_TYPE_REF_STRING ); str_copy = g_strdup( str ); area = vips_area_new( (VipsCallbackFn) vips_free, str_copy ); /* Handy place to cache this. */ area->length = strlen( str ); g_value_set_boxed( value, area ); vips_area_unref( area ); return( 0 ); }