static void
vips_leak( void )
{
char txt[1024];
VipsBuf buf = VIPS_BUF_STATIC( txt );
vips_object_print_all();
if( vips_tracked_get_allocs() ||
vips_tracked_get_mem() ||
vips_tracked_get_files() ) {
vips_buf_appendf( &buf, "memory: %d allocations, %zd bytes\n",
vips_tracked_get_allocs(), vips_tracked_get_mem() );
vips_buf_appendf( &buf, "files: %d open\n",
vips_tracked_get_files() );
}
vips_buf_appendf( &buf, "memory: high-water mark " );
vips_buf_append_size( &buf, vips_tracked_get_mem_highwater() );
vips_buf_appends( &buf, "\n" );
fprintf( stderr, "%s", vips_buf_all( &buf ) );
vips__type_leak();
}
/**
* im_system:
* @im: image to run command on
* @cmd: command to run
* @out: stdout of command is returned here
*
* im_system() runs a command on an image, returning the command's output as a
* string. The command is executed with popen(), the first '%%s' in the
* command being substituted for a filename.
*
* If the IMAGE is a file on disc, then the filename will be the name of the
* real file. If the image is in memory, or the result of a computation,
* then a new file is created in the temporary area called something like
* "vips_XXXXXX.v", and that filename given to the command. The file is
* deleted when the command finishes.
*
* The environment variable TMPDIR can be used to set the temporary
* directory. If it is not set, it defaults to "/tmp".
*
* In all cases, @log must be freed with im_free().
*
* See also: im_system_image().
*
* Returns: 0 on success, -1 on error
*/
int
im_system( IMAGE *im, const char *cmd, char **out )
{
FILE *fp;
if( !im_isfile( im ) ) {
IMAGE *disc;
if( !(disc = im__open_temp( "%s.v" )) )
return( -1 );
if( im_copy( im, disc ) ||
im_system( disc, cmd, out ) ) {
im_close( disc );
return( -1 );
}
im_close( disc );
}
else if( (fp = im_popenf( cmd, "r", im->filename )) ) {
char line[IM_MAX_STRSIZE];
char txt[IM_MAX_STRSIZE];
VipsBuf buf = VIPS_BUF_STATIC( txt );
while( fgets( line, IM_MAX_STRSIZE, fp ) )
if( !vips_buf_appends( &buf, line ) )
break;
pclose( fp );
if( out )
*out = im_strdup( NULL, vips_buf_all( &buf ) );
}
return( 0 );
}
static void
vips_leak( void )
{
char txt[1024];
VipsBuf buf = VIPS_BUF_STATIC( txt );
vips_object_print_all();
if( vips_tracked_get_allocs() ||
vips_tracked_get_mem() ||
vips_tracked_get_files() ) {
vips_buf_appendf( &buf, "memory: %d allocations, %zd bytes\n",
vips_tracked_get_allocs(), vips_tracked_get_mem() );
vips_buf_appendf( &buf, "files: %d open\n",
vips_tracked_get_files() );
}
vips_buf_appendf( &buf, "memory: high-water mark " );
vips_buf_append_size( &buf, vips_tracked_get_mem_highwater() );
vips_buf_appends( &buf, "\n" );
if( strlen( vips_error_buffer() ) > 0 )
vips_buf_appendf( &buf, "error buffer: %s",
vips_error_buffer() );
fprintf( stderr, "%s", vips_buf_all( &buf ) );
#ifdef DEBUG
vips_buffer_dump_all();
#endif /*DEBUG*/
}
static void
vips_exif_exif_entry( ExifEntry *entry, VipsExifRemove *ve )
{
const char *tag_name;
char vips_name_txt[256];
VipsBuf vips_name = VIPS_BUF_STATIC( vips_name_txt );
if( !(tag_name = vips_exif_entry_get_name( entry )) )
return;
vips_buf_appendf( &vips_name, "exif-ifd%d-%s",
exif_entry_get_ifd( entry ), tag_name );
/* Does this field exist on the image? If not, schedule it for
* removal.
*/
if( !vips_image_get_typeof( ve->image, vips_buf_all( &vips_name ) ) )
ve->to_remove = g_slist_prepend( ve->to_remove, entry );
/* Orientation is really set from the vips
* VIPS_META_ORIENTATION tag. If that's been deleted, we must delete
* any matching EXIF tags too.
*/
if( strcmp( tag_name, "Orientation" ) == 0 &&
vips_image_get_typeof( ve->image, VIPS_META_ORIENTATION ) )
ve->to_remove = g_slist_prepend( ve->to_remove, entry );
/* If this is a string tag, we must also remove it ready for
* recreation, see the comment below.
*/
if( tag_is_encoding( entry->tag ) ||
tag_is_ascii( entry->tag ) ||
tag_is_utf16( entry->tag ) )
ve->to_remove = g_slist_prepend( ve->to_remove, entry );
}
static void
stringview_refresh( vObject *vobject )
{
Stringview *stringview = STRINGVIEW( vobject );
String *string = STRING( VOBJECT( stringview )->iobject );
#ifdef DEBUG
Row *row = HEAPMODEL( string )->row;
printf( "stringview_refresh: " );
row_name_print( row );
printf( " (%p)\n", vobject );
#endif /*DEBUG*/
if( string->value ) {
char txt[MAX_STRSIZE];
VipsBuf buf = VIPS_BUF_STATIC( txt );
vips_buf_appendsc( &buf, FALSE, string->value );
editview_set_entry( EDITVIEW( stringview ),
"%s", vips_buf_all( &buf ) );
}
VOBJECT_CLASS( parent_class )->refresh( vobject );
}
static void
workspaceview_drag_data_received( GtkWidget *widget, GdkDragContext *context,
gint x, gint y, GtkSelectionData *selection_data,
guint info, guint time )
{
Workspaceview *wview = WORKSPACEVIEW( widget );
Workspace *ws = WORKSPACE( VOBJECT( wview )->iobject );
const char *from_row_path = (const char *) selection_data->data;
Row *from_row;
#ifdef DEBUG
printf( "workspaceview_drag_data_received:\n" );
#endif /*DEBUG*/
/* We seem to rx drag events with x/y relative to the viewport.
*/
x += wview->vp.left;
y += wview->vp.top;
if( info == TARGET_SYMBOL && selection_data->length > 0 &&
selection_data->format == 8 &&
workspaceview_is_background( wview,
GTK_WIDGET( wview->fixed )->window, x, y ) &&
(from_row = row_parse_name( main_workspaceroot->sym,
from_row_path )) ) {
char new_name[MAX_STRSIZE];
Column *col;
char vips_buf_text[256];
VipsBuf buf = VIPS_BUF_STATIC( vips_buf_text );
Symbol *sym;
workspace_column_name_new( ws, new_name );
col = column_new( ws, new_name );
col->x = x;
col->y = y;
workspace_column_select( ws, col );
/* Qualify relative to us. We don't want to embed
* workspace names unless we have to.
*/
row_qualified_name_relative( ws->sym, from_row, &buf );
if( !(sym = workspace_add_def( ws, vips_buf_all( &buf ) )) )
iwindow_alert( widget, GTK_MESSAGE_ERROR );
symbol_recalculate_all();
/* Usually the drag-from row will be selected, very
* annoying. Select the drag-to row.
*/
if( sym &&
sym->expr &&
sym->expr->row )
row_select( sym->expr->row );
}
}
static void
attach_exif_entry( ExifEntry *entry, VipsExif *ve )
{
char name_txt[256];
VipsBuf name = VIPS_BUF_STATIC( name_txt );
char value_txt[256];
VipsBuf value = VIPS_BUF_STATIC( value_txt );
vips_buf_appendf( &name, "exif-ifd%d-%s",
exif_entry_get_ifd( entry ),
exif_tag_get_title( entry->tag ) );
vips_exif_to_s( ve->ed, entry, &value );
/* Can't do anything sensible with the error return.
*/
(void) vips_image_set_string( ve->image,
vips_buf_all( &name ), vips_buf_all( &value ) );
}
static void
workspacedefs_refresh( vObject *vobject )
{
Workspacedefs *workspacedefs = WORKSPACEDEFS( vobject );
Workspace *ws = workspacedefs->ws;
char txt[256];
VipsBuf buf = VIPS_BUF_STATIC( txt );
#ifdef DEBUG
printf( "workspacedefs_refresh:\n" );
#endif /*DEBUG*/
if( !workspacedefs->changed ) {
guint text_hash = g_str_hash( ws->local_defs );
if( text_hash != workspacedefs->text_hash ) {
g_signal_handlers_block_by_func(
gtk_text_view_get_buffer(
GTK_TEXT_VIEW( workspacedefs->text ) ),
workspacedefs_text_changed, workspacedefs );
text_view_set_text(
GTK_TEXT_VIEW( workspacedefs->text ),
ws->local_defs, TRUE );
g_signal_handlers_unblock_by_func(
gtk_text_view_get_buffer(
GTK_TEXT_VIEW( workspacedefs->text ) ),
workspacedefs_text_changed, workspacedefs );
workspacedefs->text_hash = text_hash;
}
}
if( ws->local_kit ) {
int n = icontainer_get_n_children( ICONTAINER(
ws->local_kit ) );
vips_buf_appendf( &buf, ngettext( "%d definition",
"%d definitions", n ), n );
}
if( workspacedefs->errors ) {
if( !vips_buf_is_empty( &buf ) )
vips_buf_appendf( &buf, ", " );
vips_buf_appendf( &buf, _( "errors" ) );
}
if( workspacedefs->changed ) {
if( !vips_buf_is_empty( &buf ) )
vips_buf_appendf( &buf, ", " );
vips_buf_appendf( &buf, _( "modified" ) );
}
set_glabel( workspacedefs->status, "%s", vips_buf_all( &buf ) );
VOBJECT_CLASS( parent_class )->refresh( vobject );
}
static void
vips_exif_attach_entry( ExifEntry *entry, VipsExifParams *params )
{
const char *tag_name;
char vips_name_txt[256];
VipsBuf vips_name = VIPS_BUF_STATIC( vips_name_txt );
char value_txt[256];
VipsBuf value = VIPS_BUF_STATIC( value_txt );
if( !(tag_name = vips_exif_entry_get_name( entry )) )
return;
vips_buf_appendf( &vips_name, "exif-ifd%d-%s",
exif_entry_get_ifd( entry ), tag_name );
vips_exif_to_s( params->ed, entry, &value );
/* Can't do anything sensible with the error return.
*/
(void) vips_image_set_string( params->image,
vips_buf_all( &vips_name ), vips_buf_all( &value ) );
}
static void *
vips_cache_print_fn( void *value, void *a, void *b )
{
char str[32768];
VipsBuf buf = VIPS_BUF_STATIC( str );
vips_object_to_string( VIPS_OBJECT( value ), &buf );
printf( "%p - %s\n", value, vips_buf_all( &buf ) );
return( NULL );
}
/* Do "print".
*/
static void
apply_print_call( Reduce *rc, const char *name, HeapNode **arg, PElement *out )
{
PElement rhs;
char txt[MAX_STRSIZE];
VipsBuf buf = VIPS_BUF_STATIC( txt );
PEPOINTRIGHT( arg[0], &rhs );
itext_value_ev( rc, &buf, &rhs );
if( !heap_managedstring_new( rc->heap, vips_buf_all( &buf ), out ) )
reduce_throw( rc );
}
static void *
vips_cache_print_fn( void *value, void *a, void *b )
{
VipsOperationCacheEntry *entry = value;
char str[32768];
VipsBuf buf = VIPS_BUF_STATIC( str );
vips_object_to_string( VIPS_OBJECT( entry->operation ), &buf );
printf( "%p - %s\n", value, vips_buf_all( &buf ) );
return( NULL );
}
/* Convenience ... print a row name out, identifying by tally heirarchy.
*/
void *
row_name_print( Row *row )
{
if( row ) {
char txt[100];
VipsBuf buf = VIPS_BUF_STATIC( txt );
row_qualified_name( row, &buf );
printf( "%s ", vips_buf_all( &buf ) );
}
else
printf( "(null)" );
return( NULL );
}
/* Load a matrix or image. Don't recalc: you need to recalc later to test for
* success/fail. See eg. workspace_add_def_recalc()
*/
Symbol *
workspace_load_file( Workspace *ws, const char *filename )
{
char txt[MAX_STRSIZE];
VipsBuf buf = VIPS_BUF_STATIC( txt );
Symbol *sym;
if( !workspace_load_file_buf( &buf, filename ) )
return( NULL );
if( !(sym = workspace_add_def( ws, vips_buf_all( &buf ) )) )
return( NULL );
mainw_recent_add( &mainw_recent_image, filename );
return( sym );
}
/* Make a VipsObject.
*/
void
vo_object_new( Reduce *rc, const char *name,
PElement *required, PElement *optional, PElement *out )
{
Vo *vo;
Managedgobject *managedgobject;
if( !(vo = vo_new( rc, name )) )
reduce_throw( rc );
if( !vo_args( vo, required, optional ) ) {
vo_free( vo );
reduce_throw( rc );
}
/* Ask the object to construct.
*/
if( vips_object_build( vo->object ) ) {
error_top( _( "VIPS library error." ) );
error_sub( "%s", im_error_buffer() );
im_error_clear();
vo_free( vo );
reduce_throw( rc );
}
/* Return the constructed object.
*/
if( !(managedgobject = managedgobject_new( vo->rc->heap,
G_OBJECT( vo->object ) )) ) {
vo_free( vo );
reduce_throw( rc );
}
PEPUTP( out, ELEMENT_MANAGED, managedgobject );
#ifdef DEBUG
{
char txt[1000];
VipsBuf buf = VIPS_BUF_STATIC( txt );
vips_object_to_string( vo->object, &buf );
printf( "vo_object_new: built %s\n", vips_buf_all( &buf ) );
}
#endif /*DEBUG*/
vo_free( vo );
}
/* Do a graph_export_image call.
*/
static void
apply_graph_export_image_call( Reduce *rc,
const char *name, HeapNode **arg, PElement *out )
{
#ifdef HAVE_LIBGOFFICE
PElement rhs;
double dpi;
Plot *plot;
Imageinfo *ii;
PEPOINTRIGHT( arg[1], &rhs );
dpi = PEGETREAL( &rhs );
PEPOINTRIGHT( arg[0], &rhs );
if( !reduce_is_instanceof( rc, CLASS_PLOT, &rhs ) ) {
char txt[100];
VipsBuf buf = VIPS_BUF_STATIC( txt );
itext_value_ev( rc, &buf, &rhs );
error_top( _( "Bad argument." ) );
error_sub( _( "Argument 2 to \"%s\" should "
"be instance of \"%s\", you passed:\n %s" ),
name, CLASS_PLOT,
vips_buf_all( &buf ) );
reduce_throw( rc );
}
plot = g_object_new( TYPE_PLOT, NULL );
if( !classmodel_update_members( CLASSMODEL( plot ), &rhs ) ) {
UNREF( plot );
reduce_throw( rc );
}
if( !(ii = plot_to_image( plot, rc, dpi )) ) {
UNREF( plot );
reduce_throw( rc );
}
UNREF( plot );
PEPUTP( out, ELEMENT_MANAGED, ii );
#else /*!HAVE_LIBGOFFICE*/
PEPUTP( out, ELEMENT_BOOL, TRUE );
#endif /*HAVE_LIBGOFFICE*/
}
/* Mark a row as containing an error ... called from expr_error_set()
* ... don't call this directly.
*/
void
row_error_set( Row *row )
{
if( !row->err ) {
Workspace *ws = row->ws;
gboolean was_clear = ws->errors == NULL;
ws->errors = g_slist_prepend( ws->errors, row );
row->err = TRUE;
#ifdef DEBUG_ERROR
printf( "row_error_set: " );
row_name_print( row );
printf( "\n" );
#endif /*DEBUG_ERROR*/
iobject_changed( IOBJECT( row ) );
/* First error? State change on workspace.
*/
if( was_clear )
iobject_changed( IOBJECT( ws ) );
/* If this is a local row, mark the top row in error too to end
* recomp on this tree.
*/
if( row != row->top_row ) {
char txt[100];
VipsBuf buf = VIPS_BUF_STATIC( txt );
row_qualified_name( row, &buf );
error_top( _( "Error in row." ) );
/* Elements are name of row, principal error,
* secondary error.
*/
error_sub( _( "Error in row %s: %s\n%s" ),
vips_buf_all( &buf ),
row->expr->error_top,
row->expr->error_sub );
expr_error_set( row->top_row->expr );
}
}
}
static void
transform_array_double_g_string( const GValue *src_value, GValue *dest_value )
{
int n;
double *array = vips_value_get_array_double( src_value, &n );
char txt[1024];
VipsBuf buf = VIPS_BUF_STATIC( txt );
int i;
for( i = 0; i < n; i++ )
/* Use space as a separator since ',' may be a decimal point
* in this locale.
*/
vips_buf_appendf( &buf, "%g ", array[i] );
g_value_set_string( dest_value, vips_buf_all( &buf ) );
}
static void *
vips_exif_exif_remove( ExifEntry *entry, VipsExifRemove *ve )
{
#ifdef DEBUG
{
const char *tag_name;
char vips_name_txt[256];
VipsBuf vips_name = VIPS_BUF_STATIC( vips_name_txt );
tag_name = vips_exif_entry_get_name( entry );
vips_buf_appendf( &vips_name, "exif-ifd%d-%s",
exif_entry_get_ifd( entry ), tag_name );
printf( "vips_exif_exif_remove: %s\n", vips_buf_all( &vips_name ) );
}
#endif /*DEBUG*/
exif_content_remove_entry( ve->content, entry );
return( NULL );
}
gboolean
iimage_replace( iImage *iimage, const char *filename )
{
Row *row = HEAPMODEL( iimage )->row;
iText *itext = ITEXT( HEAPMODEL( iimage )->rhs->itext );
char txt[MAX_STRSIZE];
VipsBuf buf = VIPS_BUF_STATIC( txt );
vips_buf_appends( &buf, "Image_file \"" );
vips_buf_appendsc( &buf, TRUE, filename );
vips_buf_appends( &buf, "\"" );
if( itext_set_formula( itext, vips_buf_all( &buf ) ) ) {
itext_set_edited( itext, TRUE );
workspace_set_modified( row->ws, TRUE );
(void) expr_dirty( row->expr, link_serial_new() );
mainw_recent_add( &mainw_recent_image, filename );
}
return( TRUE );
}
static void *
imageheader_add_item( IMAGE *im,
const char *field, GValue *value, Imageheader *imageheader )
{
char txt[256];
VipsBuf buf = VIPS_BUF_STATIC( txt );
GtkTreeIter iter;
char *value_str;
const char *extra;
value_str = g_strdup_value_contents( value );
vips_buf_appendf( &buf, "%s", value_str );
/* Look for enums and decode them.
*/
extra = NULL;
if( strcmp( field, "coding" ) == 0 )
extra = vips_enum_nick( VIPS_TYPE_CODING,
g_value_get_int( value ) );
else if( strcmp( field, "format" ) == 0 )
extra = vips_enum_nick( VIPS_TYPE_BAND_FORMAT,
g_value_get_int( value ) );
else if( strcmp( field, "interpretation" ) == 0 )
extra = vips_enum_nick( VIPS_TYPE_INTERPRETATION,
g_value_get_int( value ) );
if( extra )
vips_buf_appendf( &buf, " - %s", extra );
gtk_list_store_append( imageheader->store, &iter );
gtk_list_store_set( imageheader->store, &iter,
NAME_COLUMN, field,
VALUE_COLUMN, vips_buf_all( &buf ),
-1 );
g_free( value_str );
return( NULL );
}
void
iimage_header( GtkWidget *parent, Model *model )
{
iImage *iimage = IIMAGE( model );
Row *row = HEAPMODEL( iimage )->row;
Workspace *ws = row_get_workspace( row );
GtkWidget *imageheader;
char txt[512];
VipsBuf buf = VIPS_BUF_STATIC( txt );
imageheader = imageheader_new( iimage );
row_qualified_name_relative( ws->sym, row, &buf );
iwindow_set_title( IWINDOW( imageheader ),
_( "Header for \"%s\"" ), vips_buf_all( &buf ) );
idialog_set_callbacks( IDIALOG( imageheader ), NULL, NULL, NULL, NULL );
idialog_add_ok( IDIALOG( imageheader ), iwindow_true_cb, _( "OK" ) );
iwindow_set_parent( IWINDOW( imageheader ), parent );
idialog_set_iobject( IDIALOG( imageheader ), IOBJECT( iimage ) );
iwindow_build( IWINDOW( imageheader ) );
gtk_widget_show( imageheader );
}
VipsObjectClass *object_class = VIPS_OBJECT_GET_CLASS( object );
#ifdef DEBUG
printf( "vips_object_build: " );
vips_object_print_name( object );
printf( "\n" );
#endif /*DEBUG*/
return( object_class->build( object ) );
}
void
vips_object_print_class( VipsObjectClass *class )
{
char str[1000];
VipsBuf buf = VIPS_BUF_STATIC( str );
class->print_class( class, &buf );
printf( "%s\n", vips_buf_all( &buf ) );
}
void
vips_object_print( VipsObject *object )
{
VipsObjectClass *class = VIPS_OBJECT_GET_CLASS( object );
/* This is used for printing image headers, so we may need lots of
* space. See header.c.
*/
char str[32768];
VipsBuf buf = VIPS_BUF_STATIC( str );
/* Make the insides of an about box.
*/
static void
about_build( iDialog *idlg, GtkWidget *work )
{
/* Translators: translate this to a credit for you, and it'll appear in
* the About box.
*/
char *translator_credits = _( "translator_credits" );
GtkWidget *hb;
GtkWidget *lab;
char txt[MAX_DIALOG_TEXT];
char txt2[MAX_DIALOG_TEXT];
VipsBuf buf = VIPS_BUF_STATIC( txt );
GtkWidget *image;
im_snprintf( txt2, MAX_DIALOG_TEXT, _( "About %s." ), PACKAGE );
vips_buf_appendf( &buf, "<b><big>%s</big></b>\n\n", txt2 );
im_snprintf( txt2, MAX_DIALOG_TEXT,
_( "%s is an image processing package." ), PACKAGE );
vips_buf_appendf( &buf, "%s\n\n", txt2 );
im_snprintf( txt2, MAX_DIALOG_TEXT,
_( "%s comes with ABSOLUTELY NO WARRANTY. This is "
"free software and you are welcome to redistribute "
"it under certain conditions, see http://www.gnu.org." ),
PACKAGE );
vips_buf_appendf( &buf, "%s\n\n", txt2 );
im_snprintf( txt2, MAX_DIALOG_TEXT, _( NIP_COPYRIGHT ), PACKAGE );
vips_buf_appendf( &buf, "%s\n\n", txt2 );
{
char buf1[FILENAME_MAX];
char buf2[FILENAME_MAX];
im_snprintf( buf1, FILENAME_MAX, "%s" G_DIR_SEPARATOR_S "start",
get_savedir() );
expand_variables( buf1, buf2 );
nativeize_path( buf2 );
escape_markup( buf2, buf1, FILENAME_MAX );
vips_buf_appendf( &buf, "<b>%s:</b> %s\n",
_( "Personal start folder" ), buf1 );
}
vips_buf_appendf( &buf, "<b>%s:</b> %s\n",
_( "Homepage" ), VIPS_HOMEPAGE );
escape_markup( im_version_string(), txt2, MAX_DIALOG_TEXT );
vips_buf_appendf( &buf, "<b>%s:</b> %s\n",
_( "Linked to VIPS" ), txt2 );
escape_markup( IM_VERSION_STRING, txt2, MAX_DIALOG_TEXT );
vips_buf_appendf( &buf, "<b>%s:</b> %s\n",
_( "Built against VIPS" ), txt2 );
escape_markup( PACKAGE, txt2, MAX_DIALOG_TEXT );
vips_buf_appendf( &buf, "<b>$PACKAGE:</b> %s\n", txt2 );
escape_markup( VERSION, txt2, MAX_DIALOG_TEXT );
vips_buf_appendf( &buf, "<b>$VERSION:</b> %s\n", txt2 );
escape_markup( NN( g_getenv( "VIPSHOME" ) ), txt2, MAX_DIALOG_TEXT );
vips_buf_appendf( &buf, "<b>$VIPSHOME:</b> %s\n", txt2 );
escape_markup( NN( g_getenv( "HOME" ) ), txt2, MAX_DIALOG_TEXT );
vips_buf_appendf( &buf, "<b>$HOME:</b> %s\n", txt2 );
escape_markup( NN( g_getenv( "SAVEDIR" ) ), txt2, MAX_DIALOG_TEXT );
vips_buf_appendf( &buf, "<b>$SAVEDIR:</b> %s\n", txt2 );
escape_markup( PATH_TMP, txt2, MAX_DIALOG_TEXT );
vips_buf_appendf( &buf, "<b>%s:</b> %s\n",
_( "Temp files in" ), txt2 );
if( strcmp( translator_credits, "translator_credits" ) != 0 ) {
vips_buf_appendf( &buf, "\n" );
vips_buf_appends( &buf, translator_credits );
}
vips_buf_appendf( &buf, "\n" );
mainw_find_disc( &buf );
/* Expands to (eg.) "14GB free in /pics/tmp" */
vips_buf_appendf( &buf, _( " in \"%s\"" ), PATH_TMP );
vips_buf_appends( &buf, "\n" );
vips_buf_appendf( &buf,
_( "%d cells in heap, %d cells free, %d cells maximum" ),
reduce_context->heap->ncells,
reduce_context->heap->nfree,
reduce_context->heap->max_fn( reduce_context->heap ) );
vips_buf_appends( &buf, "\n" );
vips_buf_appendf( &buf, _( "%d vips calls cached by nip2" ),
cache_history_size );
vips_buf_appends( &buf, "\n" );
vips_buf_appendf( &buf, _( "%d vips operations cached by libvips" ),
vips_cache_get_size() );
vips_buf_appends( &buf, "\n" );
vips_buf_appendf( &buf, _( "using %d threads" ), im_concurrency_get() );
vips_buf_appends( &buf, "\n" );
vips_buf_appendf( &buf, _( "%d pixel buffers in vips" ),
vips_tracked_get_allocs() );
vips_buf_appends( &buf, "\n" );
vips_buf_append_size( &buf, vips_tracked_get_mem() );
vips_buf_appendf( &buf, _( " of ram in pixel buffers" ) );
vips_buf_appends( &buf, "\n" );
vips_buf_append_size( &buf, vips_tracked_get_mem_highwater() );
vips_buf_appendf( &buf, _( " of ram highwater mark" ) );
vips_buf_appends( &buf, "\n" );
hb = gtk_hbox_new( FALSE, 0 );
gtk_container_border_width( GTK_CONTAINER( hb ), 10 );
gtk_container_add( GTK_CONTAINER( work ), hb );
gtk_widget_show( hb );
image = image_new_from_file(
"$VIPSHOME/share/$PACKAGE/data/vips-128.png" );
gtk_box_pack_start( GTK_BOX( hb ), image, FALSE, FALSE, 2 );
gtk_widget_show( image );
lab = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL( lab ), vips_buf_all( &buf ) );
gtk_label_set_justify( GTK_LABEL( lab ), GTK_JUSTIFY_LEFT );
gtk_label_set_selectable( GTK_LABEL( lab ), TRUE );
gtk_label_set_line_wrap( GTK_LABEL( lab ), TRUE );
gtk_box_pack_start( GTK_BOX( hb ), lab, FALSE, FALSE, 2 );
gtk_widget_show( lab );
}
* if( vips_image_get_width( im ) < 100 ) {
* // we have detected an error, we must set a message
* vips_error( "myprogram", "%s", _( "width too small" ) );
* return( -1 );
* }
* ]|
*
* The domain argument most of these functions take is not localised and is
* supposed to indicate the component which failed.
*/
/* Make global array to keep the error message buffer.
*/
#define VIPS_MAX_ERROR (10240)
static char vips_error_text[VIPS_MAX_ERROR] = "";
static VipsBuf vips_error_buf = VIPS_BUF_STATIC( vips_error_text );
#define IM_DIAGNOSTICS "IM_DIAGNOSTICS"
#define IM_WARNING "IM_WARNING"
/**
* vips_error_buffer:
*
* Get a pointer to the start of the error buffer as a C string.
* The string is owned by the error system and must not be freed.
*
* See also: vips_error_clear().
*
* Returns: the error buffer as a C string which must not be freed
*/
const char *
static int
parse_header( Read *read )
{
VipsImage *im = read->im;
Image *image = read->image;
Image *p;
int i;
#ifdef DEBUG
printf( "parse_header: filename = %s\n", read->filename );
printf( "GetImageChannelDepth(AllChannels) = %zd\n",
GetImageChannelDepth( image, AllChannels, &image->exception ) );
printf( "GetImageDepth() = %zd\n",
GetImageDepth( image, &image->exception ) );
printf( "image->depth = %zd\n", image->depth );
printf( "GetImageType() = %d\n",
GetImageType( image, &image->exception ) );
printf( "IsGrayImage() = %d\n",
IsGrayImage( image, &image->exception ) );
printf( "IsMonochromeImage() = %d\n",
IsMonochromeImage( image, &image->exception ) );
printf( "IsOpaqueImage() = %d\n",
IsOpaqueImage( image, &image->exception ) );
printf( "image->columns = %zd\n", image->columns );
printf( "image->rows = %zd\n", image->rows );
#endif /*DEBUG*/
im->Xsize = image->columns;
im->Ysize = image->rows;
read->frame_height = image->rows;
if( (im->Bands = get_bands( image )) < 0 )
return( -1 );
/* Depth can be 'fractional'. You'd think we should use
* GetImageDepth() but that seems unreliable. 16-bit mono DICOM images
* are reported as depth 1, for example.
*/
im->BandFmt = -1;
if( image->depth >= 1 && image->depth <= 8 )
im->BandFmt = VIPS_FORMAT_UCHAR;
if( image->depth >= 9 && image->depth <= 16 )
im->BandFmt = VIPS_FORMAT_USHORT;
#ifdef UseHDRI
if( image->depth == 32 )
im->BandFmt = VIPS_FORMAT_FLOAT;
if( image->depth == 64 )
im->BandFmt = VIPS_FORMAT_DOUBLE;
#else /*!UseHDRI*/
if( image->depth == 32 )
im->BandFmt = VIPS_FORMAT_UINT;
#endif /*UseHDRI*/
if( im->BandFmt == -1 ) {
vips_error( "magick2vips", _( "unsupported bit depth %d" ),
(int) image->depth );
return( -1 );
}
switch( image->colorspace ) {
case GRAYColorspace:
if( im->BandFmt == VIPS_FORMAT_USHORT )
im->Type = VIPS_INTERPRETATION_GREY16;
else
im->Type = VIPS_INTERPRETATION_B_W;
break;
case RGBColorspace:
if( im->BandFmt == VIPS_FORMAT_USHORT )
im->Type = VIPS_INTERPRETATION_RGB16;
else
im->Type = VIPS_INTERPRETATION_RGB;
break;
case sRGBColorspace:
if( im->BandFmt == VIPS_FORMAT_USHORT )
im->Type = VIPS_INTERPRETATION_RGB16;
else
im->Type = VIPS_INTERPRETATION_sRGB;
break;
case CMYKColorspace:
im->Type = VIPS_INTERPRETATION_CMYK;
break;
default:
vips_error( "magick2vips", _( "unsupported colorspace %d" ),
(int) image->colorspace );
return( -1 );
}
switch( image->units ) {
case PixelsPerInchResolution:
im->Xres = image->x_resolution / 25.4;
im->Yres = image->y_resolution / 25.4;
break;
case PixelsPerCentimeterResolution:
im->Xres = image->x_resolution / 10.0;
im->Yres = image->y_resolution / 10.0;
break;
default:
im->Xres = 1.0;
im->Yres = 1.0;
break;
}
/* Other fields.
*/
im->Coding = VIPS_CODING_NONE;
vips_image_pipelinev( im, VIPS_DEMAND_STYLE_SMALLTILE, NULL );
/* Three ways to loop over attributes / properties :-(
*/
#ifdef HAVE_RESETIMAGEPROPERTYITERATOR
{
char *key;
/* This is the most recent imagemagick API, test for this first.
*/
ResetImagePropertyIterator( image );
while( (key = GetNextImageProperty( image )) ) {
char name_text[256];
VipsBuf name = VIPS_BUF_STATIC( name_text );
vips_buf_appendf( &name, "magick-%s", key );
vips_image_set_string( im,
vips_buf_all( &name ), GetImageProperty( image, key ) );
}
}
#elif defined(HAVE_RESETIMAGEATTRIBUTEITERATOR)
{
const ImageAttribute *attr;
/* magick6.1-ish and later, deprecated in 6.5ish.
*/
ResetImageAttributeIterator( image );
while( (attr = GetNextImageAttribute( image )) ) {
char name_text[256];
VipsBuf name = VIPS_BUF_STATIC( name_text );
vips_buf_appendf( &name, "magick-%s", attr->key );
vips_image_set_string( im, vips_buf_all( &name ), attr->value );
}
}
#else
{
const ImageAttribute *attr;
/* GraphicsMagick is missing the iterator: we have to loop ourselves.
* ->attributes is marked as private in the header, but there's no
* getter so we have to access it directly.
*/
for( attr = image->attributes; attr; attr = attr->next ) {
char name_text[256];
VipsBuf name = VIPS_BUF_STATIC( name_text );
vips_buf_appendf( &name, "magick-%s", attr->key );
vips_image_set_string( im, vips_buf_all( &name ), attr->value );
}
}
#endif
/* Do we have a set of equal-sized frames? Append them.
FIXME ... there must be an attribute somewhere from dicom read
which says this is a volumetric image
*/
read->n_frames = 0;
for( p = image; p; (p = GetNextImageInList( p )) ) {
if( p->columns != (unsigned int) im->Xsize ||
p->rows != (unsigned int) im->Ysize ||
get_bands( p ) != im->Bands )
break;
read->n_frames += 1;
}
if( p )
/* Nope ... just do the first image in the list.
*/
read->n_frames = 1;
#ifdef DEBUG
printf( "image has %d frames\n", read->n_frames );
#endif /*DEBUG*/
/* If all_frames is off, just get the first one.
*/
if( !read->all_frames )
read->n_frames = 1;
/* Record frame pointers.
*/
im->Ysize *= read->n_frames;
if( !(read->frames = VIPS_ARRAY( NULL, read->n_frames, Image * )) )
return( -1 );
p = image;
for( i = 0; i < read->n_frames; i++ ) {
read->frames[i] = p;
p = GetNextImageInList( p );
}
return( 0 );
}
* if( im->Xsize < 100 ) {
* // we have detected an error, we must set a message
* im_error( "myprogram", "%s", _( "XSize too small" ) );
* return( -1 );
* }
* ]|
*
* The domain argument most of these functions take is not localised and is
* supposed to indicate the component which failed.
*/
/* Make global array to keep the error message buffer.
*/
#define IM_MAX_ERROR (10240)
static char im_error_text[IM_MAX_ERROR] = "";
static VipsBuf im_error_buf = VIPS_BUF_STATIC( im_error_text );
#define IM_DIAGNOSTICS "IM_DIAGNOSTICS"
#define IM_WARNING "IM_WARNING"
/**
* im_error_buffer:
*
* Get a pointer to the start of the error buffer as a C string.
* The string is owned by the error system and must not be freed.
*
* See also: im_error_clear().
*
* Returns: the error buffer as a C string which must not be freed
*/
const char *