From 5c1676dfe6d2f3c837a5e074117b45613fd29a72 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:30:19 +0200 Subject: Adding upstream version 2.10.34. Signed-off-by: Daniel Baumann --- plug-ins/common/file-dicom.c | 1796 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1796 insertions(+) create mode 100644 plug-ins/common/file-dicom.c (limited to 'plug-ins/common/file-dicom.c') diff --git a/plug-ins/common/file-dicom.c b/plug-ins/common/file-dicom.c new file mode 100644 index 0000000..7a3d400 --- /dev/null +++ b/plug-ins/common/file-dicom.c @@ -0,0 +1,1796 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * PNM reading and writing code Copyright (C) 1996 Erik Nygren + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* + * The dicom reading and writing code was written from scratch + * by Dov Grobgeld. (dov.grobgeld@gmail.com). + */ + +#include "config.h" + +#include +#include +#include + +#include + +#include +#include + +#include "libgimp/stdplugins-intl.h" + + +#define LOAD_PROC "file-dicom-load" +#define SAVE_PROC "file-dicom-save" +#define PLUG_IN_BINARY "file-dicom" +#define PLUG_IN_ROLE "gimp-file-dicom" + + +/* A lot of Dicom images are wrongly encoded. By guessing the endian + * we can get around this problem. + */ +#define GUESS_ENDIAN 1 + +/* Declare local data types */ +typedef struct _DicomInfo +{ + guint width, height; /* The size of the image */ + gint maxval; /* For 16 and 24 bit image files, the max + value which we need to normalize to */ + gint samples_per_pixel; /* Number of image planes (0 for pbm) */ + gint bpp; + gint bits_stored; + gint high_bit; + gboolean is_signed; + gboolean planar; + gboolean bw_inverted; +} DicomInfo; + +/* Local function prototypes */ +static void query (void); +static void run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals); +static gint32 load_image (const gchar *filename, + GError **error); +static gboolean save_image (const gchar *filename, + gint32 image_ID, + gint32 drawable_ID, + GError **error); +static void dicom_loader (guint8 *pix_buf, + DicomInfo *info, + GeglBuffer *buffer); +static void guess_and_set_endian2 (guint16 *buf16, + gint length); +static void toggle_endian2 (guint16 *buf16, + gint length); +static void add_tag_pointer (GByteArray *group_stream, + gint group, + gint element, + const gchar *value_rep, + const guint8 *data, + gint length); +static GSList * dicom_add_tags (FILE *DICOM, + GByteArray *group_stream, + GSList *elements); +static gboolean write_group_to_file (FILE *DICOM, + gint group, + GByteArray *group_stream); + + +const GimpPlugInInfo PLUG_IN_INFO = +{ + NULL, /* init_proc */ + NULL, /* quit_proc */ + query, /* query_proc */ + run, /* run_proc */ +}; + +MAIN () + +static void +query (void) +{ + static const GimpParamDef load_args[] = + { + { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, + { GIMP_PDB_STRING, "filename", "The name of the file to load" }, + { GIMP_PDB_STRING, "raw-filename", "The name of the file to load" } + }; + static const GimpParamDef load_return_vals[] = + { + { GIMP_PDB_IMAGE, "image", "Output image" } + }; + + static const GimpParamDef save_args[] = + { + { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, + { GIMP_PDB_IMAGE, "image", "Input image" }, + { GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" }, + { GIMP_PDB_STRING, "filename", "The name of the file to save" }, + { GIMP_PDB_STRING, "raw-filename", "The name of the file to save" }, + }; + + gimp_install_procedure (LOAD_PROC, + "loads files of the dicom file format", + "Load a file in the DICOM standard format." + "The standard is defined at " + "http://medical.nema.org/. The plug-in currently " + "only supports reading images with uncompressed " + "pixel sections.", + "Dov Grobgeld", + "Dov Grobgeld ", + "2003", + N_("DICOM image"), + NULL, + GIMP_PLUGIN, + G_N_ELEMENTS (load_args), + G_N_ELEMENTS (load_return_vals), + load_args, load_return_vals); + + gimp_register_file_handler_mime (LOAD_PROC, "image/x-dcm"); + gimp_register_magic_load_handler (LOAD_PROC, + "dcm,dicom", + "", + "128,string,DICM" + ); + + gimp_install_procedure (SAVE_PROC, + "Save file in the DICOM file format", + "Save an image in the medical standard DICOM image " + "formats. The standard is defined at " + "http://medical.nema.org/. The file format is " + "defined in section 10 of the standard. The files " + "are saved uncompressed and the compulsory DICOM " + "tags are filled with default dummy values.", + "Dov Grobgeld", + "Dov Grobgeld ", + "2003", + N_("Digital Imaging and Communications in " + "Medicine image"), + "RGB, GRAY", + GIMP_PLUGIN, + G_N_ELEMENTS (save_args), 0, + save_args, NULL); + + gimp_register_file_handler_mime (SAVE_PROC, "image/x-dcm"); + gimp_register_save_handler (SAVE_PROC, "dcm,dicom", ""); +} + +static void +run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals) +{ + static GimpParam values[2]; + GimpRunMode run_mode; + GimpPDBStatusType status = GIMP_PDB_SUCCESS; + gint32 image_ID; + gint32 drawable_ID; + GimpExportReturn export = GIMP_EXPORT_CANCEL; + GError *error = NULL; + + INIT_I18N (); + gegl_init (NULL, NULL); + + run_mode = param[0].data.d_int32; + + *nreturn_vals = 1; + *return_vals = values; + values[0].type = GIMP_PDB_STATUS; + values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; + + if (strcmp (name, LOAD_PROC) == 0) + { + image_ID = load_image (param[1].data.d_string, &error); + + if (image_ID != -1) + { + *nreturn_vals = 2; + + values[1].type = GIMP_PDB_IMAGE; + values[1].data.d_image = image_ID; + } + else + { + status = GIMP_PDB_EXECUTION_ERROR; + + if (error) + { + *nreturn_vals = 2; + values[1].type = GIMP_PDB_STRING; + values[1].data.d_string = error->message; + } + } + } + else if (strcmp (name, SAVE_PROC) == 0) + { + image_ID = param[1].data.d_int32; + drawable_ID = param[2].data.d_int32; + + switch (run_mode) + { + case GIMP_RUN_INTERACTIVE: + case GIMP_RUN_WITH_LAST_VALS: + gimp_ui_init (PLUG_IN_BINARY, FALSE); + export = gimp_export_image (&image_ID, &drawable_ID, "DICOM", + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY); + + if (export == GIMP_EXPORT_CANCEL) + { + values[0].data.d_status = GIMP_PDB_CANCEL; + return; + } + break; + + default: + break; + } + + switch (run_mode) + { + case GIMP_RUN_INTERACTIVE: + break; + + case GIMP_RUN_NONINTERACTIVE: + /* Make sure all the arguments are there! */ + if (nparams != 5) + status = GIMP_PDB_CALLING_ERROR; + break; + + case GIMP_RUN_WITH_LAST_VALS: + break; + + default: + break; + } + + if (status == GIMP_PDB_SUCCESS) + { + if (! save_image (param[3].data.d_string, image_ID, drawable_ID, + &error)) + { + status = GIMP_PDB_EXECUTION_ERROR; + + if (error) + { + *nreturn_vals = 2; + values[1].type = GIMP_PDB_STRING; + values[1].data.d_string = error->message; + } + } + } + + if (export == GIMP_EXPORT_EXPORT) + gimp_image_delete (image_ID); + } + else + { + status = GIMP_PDB_CALLING_ERROR; + } + + values[0].data.d_status = status; +} + +/** + * add_parasites_to_image: + * @data: pointer to a GimpParasite to be attached to the image + * specified by @user_data. + * @user_data: pointer to the image_ID to which parasite @data should + * be added. + * + * Attaches parasite to image and also frees that parasite +**/ +static void +add_parasites_to_image (gpointer data, + gpointer user_data) +{ + GimpParasite *parasite = (GimpParasite *) data; + gint32 *image_ID = (gint32 *) user_data; + + gimp_image_attach_parasite (*image_ID, parasite); + gimp_parasite_free (parasite); +} + +static gint32 +load_image (const gchar *filename, + GError **error) +{ + gint32 volatile image_ID = -1; + gint32 layer_ID; + GeglBuffer *buffer; + GSList *elements = NULL; + FILE *DICOM; + gchar buf[500]; /* buffer for random things like scanning */ + DicomInfo *dicominfo; + guint width = 0; + guint height = 0; + gint samples_per_pixel = 0; + gint bpp = 0; + gint bits_stored = 0; + gint high_bit = 0; + guint8 *pix_buf = NULL; + gboolean is_signed = FALSE; + guint8 in_sequence = 0; + gboolean implicit_encoding = FALSE; + gboolean big_endian = FALSE; + + gimp_progress_init_printf (_("Opening '%s'"), + gimp_filename_to_utf8 (filename)); + + DICOM = g_fopen (filename, "rb"); + + if (! DICOM) + { + g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), + _("Could not open '%s' for reading: %s"), + gimp_filename_to_utf8 (filename), g_strerror (errno)); + return -1; + } + + /* allocate the necessary structures */ + dicominfo = g_new0 (DicomInfo, 1); + + /* Parse the file */ + fread (buf, 1, 128, DICOM); /* skip past buffer */ + + /* Check for unsupported formats */ + if (g_ascii_strncasecmp (buf, "PAPYRUS", 7) == 0) + { + g_message ("'%s' is a PAPYRUS DICOM file.\n" + "This plug-in does not support this type yet.", + gimp_filename_to_utf8 (filename)); + g_free (dicominfo); + fclose (DICOM); + return -1; + } + + fread (buf, 1, 4, DICOM); /* This should be dicom */ + if (g_ascii_strncasecmp (buf,"DICM",4) != 0) + { + g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, + _("'%s' is not a DICOM file."), + gimp_filename_to_utf8 (filename)); + g_free (dicominfo); + fclose (DICOM); + return -1; + } + + while (!feof (DICOM)) + { + guint16 group_word; + guint16 element_word; + gchar value_rep[3]; + guint32 element_length; + guint16 ctx_us; + guint8 *value; + guint32 tag; + + if (fread (&group_word, 1, 2, DICOM) == 0) + break; + group_word = g_ntohs (GUINT16_SWAP_LE_BE (group_word)); + + fread (&element_word, 1, 2, DICOM); + element_word = g_ntohs (GUINT16_SWAP_LE_BE (element_word)); + + if (group_word != 0x0002 && big_endian) + { + group_word = GUINT16_SWAP_LE_BE (group_word); + element_word = GUINT16_SWAP_LE_BE (element_word); + } + + tag = (group_word << 16) | element_word; + fread(value_rep, 2, 1, DICOM); + value_rep[2] = 0; + + /* Check if the value rep looks valid. There probably is a + better way of checking this... + */ + if ((/* Always need lookup for implicit encoding */ + tag > 0x0002ffff && implicit_encoding) + /* This heuristics isn't used if we are doing implicit + encoding according to the value representation... */ + || ((value_rep[0] < 'A' || value_rep[0] > 'Z' + || value_rep[1] < 'A' || value_rep[1] > 'Z') + + /* I found this in one of Ednas images. It seems like a + bug... + */ + && !(value_rep[0] == ' ' && value_rep[1])) + ) + { + /* Look up type from the dictionary. At the time we don't + support this option... */ + gchar element_length_chars[4]; + + /* Store the bytes that were read */ + element_length_chars[0] = value_rep[0]; + element_length_chars[1] = value_rep[1]; + + /* Unknown value rep. It is not used right now anyhow */ + strcpy (value_rep, "??"); + + /* For implicit value_values the length is always four bytes, + so we need to read another two. */ + fread (&element_length_chars[2], 1, 2, DICOM); + + /* Now cast to integer and insert into element_length */ + if (big_endian && group_word != 0x0002) + element_length = + g_ntohl (*((gint *) element_length_chars)); + else + element_length = + g_ntohl (GUINT32_SWAP_LE_BE (*((gint *) element_length_chars))); + } + /* Binary value reps are OB, OW, SQ or UN */ + else if (strncmp (value_rep, "OB", 2) == 0 + || strncmp (value_rep, "OW", 2) == 0 + || strncmp (value_rep, "SQ", 2) == 0 + || strncmp (value_rep, "UN", 2) == 0) + { + fread (&element_length, 1, 2, DICOM); /* skip two bytes */ + fread (&element_length, 1, 4, DICOM); + if (big_endian && group_word != 0x0002) + element_length = g_ntohl (element_length); + else + element_length = g_ntohl (GUINT32_SWAP_LE_BE (element_length)); + } + /* Short length */ + else + { + guint16 el16; + + fread (&el16, 1, 2, DICOM); + if (big_endian && group_word != 0x0002) + element_length = g_ntohs (el16); + else + element_length = g_ntohs (GUINT16_SWAP_LE_BE (el16)); + } + + /* Sequence of items - just ignore the delimiters... */ + if (element_length == 0xffffffff) + { + in_sequence = 1; + continue; + } + /* End of Sequence tag */ + if (tag == 0xFFFEE0DD) + { + in_sequence = 0; + continue; + } + + /* Sequence of items item tag... Ignore as well */ + if (tag == 0xFFFEE000) + continue; + + /* Even for pixel data, we don't handle very large element + lengths */ + + if (element_length >= (G_MAXUINT - 6)) + { + g_message ("'%s' seems to have an incorrect value field length.", + gimp_filename_to_utf8 (filename)); + gimp_quit (); + } + + /* Read contents. Allocate a bit more to make room for casts to int + below. */ + value = g_new0 (guint8, element_length + 4); + fread (value, 1, element_length, DICOM); + + /* ignore everything inside of a sequence */ + if (in_sequence) + { + g_free (value); + continue; + } + /* Some special casts that are used below */ + ctx_us = *(guint16 *) value; + if (big_endian && group_word != 0x0002) + ctx_us = GUINT16_SWAP_LE_BE (ctx_us); + + g_debug ("group: %04x, element: %04x, length: %d", + group_word, element_word, element_length); + g_debug ("Value: %s", (char*)value); + /* Recognize some critical tags */ + if (group_word == 0x0002) + { + switch (element_word) + { + case 0x0010: /* transfer syntax id */ + if (strcmp("1.2.840.10008.1.2", (char*)value) == 0) + { + implicit_encoding = TRUE; + g_debug ("Transfer syntax: Implicit VR Endian: Default Transfer Syntax for DICOM."); + } + else if (strcmp("1.2.840.10008.1.2.1", (char*)value) == 0) + { + g_debug ("Transfer syntax: Explicit VR Little Endian."); + } + else if (strcmp("1.2.840.10008.1.2.1.99", (char*)value) == 0) + { + g_debug ("Transfer syntax: Deflated Explicit VR Little Endian."); + } + else if (strcmp("1.2.840.10008.1.2.2", (char*)value) == 0) + { + /* This Transfer Syntax was retired in 2006. For the most recent description of it, see PS3.5 2016b */ + big_endian = TRUE; + g_debug ("Transfer syntax: Deprecated Explicit VR Big Endian."); + } + else + { + g_debug ("Transfer syntax %s is not supported by GIMP.", (gchar *) value); + g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, + _("Transfer syntax %s is not supported by GIMP."), + (gchar *) value); + g_free (dicominfo); + fclose (DICOM); + return -1; + } + break; + } + } + else if (group_word == 0x0028) + { + gboolean supported = TRUE; + + switch (element_word) + { + case 0x0002: /* samples per pixel */ + samples_per_pixel = ctx_us; + g_debug ("spp: %d", samples_per_pixel); + break; + case 0x0004: /* photometric interpretation */ + g_debug ("photometric interpretation: %s", (gchar *) value); + + if (samples_per_pixel == 1) + { + if (strncmp ((gchar *) value, "MONOCHROME1", 11) == 0) + { + /* The minimum sample value is intended to be displayed + * as white after any VOI gray scale transformations + * have been performed. */ + dicominfo->bw_inverted = TRUE; + } + else if (strncmp ((gchar *) value, "MONOCHROME2", 11) == 0) + { + /* The minimum sample value is intended to be displayed + * as black after any VOI gray scale transformations + * have been performed. */ + dicominfo->bw_inverted = FALSE; + } + else + supported = FALSE; + } + else if (samples_per_pixel == 3) + { + if (strncmp ((gchar *) value, "RGB", 2) != 0) + { + supported = FALSE; + } + } + else + { + supported = FALSE; + } + if (! supported) + { + g_set_error (error, GIMP_PLUG_IN_ERROR, 0, + _("%s is not supported by GIMP in combination " + "with samples per pixel: %d"), + (gchar *) value, samples_per_pixel); + g_free (dicominfo); + fclose (DICOM); + return -1; + } + + break; + case 0x0006: /* planar configuration */ + g_debug ("planar configuration: %u", ctx_us); + dicominfo->planar = (ctx_us == 1); + break; + case 0x0008: /* number of frames */ + g_debug ("number of frames: %d", ctx_us); + break; + case 0x0010: /* rows */ + height = ctx_us; + g_debug ("height: %d", height); + break; + case 0x0011: /* columns */ + width = ctx_us; + g_debug ("width: %d", width); + break; + case 0x0100: /* bits allocated */ + bpp = ctx_us; + g_debug ("bpp: %d", bpp); + break; + case 0x0101: /* bits stored */ + bits_stored = ctx_us; + g_debug ("bits stored: %d", bits_stored); + break; + case 0x0102: /* high bit */ + high_bit = ctx_us; + g_debug ("high bit: %d", high_bit); + break; + case 0x0103: /* is pixel representation signed? */ + is_signed = (ctx_us == 0) ? FALSE : TRUE; + g_debug ("is signed: %d", ctx_us); + break; + } + } + + /* Pixel data */ + if (group_word == 0x7fe0 && element_word == 0x0010) + { + pix_buf = value; + } + else + { + /* save this element to a parasite for later writing */ + GimpParasite *parasite; + gchar pname[255]; + + /* all elements are retrievable using gimp_get_parasite_list() */ + g_snprintf (pname, sizeof (pname), + "dcm/%04x-%04x-%s", group_word, element_word, value_rep); + if ((parasite = gimp_parasite_new (pname, + GIMP_PARASITE_PERSISTENT, + element_length, value))) + { + /* + * at this point, the image has not yet been created, so + * image_ID is not valid. keep the parasite around + * until we're able to attach it. + */ + + /* add to our list of parasites to be added (prepending + * for speed. we'll reverse it later) + */ + elements = g_slist_prepend (elements, parasite); + } + + g_free (value); + } + } + + if ((bpp != 8) && (bpp != 16)) + { + g_message ("'%s' has a bpp of %d which GIMP cannot handle.", + gimp_filename_to_utf8 (filename), bpp); + gimp_quit (); + } + + if ((width > GIMP_MAX_IMAGE_SIZE) || (height > GIMP_MAX_IMAGE_SIZE)) + { + g_message ("'%s' has a larger image size (%d x %d) than GIMP can handle.", + gimp_filename_to_utf8 (filename), width, height); + gimp_quit (); + } + + if (samples_per_pixel > 3) + { + g_message ("'%s' has samples per pixel of %d which GIMP cannot handle.", + gimp_filename_to_utf8 (filename), samples_per_pixel); + gimp_quit (); + } + + dicominfo->width = width; + dicominfo->height = height; + dicominfo->bpp = bpp; + + dicominfo->bits_stored = bits_stored; + dicominfo->high_bit = high_bit; + dicominfo->is_signed = is_signed; + dicominfo->samples_per_pixel = samples_per_pixel; + dicominfo->maxval = -1; /* External normalization factor - not used yet */ + + /* Create a new image of the proper size and associate the filename with it. + */ + image_ID = gimp_image_new (dicominfo->width, dicominfo->height, + (dicominfo->samples_per_pixel >= 3 ? + GIMP_RGB : GIMP_GRAY)); + gimp_image_set_filename (image_ID, filename); + + layer_ID = gimp_layer_new (image_ID, _("Background"), + dicominfo->width, dicominfo->height, + (dicominfo->samples_per_pixel >= 3 ? + GIMP_RGB_IMAGE : GIMP_GRAY_IMAGE), + 100, + gimp_image_get_default_new_layer_mode (image_ID)); + gimp_image_insert_layer (image_ID, layer_ID, -1, 0); + + buffer = gimp_drawable_get_buffer (layer_ID); + +#if GUESS_ENDIAN + if (bpp == 16) + guess_and_set_endian2 ((guint16 *) pix_buf, width * height); +#endif + + dicom_loader (pix_buf, dicominfo, buffer); + + if (elements) + { + /* flip the parasites back around into the order they were + * created (read from the file) + */ + elements = g_slist_reverse (elements); + /* and add each one to the image */ + g_slist_foreach (elements, add_parasites_to_image, (gpointer) &image_ID); + g_slist_free (elements); + } + + g_free (pix_buf); + g_free (dicominfo); + + fclose (DICOM); + + g_object_unref (buffer); + + return image_ID; +} + +static void +dicom_loader (guint8 *pix_buffer, + DicomInfo *info, + GeglBuffer *buffer) +{ + guchar *data; + gint row_idx; + gint width = info->width; + gint height = info->height; + gint samples_per_pixel = info->samples_per_pixel; + guint16 *buf16 = (guint16 *) pix_buffer; + + if (info->bpp == 16) + { + gulong pix_idx; + guint shift = info->high_bit + 1 - info->bits_stored; + + /* Reorder the buffer; also shift the data so that the LSB + * of the pixel data is at the LSB of the 16-bit array entries + * (i.e., compensate for high_bit and bits_stored). + */ + for (pix_idx = 0; pix_idx < width * height * samples_per_pixel; pix_idx++) + buf16[pix_idx] = g_ntohs (GUINT16_SWAP_LE_BE (buf16[pix_idx])) >> shift; + } + + data = g_malloc (gimp_tile_height () * width * samples_per_pixel); + + for (row_idx = 0; row_idx < height; ) + { + guchar *d = data; + gint start; + gint end; + gint scanlines; + gint i; + + start = row_idx; + end = row_idx + gimp_tile_height (); + end = MIN (end, height); + + scanlines = end - start; + + for (i = 0; i < scanlines; i++) + { + if (info->bpp == 16) + { + guint16 *row_start; + gint col_idx; + + row_start = buf16 + (row_idx + i) * width * samples_per_pixel; + + for (col_idx = 0; col_idx < width * samples_per_pixel; col_idx++) + { + /* Shift it by 8 bits, or less in case bits_stored + * is less than bpp. + */ + d[col_idx] = (guint8) (row_start[col_idx] >> + (info->bits_stored - 8)); + if (info->bw_inverted) + { + d[col_idx] = ~d[col_idx]; + } + + if (info->is_signed) + { + /* If the data is negative, make it 0. Otherwise, + * multiply the positive value by 2, so that the + * positive values span between 0 and 254. + */ + if (d[col_idx] > 127) + d[col_idx] = 0; + else + d[col_idx] <<= 1; + } + } + } + else if (info->bpp == 8) + { + if (! info->planar) + { + guint8 *row_start; + gint col_idx; + + row_start = (pix_buffer + + (row_idx + i) * width * samples_per_pixel); + + for (col_idx = 0; col_idx < width * samples_per_pixel; col_idx++) + { + /* Shift it by 0 bits, or more in case bits_stored is + * less than bpp. + */ + d[col_idx] = row_start[col_idx] << (8 - info->bits_stored); + if (info->bw_inverted) + { + d[col_idx] = ~d[col_idx]; + } + + if (info->is_signed) + { + /* If the data is negative, make it 0. Otherwise, + * multiply the positive value by 2, so that the + * positive values span between 0 and 254. + */ + if (d[col_idx] > 127) + d[col_idx] = 0; + else + d[col_idx] <<= 1; + } + } + } + else + { + /* planar organization of color data */ + guint8 *row_start; + gint col_idx; + gint plane_size = width * height; + + row_start = (pix_buffer + (row_idx + i) * width); + + for (col_idx = 0; col_idx < width; col_idx++) + { + /* Shift it by 0 bits, or more in case bits_stored is + * less than bpp. + */ + gint pix_idx; + gint src_offset = col_idx; + + for (pix_idx = 0; pix_idx < samples_per_pixel; pix_idx++) + { + gint dest_idx = col_idx * samples_per_pixel + pix_idx; + + d[dest_idx] = row_start[src_offset] << (8 - info->bits_stored); + if (info->is_signed) + { + /* If the data is negative, make it 0. Otherwise, + * multiply the positive value by 2, so that the + * positive values span between 0 and 254. + */ + if (d[dest_idx] > 127) + d[dest_idx] = 0; + else + d[dest_idx] <<= 1; + } + src_offset += plane_size; + } + } + } + } + + d += width * samples_per_pixel; + } + + gegl_buffer_set (buffer, GEGL_RECTANGLE (0, row_idx, width, scanlines), 0, + NULL, data, GEGL_AUTO_ROWSTRIDE); + + row_idx += scanlines; + + gimp_progress_update ((gdouble) row_idx / (gdouble) height); + } + + g_free (data); + + gimp_progress_update (1.0); +} + + +/* Guess and set endian. Guesses the endian of a buffer by + * checking the maximum value of the first and the last byte + * in the words of the buffer. It assumes that the least + * significant byte has a larger maximum than the most + * significant byte. + */ +static void +guess_and_set_endian2 (guint16 *buf16, + int length) +{ + guint16 *p = buf16; + gint max_first = -1; + gint max_second = -1; + + while (p max_first) + max_first = *(guint8*)p; + if (((guint8*)p)[1] > max_second) + max_second = ((guint8*)p)[1]; + p++; + } + + if ( ((max_second > max_first) && (G_BYTE_ORDER == G_LITTLE_ENDIAN)) + || ((max_second < max_first) && (G_BYTE_ORDER == G_BIG_ENDIAN))) + toggle_endian2 (buf16, length); +} + +/* toggle_endian2 toggles the endian for a 16 bit entity. */ +static void +toggle_endian2 (guint16 *buf16, + gint length) +{ + guint16 *p = buf16; + + while (p < buf16 + length) + { + *p = ((*p & 0xff) << 8) | (*p >> 8); + p++; + } +} + +typedef struct +{ + guint16 group_word; + guint16 element_word; + gchar value_rep[3]; + guint32 element_length; + guint8 *value; + gboolean free; +} DICOMELEMENT; + +/** + * dicom_add_element: + * @elements: head of a GSList containing DICOMELEMENT structures. + * @group_word: Dicom Element group number for the tag to be added to + * @elements. + * @element_word: Dicom Element element number for the tag to be added + * to @elements. + * @value_rep: a string representing the Dicom VR for the new element. + * @value: a pointer to an integer containing the value for the + * element to be created. + * + * Creates a DICOMELEMENT object and inserts it into @elements. + * + * Return value: the new head of @elements +**/ +static GSList * +dicom_add_element (GSList *elements, + guint16 group_word, + guint16 element_word, + const gchar *value_rep, + guint32 element_length, + guint8 *value) +{ + DICOMELEMENT *element = g_slice_new0 (DICOMELEMENT); + + element->group_word = group_word; + element->element_word = element_word; + strncpy (element->value_rep, value_rep, sizeof (element->value_rep)); + element->element_length = element_length; + element->value = value; + + return g_slist_prepend (elements, element); +} + +static GSList * +dicom_add_element_copy (GSList *elements, + guint16 group_word, + guint16 element_word, + gchar *value_rep, + guint32 element_length, + const guint8 *value) +{ + elements = dicom_add_element (elements, + group_word, element_word, value_rep, + element_length, + g_memdup (value, element_length)); + + ((DICOMELEMENT *) elements->data)->free = TRUE; + + return elements; +} + +/** + * dicom_add_element_int: + * @elements: head of a GSList containing DICOMELEMENT structures. + + * @group_word: Dicom Element group number for the tag to be added to + * @elements. + * @element_word: Dicom Element element number for the tag to be added to + * @elements. + * @value_rep: a string representing the Dicom VR for the new element. + * @value: a pointer to an integer containing the value for the + * element to be created. + * + * Creates a DICOMELEMENT object from the passed integer pointer and + * adds it to @elements. Note: value should be the address of a + * guint16 for @value_rep == %US or guint32 for other values of + * @value_rep + * + * Return value: the new head of @elements + */ +static GSList * +dicom_add_element_int (GSList *elements, + guint16 group_word, + guint16 element_word, + gchar *value_rep, + guint8 *value) +{ + guint32 len; + + if (strcmp (value_rep, "US") == 0) + len = 2; + else + len = 4; + + return dicom_add_element (elements, + group_word, element_word, value_rep, + len, value); +} + +/** + * dicom_element_done: + * @data: pointer to a DICOMELEMENT structure which is to be destroyed. + * + * Destroys the DICOMELEMENT passed as @data +**/ +static void +dicom_element_done (gpointer data) +{ + if (data) + { + DICOMELEMENT *e = data; + + if (e->free) + g_free (e->value); + + g_slice_free (DICOMELEMENT, data); + } +} + +/** + * dicom_elements_destroy: + * @elements: head of a GSList containing DICOMELEMENT structures. + * + * Destroys the list of DICOMELEMENTs +**/ +static void +dicom_elements_destroy (GSList *elements) +{ + if (elements) + g_slist_free_full (elements, dicom_element_done); +} + +/** + * dicom_destroy_element: + * @elements: head of a GSList containing DICOMELEMENT structures. + * @ele: a DICOMELEMENT structure to be removed from @elements + * + * Removes the specified DICOMELEMENT from @elements and Destroys it + * + * Return value: the new head of @elements +**/ +static GSList * +dicom_destroy_element (GSList *elements, + DICOMELEMENT *ele) +{ + if (ele) + { + elements = g_slist_remove_all (elements, ele); + + if (ele->free) + g_free (ele->value); + + g_slice_free (DICOMELEMENT, ele); + } + + return elements; +} + +/** + * dicom_elements_compare: + * @a: pointer to a DICOMELEMENT structure. + * @b: pointer to a DICOMELEMENT structure. + * + * Determines the equality of @a and @b as strcmp + * + * Return value: an integer indicating the equality of @a and @b. +**/ +static gint +dicom_elements_compare (gconstpointer a, + gconstpointer b) +{ + DICOMELEMENT *e1 = (DICOMELEMENT *)a; + DICOMELEMENT *e2 = (DICOMELEMENT *)b; + + if (e1->group_word == e2->group_word) + { + if (e1->element_word == e2->element_word) + { + return 0; + } + else if (e1->element_word > e2->element_word) + { + return 1; + } + else + { + return -1; + } + } + else if (e1->group_word < e2->group_word) + { + return -1; + } + + return 1; +} + +/** + * dicom_element_find_by_num: + * @head: head of a GSList containing DICOMELEMENT structures. + * @group_word: Dicom Element group number for the tag to be found. + * @element_word: Dicom Element element number for the tag to be found. + * + * Retrieves the specified DICOMELEMENT from @head, if available. + * + * Return value: a DICOMELEMENT matching the specified group,element, + * or NULL if the specified element was not found. +**/ +static DICOMELEMENT * +dicom_element_find_by_num (GSList *head, + guint16 group_word, + guint16 element_word) +{ + DICOMELEMENT data = { group_word,element_word, "", 0, NULL}; + GSList *ele = g_slist_find_custom (head,&data,dicom_elements_compare); + return (ele ? ele->data : NULL); +} + +/** + * dicom_get_elements_list: + * @image_ID: the image_ID from which to read parasites in order to + * retrieve the dicom elements + * + * Reads all DICOMELEMENTs from the specified image's parasites. + * + * Return value: a GSList of all known dicom elements +**/ +static GSList * +dicom_get_elements_list (gint32 image_ID) +{ + GSList *elements = NULL; + GimpParasite *parasite; + gchar **parasites = NULL; + gint count = 0; + + parasites = gimp_image_get_parasite_list (image_ID, &count); + + if (parasites && count > 0) + { + gint i; + + for (i = 0; i < count; i++) + { + if (strncmp (parasites[i], "dcm", 3) == 0) + { + parasite = gimp_image_get_parasite (image_ID, parasites[i]); + + if (parasite) + { + gchar buf[1024]; + gchar *ptr1; + gchar *ptr2; + gchar value_rep[3] = ""; + guint16 group_word = 0; + guint16 element_word = 0; + + /* sacrificial buffer */ + strncpy (buf, parasites[i], sizeof (buf)); + + /* buf should now hold a string of the form + * dcm/XXXX-XXXX-AA where XXXX are Hex values for + * group and element respectively AA is the Value + * Representation of the element + * + * start off by jumping over the dcm/ to the first Hex blob + */ + ptr1 = strchr (buf, '/'); + + if (ptr1) + { + gchar t[15]; + + ptr1++; + ptr2 = strchr (ptr1,'-'); + + if (ptr2) + *ptr2 = '\0'; + + g_snprintf (t, sizeof (t), "0x%s", ptr1); + group_word = (guint16) g_ascii_strtoull (t, NULL, 16); + ptr1 = ptr2 + 1; + } + + /* now get the second Hex blob */ + if (ptr1) + { + gchar t[15]; + + ptr2 = strchr (ptr1, '-'); + + if (ptr2) + *ptr2 = '\0'; + + g_snprintf (t, sizeof (t), "0x%s", ptr1); + element_word = (guint16) g_ascii_strtoull (t, NULL, 16); + ptr1 = ptr2 + 1; + } + + /* and lastly, the VR */ + if (ptr1) + strncpy (value_rep, ptr1, sizeof (value_rep)); + + /* + * If all went according to plan, we should be able + * to add this element + */ + if (group_word > 0 && element_word > 0) + { + const guint8 *val = gimp_parasite_data (parasite); + const guint len = gimp_parasite_data_size (parasite); + + /* and add the dicom element, asking to have + it's value copied for later garbage collection */ + elements = dicom_add_element_copy (elements, + group_word, + element_word, + value_rep, len, val); + } + + gimp_parasite_free (parasite); + } + } + } + } + + /* cleanup the array of names */ + g_strfreev (parasites); + + return elements; +} + +/** + * dicom_remove_gimp_specified_elements: + * @elements: GSList to remove elements from + * @samples_per_pixel: samples per pixel of the image to be written. + * if set to %3 the planar configuration for color images + * will also be removed from @elements + * + * Removes certain DICOMELEMENTs from the elements list which are specific to the output of this plugin. + * + * Return value: the new head of @elements +**/ +static GSList * +dicom_remove_gimp_specified_elements (GSList *elements, + gint samples_per_pixel) +{ + DICOMELEMENT remove[] = { + /* Image presentation group */ + /* Samples per pixel */ + {0x0028, 0x0002, "", 0, NULL}, + /* Photometric interpretation */ + {0x0028, 0x0004, "", 0, NULL}, + /* rows */ + {0x0028, 0x0010, "", 0, NULL}, + /* columns */ + {0x0028, 0x0011, "", 0, NULL}, + /* Bits allocated */ + {0x0028, 0x0100, "", 0, NULL}, + /* Bits Stored */ + {0x0028, 0x0101, "", 0, NULL}, + /* High bit */ + {0x0028, 0x0102, "", 0, NULL}, + /* Pixel representation */ + {0x0028, 0x0103, "", 0, NULL}, + + {0,0,"",0,NULL} + }; + DICOMELEMENT *ele; + gint i; + + /* + * Remove all Dicom elements which will be set as part of the writing of the new file + */ + for (i=0; remove[i].group_word > 0;i++) + { + if ((ele = dicom_element_find_by_num (elements,remove[i].group_word,remove[i].element_word))) + { + elements = dicom_destroy_element (elements,ele); + } + } + /* special case - allow this to be overwritten if necessary */ + if (samples_per_pixel == 3) + { + /* Planar configuration for color images */ + if ((ele = dicom_element_find_by_num (elements,0x0028,0x0006))) + { + elements = dicom_destroy_element (elements,ele); + } + } + return elements; +} + +/** + * dicom_ensure_required_elements_present: + * @elements: GSList to remove elements from + * @today_string: string containing today's date in DICOM format. This + * is used to default any required Dicom elements of date + * type to today's date. + * + * Defaults DICOMELEMENTs to the values set by previous version of + * this plugin, but only if they do not already exist. + * + * Return value: the new head of @elements +**/ +static GSList * +dicom_ensure_required_elements_present (GSList *elements, + gchar *today_string) +{ + const DICOMELEMENT defaults[] = { + /* Meta element group */ + /* 0002, 0001 - File Meta Information Version */ + { 0x0002, 0x0001, "OB", 2, (guint8 *) "\0\1" }, + /* 0002, 0010 - Transfer syntax uid */ + { 0x0002, 0x0010, "UI", + strlen ("1.2.840.10008.1.2.1"), (guint8 *) "1.2.840.10008.1.2.1"}, + /* 0002, 0013 - Implementation version name */ + { 0x0002, 0x0013, "SH", + strlen ("GIMP Dicom Plugin 1.0"), (guint8 *) "GIMP Dicom Plugin 1.0" }, + /* Identifying group */ + /* ImageType */ + { 0x0008, 0x0008, "CS", + strlen ("ORIGINAL\\PRIMARY"), (guint8 *) "ORIGINAL\\PRIMARY" }, + { 0x0008, 0x0016, "UI", + strlen ("1.2.840.10008.5.1.4.1.1.7"), (guint8 *) "1.2.840.10008.5.1.4.1.1.7" }, + /* Study date */ + { 0x0008, 0x0020, "DA", + strlen (today_string), (guint8 *) today_string }, + /* Series date */ + { 0x0008, 0x0021, "DA", + strlen (today_string), (guint8 *) today_string }, + /* Acquisition date */ + { 0x0008, 0x0022, "DA", + strlen (today_string), (guint8 *) today_string }, + /* Content Date */ + { 0x0008, 0x0023, "DA", + strlen (today_string), (guint8 *) today_string}, + /* Content Time */ + { 0x0008, 0x0030, "TM", + strlen ("000000.000000"), (guint8 *) "000000.000000"}, + /* AccessionNumber */ + { 0x0008, 0x0050, "SH", strlen (""), (guint8 *) "" }, + /* Modality */ + { 0x0008, 0x0060, "CS", strlen ("MR"), (guint8 *) "MR" }, + /* ConversionType */ + { 0x0008, 0x0064, "CS", strlen ("WSD"), (guint8 *) "WSD" }, + /* ReferringPhysiciansName */ + { 0x0008, 0x0090, "PN", strlen (""), (guint8 *) "" }, + /* Patient group */ + /* Patient name */ + { 0x0010, 0x0010, "PN", + strlen ("DOE^WILBER"), (guint8 *) "DOE^WILBER" }, + /* Patient ID */ + { 0x0010, 0x0020, "LO", + strlen ("314159265"), (guint8 *) "314159265" }, + /* Patient Birth date */ + { 0x0010, 0x0030, "DA", + strlen (today_string), (guint8 *) today_string }, + /* Patient sex */ + { 0x0010, 0x0040, "CS", strlen (""), (guint8 *) "" /* unknown */ }, + /* Relationship group */ + /* StudyId */ + { 0x0020, 0x0010, "IS", strlen ("1"), (guint8 *) "1" }, + /* SeriesNumber */ + { 0x0020, 0x0011, "IS", strlen ("1"), (guint8 *) "1" }, + /* AcquisitionNumber */ + { 0x0020, 0x0012, "IS", strlen ("1"), (guint8 *) "1" }, + /* Instance number */ + { 0x0020, 0x0013, "IS", strlen ("1"), (guint8 *) "1" }, + + { 0, 0, "", 0, NULL } + }; + gint i; + + /* + * Make sure that all of the default elements have a value + */ + for (i=0; defaults[i].group_word > 0; i++) + { + if (dicom_element_find_by_num (elements, + defaults[i].group_word, + defaults[i].element_word) == NULL) + { + elements = dicom_add_element (elements, + defaults[i].group_word, + defaults[i].element_word, + defaults[i].value_rep, + defaults[i].element_length, + defaults[i].value); + } + } + + return elements; +} + +/* save_image() saves an image in the dicom format. The DICOM format + * requires a lot of tags to be set. Some of them have real uses, others + * must just be filled with dummy values. + */ +static gboolean +save_image (const gchar *filename, + gint32 image_ID, + gint32 drawable_ID, + GError **error) +{ + FILE *DICOM; + GimpImageType drawable_type; + GeglBuffer *buffer; + const Babl *format; + gint width; + gint height; + GByteArray *group_stream; + GSList *elements = NULL; + gint group; + GDate *date; + gchar today_string[16]; + gchar *photometric_interp; + gint samples_per_pixel; + gboolean retval = TRUE; + guint16 zero = 0; + guint16 seven = 7; + guint16 eight = 8; + guchar *src = NULL; + + drawable_type = gimp_drawable_type (drawable_ID); + + /* Make sure we're not saving an image with an alpha channel */ + if (gimp_drawable_has_alpha (drawable_ID)) + { + g_message (_("Cannot save images with alpha channel.")); + return FALSE; + } + + switch (drawable_type) + { + case GIMP_GRAY_IMAGE: + format = babl_format ("Y' u8"); + samples_per_pixel = 1; + photometric_interp = "MONOCHROME2"; + break; + + case GIMP_RGB_IMAGE: + format = babl_format ("R'G'B' u8"); + samples_per_pixel = 3; + photometric_interp = "RGB"; + break; + + default: + g_message (_("Cannot operate on unknown image types.")); + return FALSE; + } + + date = g_date_new (); + g_date_set_time_t (date, time (NULL)); + g_snprintf (today_string, sizeof (today_string), + "%04d%02d%02d", date->year, date->month, date->day); + g_date_free (date); + + /* Open the output file. */ + DICOM = g_fopen (filename, "wb"); + + if (!DICOM) + { + g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), + _("Could not open '%s' for writing: %s"), + gimp_filename_to_utf8 (filename), g_strerror (errno)); + return FALSE; + } + + buffer = gimp_drawable_get_buffer (drawable_ID); + + width = gegl_buffer_get_width (buffer); + height = gegl_buffer_get_height (buffer); + + /* Print dicom header */ + { + guint8 val = 0; + gint i; + + for (i = 0; i < 0x80; i++) + fwrite (&val, 1, 1, DICOM); + } + fprintf (DICOM, "DICM"); + + group_stream = g_byte_array_new (); + + elements = dicom_get_elements_list (image_ID); + if (0/*replaceElementsList*/) + { + /* to do */ + } + else if (1/*insist_on_basic_elements*/) + { + elements = dicom_ensure_required_elements_present (elements,today_string); + } + + /* + * Set value of custom elements + */ + elements = dicom_remove_gimp_specified_elements (elements,samples_per_pixel); + + /* Image presentation group */ + group = 0x0028; + /* Samples per pixel */ + elements = dicom_add_element_int (elements, group, 0x0002, "US", + (guint8 *) &samples_per_pixel); + /* Photometric interpretation */ + elements = dicom_add_element (elements, group, 0x0004, "CS", + strlen (photometric_interp), + (guint8 *) photometric_interp); + /* Planar configuration for color images */ + if (samples_per_pixel == 3) + elements = dicom_add_element_int (elements, group, 0x0006, "US", + (guint8 *) &zero); + /* rows */ + elements = dicom_add_element_int (elements, group, 0x0010, "US", + (guint8 *) &height); + /* columns */ + elements = dicom_add_element_int (elements, group, 0x0011, "US", + (guint8 *) &width); + /* Bits allocated */ + elements = dicom_add_element_int (elements, group, 0x0100, "US", + (guint8 *) &eight); + /* Bits Stored */ + elements = dicom_add_element_int (elements, group, 0x0101, "US", + (guint8 *) &eight); + /* High bit */ + elements = dicom_add_element_int (elements, group, 0x0102, "US", + (guint8 *) &seven); + /* Pixel representation */ + elements = dicom_add_element_int (elements, group, 0x0103, "US", + (guint8 *) &zero); + + /* Pixel data */ + group = 0x7fe0; + src = g_new (guchar, height * width * samples_per_pixel); + if (src) + { + gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, width, height), 1.0, + format, src, + GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); + + elements = dicom_add_element (elements, group, 0x0010, "OW", + width * height * samples_per_pixel, + (guint8 *) src); + + elements = dicom_add_tags (DICOM, group_stream, elements); + + g_free (src); + } + else + { + retval = FALSE; + } + + fclose (DICOM); + + dicom_elements_destroy (elements); + g_byte_array_free (group_stream, TRUE); + g_object_unref (buffer); + + return retval; +} + +/** + * dicom_print_tags: + * @data: pointer to a DICOMELEMENT structure which is to be written to file + * @user_data: structure containing state information and output parameters + * + * Writes the specified DICOMELEMENT to @user_data's group_stream member. + * Between groups, flushes the group_stream to @user_data's DICOM member. + */ +static void +dicom_print_tags(gpointer data, + gpointer user_data) +{ + struct { + FILE *DICOM; + GByteArray *group_stream; + gint last_group; + } *d = user_data; + DICOMELEMENT *e = (DICOMELEMENT *) data; + + if (d->last_group >= 0 && e->group_word != d->last_group) + { + write_group_to_file (d->DICOM, d->last_group, d->group_stream); + } + + add_tag_pointer (d->group_stream, + e->group_word, e->element_word, + e->value_rep,e->value, e->element_length); + d->last_group = e->group_word; +} + +/** + * dicom_add_tags: + * @DICOM: File pointer to which @elements should be written. + * @group_stream: byte array used for staging Dicom Element groups + * before flushing them to disk. + * @elements: GSList container the Dicom Element elements from + * + * Writes all Dicom tags in @elements to the file @DICOM + * + * Return value: the new head of @elements +**/ +static GSList * +dicom_add_tags (FILE *DICOM, + GByteArray *group_stream, + GSList *elements) +{ + struct { + FILE *DICOM; + GByteArray *group_stream; + gint last_group; + } data = { DICOM, group_stream, -1 }; + + elements = g_slist_sort (elements, dicom_elements_compare); + g_slist_foreach (elements, dicom_print_tags, &data); + /* make sure that the final group is written to the file */ + write_group_to_file (data.DICOM, data.last_group, data.group_stream); + + return elements; +} + +/* add_tag_pointer () adds to the group_stream one single value with its + * corresponding value_rep. Note that we use "explicit VR". + */ +static void +add_tag_pointer (GByteArray *group_stream, + gint group, + gint element, + const gchar *value_rep, + const guint8 *data, + gint length) +{ + gboolean is_long; + guint16 swapped16; + guint32 swapped32; + guint pad = 0; + + is_long = (strstr ("OB|OW|SQ|UN", value_rep) != NULL) || length > 65535; + + swapped16 = g_ntohs (GUINT16_SWAP_LE_BE (group)); + g_byte_array_append (group_stream, (guint8 *) &swapped16, 2); + + swapped16 = g_ntohs (GUINT16_SWAP_LE_BE (element)); + g_byte_array_append (group_stream, (guint8 *) &swapped16, 2); + + g_byte_array_append (group_stream, (const guchar *) value_rep, 2); + + if (length % 2 != 0) + { + /* the dicom standard requires all elements to be of even byte + * length. this element would be odd, so we must pad it before + * adding it + */ + pad = 1; + } + + if (is_long) + { + + g_byte_array_append (group_stream, (const guchar *) "\0\0", 2); + + swapped32 = g_ntohl (GUINT32_SWAP_LE_BE (length + pad)); + g_byte_array_append (group_stream, (guint8 *) &swapped32, 4); + } + else + { + swapped16 = g_ntohs (GUINT16_SWAP_LE_BE (length + pad)); + g_byte_array_append (group_stream, (guint8 *) &swapped16, 2); + } + + g_byte_array_append (group_stream, data, length); + + if (pad) + { + /* add a padding byte to the stream + * + * From ftp://medical.nema.org/medical/dicom/2009/09_05pu3.pdf: + * + * Values with VRs constructed of character strings, except in + * the case of the VR UI, shall be padded with SPACE characters + * (20H, in the Default Character Repertoire) when necessary to + * achieve even length. Values with a VR of UI shall be padded + * with a single trailing NULL (00H) character when necessary + * to achieve even length. Values with a VR of OB shall be + * padded with a single trailing NULL byte value (00H) when + * necessary to achieve even length. + */ + if (strstr ("UI|OB", value_rep) != NULL) + { + g_byte_array_append (group_stream, (guint8 *) "\0", 1); + } + else + { + g_byte_array_append (group_stream, (guint8 *) " ", 1); + } + } +} + +/* Once a group has been built it has to be wrapped with a meta-group + * tag before it is written to the DICOM file. This is done by + * write_group_to_file. + */ +static gboolean +write_group_to_file (FILE *DICOM, + gint group, + GByteArray *group_stream) +{ + gboolean retval = TRUE; + guint16 swapped16; + guint32 swapped32; + + /* Add header to the group and output it */ + swapped16 = g_ntohs (GUINT16_SWAP_LE_BE (group)); + + fwrite ((gchar *) &swapped16, 1, 2, DICOM); + fputc (0, DICOM); + fputc (0, DICOM); + fputc ('U', DICOM); + fputc ('L', DICOM); + + swapped16 = g_ntohs (GUINT16_SWAP_LE_BE (4)); + fwrite ((gchar *) &swapped16, 1, 2, DICOM); + + swapped32 = g_ntohl (GUINT32_SWAP_LE_BE (group_stream->len)); + fwrite ((gchar *) &swapped32, 1, 4, DICOM); + + if (fwrite (group_stream->data, + 1, group_stream->len, DICOM) != group_stream->len) + retval = FALSE; + + g_byte_array_set_size (group_stream, 0); + + return retval; +} -- cgit v1.2.3