Doxygen Source Code Documentation
mri_dicom_hdr.c File Reference
#include <stdio.h>#include <stdlib.h>#include <string.h>#include <sys/types.h>#include <errno.h>#include <stdarg.h>#include <ctype.h>#include "mri_dicom_hdr.h"#include "mcw_malloc.h"#include "Amalloc.h"#include "debugtrace.h"Go to the source code of this file.
Define Documentation
|
|
Definition at line 79 of file mri_dicom_hdr.c. Referenced by copyData(), DCM_GetCompressedValue(), DCM_GetElementValue(), DCM_GetElementValueOffset(), and RWC_set_endianosity(). |
|
|
Definition at line 78 of file mri_dicom_hdr.c. Referenced by exportData(), exportFixedFields(), exportVRLength(), readData(), readFile(), readGroupElement(), readVRLength(), and RWC_set_endianosity(). |
|
|
Definition at line 10720 of file mri_dicom_hdr.c. Referenced by LST_Insert(), LST_Next(), LST_Position(), LST_Previous(), and LST_Remove(). |
|
|
Definition at line 352 of file mri_dicom_hdr.c. Referenced by COND_PushCondition(). |
|
|
Definition at line 80 of file mri_dicom_hdr.c. Referenced by DCM_GetCompressedValue(), exportStream(), extractFileOptions(), newElementItem(), readFile(), and readFile1(). |
|
|
Definition at line 112 of file mri_dicom_hdr.c. Referenced by RWC_printf(). |
|
|
Definition at line 10721 of file mri_dicom_hdr.c. Referenced by LST_Insert(), and LST_Remove(). |
|
|
Definition at line 10722 of file mri_dicom_hdr.c. Referenced by LST_Insert(), and LST_Remove(). |
|
|
Definition at line 163 of file mri_dicom_hdr.c. Referenced by DCM_DumpElements(), and mri_dicom_nohex(). |
|
|
Definition at line 162 of file mri_dicom_hdr.c. Referenced by DCM_DumpElements(), and mri_dicom_noname(). |
Typedef Documentation
|
|
|
Function Documentation
|
||||||||||||||||||||
|
Definition at line 6858 of file mri_dicom_hdr.c. References COND_PushCondition(), CTNBOOLEAN, DCM_ELEMENTOUTOFORDER, DCM_Message(), DCM_NORMAL, DCM_REPEATEDELEMENT, DCM_TAG_ELEMENT, DCM_TAG_GROUP, and DCM_ELEMENT::tag.
06860 {
06861 unsigned short group;
06862 unsigned short element;
06863
06864 group = DCM_TAG_GROUP(e->tag);
06865 element = DCM_TAG_ELEMENT(e->tag);
06866
06867 if ((long) group == *lastGroup) {
06868 if (((long) element == *lastElement) && allowRepeatElements) {
06869 return DCM_REPEATEDELEMENT;
06870 }
06871 if ((long) element <= *lastElement)
06872 return COND_PushCondition(DCM_ELEMENTOUTOFORDER,
06873 DCM_Message(DCM_ELEMENTOUTOFORDER),
06874 group, element, "checkAttributeOrder");
06875 } else if ((long) group > *lastGroup) {
06876 } else {
06877 return COND_PushCondition(DCM_ELEMENTOUTOFORDER,
06878 DCM_Message(DCM_ELEMENTOUTOFORDER),
06879 group, element, "checkAttributeOrder");
06880 }
06881 *lastGroup = (long) group;
06882 *lastElement = (long) element;
06883
06884 return DCM_NORMAL;
06885 }
|
|
||||||||||||
|
Definition at line 4987 of file mri_dicom_hdr.c. References COND_PushCondition(), DCM_ILLEGALOBJECT, DCM_Message(), DCM_NORMAL, DCM_NULLOBJECT, KEY_DCM_OBJECT, and object.
04988 {
04989 if (object == NULL)
04990 return COND_PushCondition(DCM_NULLOBJECT, DCM_Message(DCM_NULLOBJECT),
04991 caller);
04992 if (*object == NULL)
04993 return COND_PushCondition(DCM_NULLOBJECT, DCM_Message(DCM_NULLOBJECT),
04994 caller);
04995
04996 if (strcmp((*object)->keyType, KEY_DCM_OBJECT) != 0)
04997 return COND_PushCondition(DCM_ILLEGALOBJECT,
04998 DCM_Message(DCM_ILLEGALOBJECT), caller);
04999 return DCM_NORMAL;
05000 }
|
|
||||||||||||||||||||
|
Definition at line 7597 of file mri_dicom_hdr.c. References PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, LST_Head(), LST_Next(), LST_Position(), and DCM_ELEMENT::tag.
07602 {
07603 PRV_ELEMENT_ITEM *e1 = NULL,
07604 *e2 = NULL;
07605
07606 if (g1 != NULL) {
07607 e1 = (void *)LST_Head(&g1->elementList);
07608 if (e1 != NULL)
07609 LST_Position(&g1->elementList, (void *)e1);
07610 }
07611 if (g2 != NULL) {
07612 e2 = (void *)LST_Head(&g2->elementList);
07613 if (e2 != NULL)
07614 LST_Position(&g2->elementList, (void *)e2);
07615 }
07616 while (e1 != NULL) {
07617 if (e2 == NULL) {
07618 callback(&e1->element, NULL, ctx);
07619 e1 = (void *)LST_Next(&g1->elementList);
07620 } else if (e1->element.tag == e2->element.tag) {
07621 callback(&e1->element, &e2->element, ctx);
07622 e1 = (void *)LST_Next(&g1->elementList);
07623 e2 = (void *)LST_Next(&g2->elementList);
07624 } else if (e1->element.tag < e2->element.tag) {
07625 callback(&e1->element, NULL, ctx);
07626 e1 = (void *)LST_Next(&g1->elementList);
07627 } else {
07628 callback(NULL, &e2->element, ctx);
07629 e2 = (void *)LST_Next(&g2->elementList);
07630 }
07631 }
07632
07633 while (e2 != NULL) {
07634 callback(NULL, &e2->element, ctx);
07635 e2 = (void *)LST_Next(&g2->elementList);
07636 }
07637 }
|
|
||||||||||||
|
Definition at line 5140 of file mri_dicom_hdr.c. References PRV_GROUP_ITEM::baseLength, CTNBOOLEAN, and PRV_GROUP_ITEM::longVRAttributes.
05142 {
05143 return (explicitVR) ?
05144 groupItem->baseLength + 4 * groupItem->longVRAttributes :
05145 groupItem->baseLength;
05146
05147 }
|
|
||||||||||||
|
Definition at line 7289 of file mri_dicom_hdr.c. References c, DCM_ELEMENT::d, DCM_AE, DCM_AS, DCM_AT, DCM_CS, DCM_CTX, DCM_DA, DCM_DD, DCM_DS, DCM_DT, DCM_FD, DCM_FL, DCM_IS, DCM_LO, DCM_LT, DCM_OT, DCM_PN, DCM_RET, DCM_SH, DCM_SL, DCM_SQ, DCM_SS, DCM_ST, DCM_TM, DCM_UI, DCM_UL, DCM_UN, DCM_US, DCM_UT, i, DCM_ELEMENT::length, DCM_ELEMENT::multiplicity, object, and DCM_ELEMENT::representation.
07290 {
07291 char
07292 *c;
07293 int
07294 i;
07295
07296 switch (element->representation) {
07297 case DCM_AE: /* Application Entity */
07298 case DCM_AS: /* Age string */
07299 case DCM_CS: /* Control string */
07300 case DCM_DA: /* Date */
07301 case DCM_DS: /* Decimal string */
07302 case DCM_DT: /* Date/Time */
07303 case DCM_IS: /* Integer string */
07304 case DCM_LO: /* Long string */
07305 case DCM_PN: /* Person Name */
07306 case DCM_SH: /* Short string */
07307 case DCM_TM: /* Time */
07308 case DCM_UI: /* Unique identifier (UID) */
07309 case DCM_UT: /* Unlimited text */
07310 element->multiplicity = 1;
07311 c = element->d.string;
07312 for (i = 0; i < (int) element->length; i++)
07313 if (*c++ == '\\')
07314 element->multiplicity++;
07315 break;
07316
07317 case DCM_FD: /* Floating double */
07318 element->multiplicity = element->length / 8;
07319 break;
07320 case DCM_AT: /* Attribute tag */
07321 case DCM_FL: /* Float */
07322 case DCM_SL: /* Signed long */
07323 case DCM_UL: /* Unsigned long */
07324 element->multiplicity = element->length / 4;
07325 break;
07326 case DCM_SS: /* Signed short */
07327 case DCM_US: /* Unsigned short */
07328 element->multiplicity = element->length / 2;
07329 break;
07330 case DCM_LT: /* Long text */
07331 case DCM_OT: /* Other binary value */
07332 case DCM_SQ: /* Sequence of items */
07333 case DCM_ST: /* Short text */
07334 /*case DCM_UNKNOWN:*/
07335 case DCM_UN:
07336 case DCM_RET:
07337 case DCM_CTX:
07338 case DCM_DD: /* Data set */
07339 default:
07340 element->multiplicity = 1;
07341 break;
07342 }
07343 }
|
|
||||||||||||
|
Definition at line 679 of file mri_dicom_hdr.c.
00680 {
00681 size_t i;
00682 int j;
00683
00684 txt[0] = '\0';
00685
00686 j = stackPtr;
00687 while (length > 2 && j >= 0) {
00688 i = strlen(EDBStack[j].statusText);
00689 if (i > length)
00690 i = length - 2;
00691 strncpy(txt, EDBStack[j].statusText, i);
00692 txt[i++] = '\n';
00693 txt[i] = '\0';
00694 length -= i;
00695 txt += i;
00696 j--;
00697 }
00698 }
|
|
|
Definition at line 636 of file mri_dicom_hdr.c. References dumpstack(), and stackPtr.
|
|
|
Definition at line 612 of file mri_dicom_hdr.c. References COND_NORMAL, and ErrorCallback.
00613 {
00614
00615 ErrorCallback = callback;
00616
00617 return COND_NORMAL;
00618 }
|
|
|
Definition at line 466 of file mri_dicom_hdr.c. References AFNI_CALL_VALU_2ARG, COND_NORMAL, CONDITION, and stackPtr.
00467 {
00468 int
00469 index,
00470 returnflag;
00471
00472 for (index = stackPtr, returnflag = 1; index >= 0 && returnflag != 0;
00473 index--) {
00474 #if 0
00475 returnflag = callback(EDBStack[index].statusCode,
00476 EDBStack[index].statusText);
00477 #else
00478 AFNI_CALL_VALU_2ARG( callback , int,returnflag ,
00479 CONDITION,EDBStack[index].statusCode ,
00480 char * ,EDBStack[index].statusText ) ;
00481 #endif
00482 }
00483
00484 return COND_NORMAL;
00485 }
|
|
|
Definition at line 565 of file mri_dicom_hdr.c. References COND_NORMAL, CONDITION, CTNBOOLEAN, and stackPtr.
00566 {
00567 CONDITION
00568 value;
00569
00570 if (stackPtr >= 0)
00571 value = EDBStack[stackPtr].statusCode;
00572 else
00573 value = COND_NORMAL;
00574
00575 if (clearstack) {
00576 stackPtr = -1;
00577 } else if (stackPtr <= 0) {
00578 stackPtr = -1;
00579 } else {
00580 stackPtr--;
00581 }
00582
00583 return value;
00584 }
|
|
||||||||||||||||
|
Definition at line 394 of file mri_dicom_hdr.c. References AFNI_CALL_VOID_2ARG, args, CONDITION, dumpstack(), ErrorCallback, MAXEDB, and stackPtr.
00395 {
00396 va_list
00397 args;
00398 char
00399 buffer[1024];
00400
00401 /*lint -e40 -e50 */
00402 va_start(args, controlString);
00403 if (controlString == NULL)
00404 controlString = "NULL Control string passedto PushCondition";
00405 (void) vsprintf(buffer, controlString, args);
00406 va_end(args);
00407 /*lint +e40 +e50 */
00408
00409 stackPtr++;
00410 EDBStack[stackPtr].statusCode = cond;
00411 buffer[256] = '\0';
00412
00413 (void) strcpy(EDBStack[stackPtr].statusText, buffer);
00414 if (ErrorCallback != NULL)
00415 #if 0
00416 ErrorCallback(EDBStack[stackPtr].statusCode,
00417 EDBStack[stackPtr].statusText);
00418 #else
00419 AFNI_CALL_VOID_2ARG( ErrorCallback ,
00420 CONDITION,EDBStack[stackPtr].statusCode ,
00421 char * ,EDBStack[stackPtr].statusText ) ;
00422 #endif
00423
00424 if (stackPtr >= MAXEDB - 2) {
00425 dumpstack(stderr);
00426 fprintf(stderr, "CONDITION Stack overflow\n");
00427 stackPtr = 0;
00428 }
00429
00430 return cond;
00431
00432 }
|
|
||||||||||||||||
|
Definition at line 519 of file mri_dicom_hdr.c. References COND_NORMAL, CONDITION, and stackPtr.
00520 {
00521 CONDITION rtnValue;
00522
00523 if (stackPtr >= 0) {
00524 *code = EDBStack[stackPtr].statusCode;
00525 (void) strncpy(text, EDBStack[stackPtr].statusText, maxlength - 1);
00526 text[maxlength - 1] = '\0';
00527 rtnValue = EDBStack[stackPtr].statusCode;
00528 } else {
00529 *code = COND_NORMAL;
00530 *text = '\0';
00531 rtnValue = COND_NORMAL;
00532 }
00533
00534 return rtnValue;
00535 }
|
|
|
Definition at line 715 of file mri_dicom_hdr.c. References dumpstack(), and stackPtr.
|
|
||||||||||||||||||||
|
Definition at line 7392 of file mri_dicom_hdr.c. References PRV_ELEMENT_ITEM::byteOrder, BYTEORDER_REVERSE, COND_PushCondition(), CONDITION, DCM_ELEMENT::d, PRV_ELEMENT_ITEM::dataOffset, DCM_AT, DCM_CANNOTGETSEQUENCEVALUE, DCM_FILEACCESSERROR, DCM_GETINCOMPLETE, DCM_Message(), DCM_NORMAL, DCM_SQ, PRV_ELEMENT_ITEM::element, l, DCM_ELEMENT::length, MIN, object, p, q, read(), DCM_ELEMENT::representation, swapATGroupElement(), swapInPlace(), DCM_ELEMENT::tag, and U32.
07394 {
07395 unsigned char *p = NULL;
07396 U32 l;
07397 int nBytes;
07398 CONDITION cond;
07399
07400 if (from->element.representation == DCM_SQ)
07401 return COND_PushCondition(DCM_CANNOTGETSEQUENCEVALUE,
07402 DCM_Message(DCM_CANNOTGETSEQUENCEVALUE),
07403 from->element.tag, "copyData (DCM internal)");
07404
07405 l = MIN(from->element.length, to->length);
07406 if (rtnLength != NULL)
07407 *rtnLength = l;
07408
07409 if (from->element.d.ot == NULL) {
07410 if ((*object)->fd != -1) {
07411 (void) lseek((*object)->fd,
07412 from->dataOffset + (off_t) p, SEEK_SET);
07413 nBytes = read((*object)->fd, to->d.ot, (int) l);
07414 } else {
07415 (*object)->sk((*object)->userCtx,
07416 (long) (from->dataOffset + (off_t) p), SEEK_SET);
07417 cond = (*object)->rd((*object)->userCtx, to->d.ot, (long) l, &nBytes);
07418 }
07419 if (nBytes != (int) l) {
07420 return COND_PushCondition(DCM_FILEACCESSERROR,
07421 DCM_Message(DCM_FILEACCESSERROR),
07422 (*object)->fileName,
07423 "copyData (DCM internal)");
07424 }
07425 if( LITTLE_ENDIAN_ARCHITECTURE ){
07426 if (from->element.representation == DCM_AT) {
07427 DCM_ELEMENT e;
07428 e = from->element;
07429 e.length = l;
07430 e.d.ot = to->d.ot;
07431 swapATGroupElement(&e);
07432 }
07433 }
07434 if (from->byteOrder == BYTEORDER_REVERSE) {
07435 DCM_ELEMENT e;
07436 e = from->element;
07437 e.length = l;
07438 e.d.ot = to->d.ot;
07439 swapInPlace(object, &e);
07440 }
07441 } else {
07442 unsigned char *q;
07443 q = (unsigned char *) from->element.d.ot +
07444 (U32) p;
07445 (void) memcpy(to->d.ot, q, l);
07446 }
07447 p += l;
07448 if ((unsigned) p == from->element.length)
07449 return DCM_NORMAL;
07450 else
07451 return DCM_GETINCOMPLETE;
07452 }
|
|
||||||||||||
|
Definition at line 7656 of file mri_dicom_hdr.c. References AFMALL, DCM_ELEMENT::d, DCM_AddSequenceElement(), DCM_CopyObject(), DCM_OBJECT, LST_Create(), LST_Enqueue(), LST_Head(), LST_Next(), LST_Position(), DCM_SEQUENCE_ITEM::object, DCM_ELEMENT::representation, and DCM_ELEMENT::tag.
07657 {
07658 LST_HEAD *lst;
07659 DCM_SEQUENCE_ITEM *sqItem;
07660 DCM_ELEMENT newElement;
07661
07662 lst = LST_Create();
07663 if (e->d.sq != NULL) {
07664 sqItem = (void *)LST_Head(&e->d.sq);
07665 (void) LST_Position(&e->d.sq, (void *)sqItem);
07666 }
07667 while (sqItem != NULL) {
07668 DCM_OBJECT *copy;
07669 DCM_SEQUENCE_ITEM *copyItem;
07670
07671 DCM_CopyObject(&sqItem->object, ©);
07672 copyItem = AFMALL( DCM_SEQUENCE_ITEM, sizeof(*copyItem));
07673 copyItem->object = copy;
07674 (void) LST_Enqueue(&lst, (void *)copyItem);
07675
07676 sqItem = (void *)LST_Next(&e->d.sq);
07677 }
07678
07679 memset(&newElement, 0, sizeof(newElement));
07680 newElement.tag = e->tag;
07681 newElement.representation = e->representation;
07682 newElement.d.sq = lst;
07683 DCM_AddSequenceElement((DCM_OBJECT **) dstObj, &newElement);
07684 }
|
|
||||||||||||||||||||
|
Definition at line 5046 of file mri_dicom_hdr.c. References DCM_NORMAL, and U32. Referenced by DCM_ComputeExportLength().
05048 {
05049 unsigned long *size;
05050
05051 size = (unsigned long *) sizePtr;
05052
05053 *size += length;
05054
05055 return DCM_NORMAL;
05056 }
|
|
||||||||||||
|
||||||||||||
|
Definition at line 1334 of file mri_dicom_hdr.c. References checkObject(), COND_PopCondition(), COND_PushCondition(), CONDITION, DCM_CTX, DCM_ILLEGALADD, DCM_ILLEGALREPRESENTATION, DCM_INSERTFAILED, DCM_LookupElement(), DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_OT, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UN, findCreateGroup(), insertNewElement(), object, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and updateObjectType().
01335 {
01336 CONDITION
01337 cond;
01338 DCM_ELEMENT
01339 localElement;
01340 PRIVATE_OBJECT
01341 ** object;
01342 PRV_GROUP_ITEM
01343 * groupItem;
01344
01345 object = (PRIVATE_OBJECT **) callerObject;
01346
01347 cond = checkObject(object, "DCM_AddElement");
01348 if (cond != DCM_NORMAL)
01349 return cond;
01350
01351 if ((DCM_TAG_ELEMENT(element->tag) == 0x0000))
01352 return COND_PushCondition(DCM_ILLEGALADD,
01353 DCM_Message(DCM_ILLEGALADD), DCM_TAG_GROUP(element->tag),
01354 DCM_TAG_ELEMENT(element->tag), "DCM_AddElement");
01355
01356
01357 localElement = *element;
01358
01359 cond = DCM_LookupElement(&localElement);
01360 if (cond != DCM_NORMAL) {
01361 (void) COND_PopCondition(0);
01362 localElement = *element;
01363 } else {
01364 if (localElement.representation == DCM_OT ||
01365 localElement.representation == DCM_CTX)
01366 localElement.representation = element->representation;
01367 if (element->representation != DCM_UN &&
01368 element->representation != localElement.representation) {
01369 return COND_PushCondition(DCM_ILLEGALREPRESENTATION,
01370 DCM_Message(DCM_ILLEGALREPRESENTATION),
01371 DCM_TAG_GROUP(element->tag),
01372 DCM_TAG_ELEMENT(element->tag),
01373 "DCM_AddElement");
01374 }
01375 }
01376
01377 cond = findCreateGroup(object, DCM_TAG_GROUP(localElement.tag), &groupItem);
01378 if (cond != DCM_NORMAL)
01379 return COND_PushCondition(DCM_INSERTFAILED,
01380 DCM_Message(DCM_INSERTFAILED), DCM_TAG_GROUP(element->tag),
01381 DCM_TAG_ELEMENT(element->tag),
01382 "DCM_AddElement");
01383
01384 cond = insertNewElement(object, &localElement);
01385 if (cond != DCM_NORMAL)
01386 return COND_PushCondition(DCM_INSERTFAILED,
01387 DCM_Message(DCM_INSERTFAILED), DCM_TAG_GROUP(element->tag),
01388 DCM_TAG_ELEMENT(element->tag),
01389 "DCM_AddElement");
01390
01391 cond = updateObjectType(object, &localElement);
01392 if (cond != DCM_NORMAL)
01393 return COND_PushCondition(DCM_INSERTFAILED,
01394 DCM_Message(DCM_INSERTFAILED), DCM_TAG_GROUP(element->tag),
01395 DCM_TAG_ELEMENT(element->tag),
01396 "DCM_AddElement");
01397
01398 return DCM_NORMAL;
01399 }
|
|
||||||||||||||||||||
|
Definition at line 3334 of file mri_dicom_hdr.c. References CONDITION, CTN_FREE, DCM_ELEMENT::d, DCM_AddElement(), DCM_ListToString(), DCM_NORMAL, DCM_OBJECT, DCM_ELEMENT::length, and offset.
03336 {
03337 DCM_ELEMENT
03338 e; /* Local copy of caller's element */
03339 CONDITION
03340 cond;
03341 char
03342 *s;
03343
03344 e = *element;
03345 cond = DCM_ListToString(list, offset, &s);
03346 if (cond != DCM_NORMAL)
03347 return cond;
03348
03349 e.d.string = s;
03350 e.length = strlen(s);
03351 cond = DCM_AddElement(callerObject, &e);
03352 CTN_FREE(s);
03353 return cond;
03354 }
|
|
||||||||||||||||
|
Definition at line 8123 of file mri_dicom_hdr.c. References checkObject(), COND_PushCondition(), CONDITION, CTN_MALLOC, DCM_ELEMENT::d, DCM_INSERTFAILED, DCM_LISTFAILURE, DCM_MALLOCFAILURE, DCM_Message(), DCM_NORMAL, DCM_OB, DCM_OBJECT, DCM_PXLPIXELDATA, DCM_UNEVENFRAGMENTLENGTH, PRV_ELEMENT_ITEM::element, findCreateGroup(), DCM_FRAGMENT_ITEM::fragment, PRV_ELEMENT_ITEM::fragmentFlag, insertThisElementItem(), DCM_FRAGMENT_ITEM::length, DCM_ELEMENT::length, locateElement(), LST_Create(), LST_Enqueue(), DCM_ELEMENT::multiplicity, newElementItem(), object, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and U32.
08124 {
08125 PRIVATE_OBJECT** object;
08126 PRV_ELEMENT_ITEM* elementItem;
08127 PRV_ELEMENT_ITEM* newItem;
08128 CONDITION cond;
08129 PRV_GROUP_ITEM *groupItem = 0;
08130 DCM_FRAGMENT_ITEM* fragmentItem;
08131 U32 mallocLength;
08132
08133 if ((fragmentLength & 1) != 0) {
08134 return COND_PushCondition(DCM_UNEVENFRAGMENTLENGTH,
08135 DCM_Message(DCM_UNEVENFRAGMENTLENGTH), fragmentLength, "DCM_AddFragment");
08136 }
08137
08138 object = (PRIVATE_OBJECT **) callerObject;
08139 cond = checkObject(object, "DCM_AddFragment");
08140 if (cond != DCM_NORMAL)
08141 return cond;
08142
08143 cond = findCreateGroup(object, 0x7fe0, &groupItem);
08144 if (cond != DCM_NORMAL)
08145 return COND_PushCondition(DCM_INSERTFAILED,
08146 DCM_Message(DCM_INSERTFAILED), 0x7fe0, 0x0010, "DCM_AddFragment");
08147
08148 elementItem = locateElement(object, 0x7fe00010);
08149 if (elementItem == NULL) {
08150 DCM_ELEMENT e;
08151 memset(&e, 0, sizeof(e));
08152 e.tag = DCM_PXLPIXELDATA;
08153 e.representation = DCM_OB;
08154 e.multiplicity = 1;
08155 e.length = 0;
08156 e.d.fragments = 0;
08157 cond = newElementItem(&e, FALSE, &newItem);
08158 if (cond != DCM_NORMAL)
08159 return cond;
08160 newItem->element.d.fragments = LST_Create();
08161 if (newItem->element.d.fragments == NULL) {
08162 return COND_PushCondition(DCM_LISTFAILURE,
08163 DCM_Message(DCM_LISTFAILURE), "DCM_AddFragment");
08164 }
08165 cond = insertThisElementItem(object, newItem);
08166 if (cond != DCM_NORMAL)
08167 return cond;
08168 }
08169
08170 elementItem = locateElement(object, 0x7fe00010);
08171
08172 mallocLength = sizeof(DCM_FRAGMENT_ITEM) + fragmentLength;
08173 fragmentItem = CTN_MALLOC(mallocLength);
08174 if (fragmentItem == NULL) {
08175 return COND_PushCondition(DCM_MALLOCFAILURE,
08176 DCM_Message(DCM_MALLOCFAILURE), mallocLength,
08177 "DCM_AddFragment");
08178 }
08179
08180 fragmentItem->fragment = ((char*)fragmentItem)+ sizeof(DCM_FRAGMENT_ITEM);
08181 fragmentItem->length = fragmentLength;
08182 memcpy(fragmentItem->fragment, fragment, fragmentLength);
08183 elementItem->fragmentFlag = 1;
08184 LST_Enqueue(&elementItem->element.d.fragments, (void *)fragmentItem);
08185
08186 return DCM_NORMAL;
08187 }
|
|
||||||||||||
|
Definition at line 1425 of file mri_dicom_hdr.c. References checkObject(), COND_PopCondition(), COND_PushCondition(), CONDITION, DCM_ELEMENT::d, DCM_ILLEGALADD, DCM_INSERTFAILED, DCM_LookupElement(), DCM_Message(), DCM_NORMAL, DCM_NOTASEQUENCE, DCM_OBJECT, DCM_SQ, DCM_TAG_ELEMENT, DCM_TAG_GROUP, findCreateGroup(), insertNewElement(), object, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and updateObjectType().
01426 {
01427 CONDITION cond;
01428 DCM_ELEMENT localElement;
01429 PRIVATE_OBJECT **object;
01430 PRV_GROUP_ITEM *groupItem;
01431
01432 object = (PRIVATE_OBJECT **) callerObject;
01433
01434 cond = checkObject(object, "DCM_AddSequenceElement");
01435 if (cond != DCM_NORMAL)
01436 return cond;
01437
01438 if ((DCM_TAG_ELEMENT(element->tag) == 0x0000))
01439 return COND_PushCondition(DCM_ILLEGALADD,
01440 DCM_Message(DCM_ILLEGALADD), DCM_TAG_GROUP(element->tag),
01441 DCM_TAG_ELEMENT(element->tag), "DCM_AddElement");
01442
01443
01444 localElement = *element;
01445
01446 cond = DCM_LookupElement(&localElement);
01447 if (cond != DCM_NORMAL) {
01448 (void) COND_PopCondition(0);
01449 localElement = *element;
01450 } else {
01451 localElement.representation = element->representation;
01452 }
01453 if (localElement.representation != DCM_SQ) {
01454 return COND_PushCondition(DCM_NOTASEQUENCE,
01455 DCM_Message(DCM_NOTASEQUENCE),
01456 DCM_TAG_GROUP(localElement.tag),
01457 DCM_TAG_ELEMENT(localElement.tag),
01458 "DCM_AddSequenceElement");
01459 }
01460 cond = findCreateGroup(object, DCM_TAG_GROUP(localElement.tag), &groupItem);
01461 if (cond != DCM_NORMAL)
01462 return COND_PushCondition(DCM_INSERTFAILED,
01463 DCM_Message(DCM_INSERTFAILED), DCM_TAG_GROUP(element->tag),
01464 DCM_TAG_ELEMENT(element->tag),
01465 "DCM_AddSequenceElement");
01466
01467 cond = insertNewElement(object, &localElement);
01468 if (cond != DCM_NORMAL)
01469 return COND_PushCondition(DCM_INSERTFAILED,
01470 DCM_Message(DCM_INSERTFAILED), DCM_TAG_GROUP(element->tag),
01471 DCM_TAG_ELEMENT(element->tag),
01472 "DCM_AddElement");
01473
01474 cond = updateObjectType(object, &localElement);
01475 if (cond != DCM_NORMAL)
01476 return COND_PushCondition(DCM_INSERTFAILED,
01477 DCM_Message(DCM_INSERTFAILED), DCM_TAG_GROUP(element->tag),
01478 DCM_TAG_ELEMENT(element->tag),
01479 "DCM_AddSequenceElement");
01480
01481 /*
01482 * We have taken ownership of the sequence list, so zero out caller's
01483 * copy
01484 */
01485 element->d.sq = NULL;
01486
01487 return DCM_NORMAL;
01488 }
|
|
|
Definition at line 1207 of file mri_dicom_hdr.c. References checkObject(), close(), COND_PushCondition(), CONDITION, CTN_FREE, DCM_ELEMENT::d, DCM_CloseObject(), DCM_FILEDELETEFAILED, DCM_LISTFAILURE, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_SQ, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_ELEMENT_ITEM::fragmentFlag, PRV_GROUP_ITEM::group, LST_Destroy(), LST_NORMAL, LST_Pop(), DCM_SEQUENCE_ITEM::object, object, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and unlink.
01208 {
01209 CONDITION
01210 cond;
01211 PRV_GROUP_ITEM
01212 * group;
01213 PRV_ELEMENT_ITEM
01214 * element;
01215 PRIVATE_OBJECT
01216 ** object;
01217 DCM_SEQUENCE_ITEM
01218 * sequenceItem;
01219 DCM_FRAGMENT_ITEM* fragmentItem;
01220
01221 if (debug)
01222 fprintf(stderr, "Starting DCM_CloseObject\n");
01223
01224 object = (PRIVATE_OBJECT **) callerObject;
01225 cond = checkObject(object, "DCM_CloseObject");
01226 if (cond != DCM_NORMAL)
01227 return cond;
01228
01229 if ((*object)->fd > 0)
01230 (void) close((*object)->fd);
01231
01232 if (debug)
01233 fprintf(stderr, "DCM_CloseObject: Legal object and file closed\n");
01234
01235 while ((group = (void *)LST_Pop(&(*object)->groupList)) != NULL) {
01236 if (debug)
01237 fprintf(stderr, "DCM_CloseObject: group %04x\n", group->group);
01238
01239 while ((element = (void *)LST_Pop(&group->elementList)) != NULL) {
01240 if (debug)
01241 fprintf(stderr, "DCM_CloseObject: Element %08x\n",
01242 element->element.tag);
01243 if (element->element.representation == DCM_SQ) {
01244 if (debug)
01245 fprintf(stderr, "Sequence List Address: %p\n",
01246 element->element.d.sq);
01247 if (element->element.d.sq != NULL) {
01248 while ((sequenceItem = (void *)LST_Pop(&element->element.d.sq)) != NULL) {
01249 (void) DCM_CloseObject(&sequenceItem->object);
01250 CTN_FREE(sequenceItem);
01251 }
01252 (void) LST_Destroy(&element->element.d.sq);
01253 }
01254 } else if (element->fragmentFlag) {
01255 if (debug)
01256 fprintf(stderr, "Fragment List Address: %p\n",
01257 element->element.d.fragments);
01258 if (element->element.d.fragments != NULL) {
01259 while ((fragmentItem = (void *)LST_Pop(&element->element.d.fragments)) != NULL) {
01260 CTN_FREE(fragmentItem);
01261 }
01262 (void) LST_Destroy(&element->element.d.fragments);
01263 }
01264 }
01265 if (debug)
01266 fprintf(stderr, "DCM_CloseObject: free %8p\n", element);
01267
01268 CTN_FREE(element);
01269 }
01270 cond = LST_Destroy(&group->elementList);
01271 if (cond != LST_NORMAL)
01272 return COND_PushCondition(DCM_LISTFAILURE,
01273 DCM_Message(DCM_LISTFAILURE), "DCM_CloseObject");
01274 CTN_FREE(group);
01275 }
01276 cond = LST_Destroy(&(*object)->groupList);
01277 if (cond != LST_NORMAL)
01278 return COND_PushCondition(DCM_LISTFAILURE,
01279 DCM_Message(DCM_LISTFAILURE), "DCM_CloseObject");
01280
01281 cond = DCM_NORMAL;
01282 if ((*object)->deleteFlag) {
01283 if (unlink((*object)->fileName) != 0) {
01284 /**** (void) COND_PushCondition(DCM_FILEDELETEFAILED, strerror(errno));****/
01285 cond = COND_PushCondition(DCM_FILEDELETEFAILED,
01286 DCM_Message(DCM_FILEDELETEFAILED), (*object)->fileName, strerror(errno),
01287 "DCM_CloseObject");
01288
01289 }
01290 }
01291 CTN_FREE(*object);
01292 *object = NULL;
01293 return cond;
01294 }
|
|
||||||||||||||||||||
|
Definition at line 3432 of file mri_dicom_hdr.c. References checkObject(), compareGroup(), CONDITION, DCM_NORMAL, DCM_OBJECT, PRV_GROUP_ITEM::group, LST_Head(), LST_Next(), and LST_Position().
03437 {
03438 PRIVATE_OBJECT **object1,
03439 **object2;
03440 PRV_GROUP_ITEM *groupItem1,
03441 *groupItem2;
03442 CONDITION cond;
03443
03444 object1 = (PRIVATE_OBJECT **) o1;
03445 cond = checkObject(object1, "DCM_CompareAttributes");
03446 if (cond != DCM_NORMAL)
03447 return cond;
03448
03449 object2 = (PRIVATE_OBJECT **) o2;
03450 cond = checkObject(object1, "DCM_CompareAttributes");
03451 if (cond != DCM_NORMAL)
03452 return cond;
03453
03454 groupItem1 = (void *)LST_Head(&(*object1)->groupList);
03455 if (groupItem1 != NULL)
03456 (void) LST_Position(&(*object1)->groupList, (void *)groupItem1);
03457
03458 groupItem2 = (void *)LST_Head(&(*object2)->groupList);
03459 if (groupItem2 != NULL)
03460 (void) LST_Position(&(*object2)->groupList, (void *)groupItem2);
03461
03462
03463 while (groupItem1 != NULL) {
03464 if (groupItem2 == NULL) {
03465 compareGroup(groupItem1, NULL, callback, ctx);
03466 groupItem1 = (void *)LST_Next(&(*object1)->groupList);
03467 } else if (groupItem1->group == groupItem2->group) {
03468 compareGroup(groupItem1, groupItem2, callback, ctx);
03469 groupItem1 = (void *)LST_Next(&(*object1)->groupList);
03470 groupItem2 = (void *)LST_Next(&(*object2)->groupList);
03471 } else if (groupItem1->group > groupItem2->group) {
03472 compareGroup(NULL, groupItem2, callback, ctx);
03473 groupItem2 = (void *)LST_Next(&(*object2)->groupList);
03474 } else {
03475 compareGroup(groupItem1, NULL, callback, ctx);
03476 groupItem1 = (void *)LST_Next(&(*object1)->groupList);
03477 }
03478 }
03479
03480 while (groupItem2 != NULL) {
03481 compareGroup(NULL, groupItem2, callback, ctx);
03482 groupItem2 = (void *)LST_Next(&(*object2)->groupList);
03483 }
03484 return DCM_NORMAL;
03485 }
|
|
||||||||||||||||
|
Definition at line 3407 of file mri_dicom_hdr.c. References checkObject(), CONDITION, countBytes(), DCM_ExportStream(), DCM_NORMAL, DCM_OBJECT, and object.
03409 {
03410 PRIVATE_OBJECT
03411 ** object;
03412 unsigned char
03413 buf[2048];
03414 CONDITION
03415 cond;
03416
03417 object = (PRIVATE_OBJECT **) callerObject;
03418 cond = checkObject(object, "DCM_ComputeExportSize");
03419 if (cond != DCM_NORMAL)
03420 return cond;
03421
03422 *length = 0;
03423 cond = DCM_ExportStream(callerObject, opt, buf,
03424 (unsigned long) sizeof(buf), countBytes, length);
03425 if (cond != DCM_NORMAL)
03426 return cond;
03427
03428 return DCM_NORMAL;
03429 }
|
|
||||||||||||
|
||||||||||||
|
|
Definition at line 2707 of file mri_dicom_hdr.c. References CTNBOOLEAN, and debug.
02708 {
02709 debug = flag;
02710 }
|
|
||||||||||||
|
Definition at line 2287 of file mri_dicom_hdr.c. References PRV_GROUP_ITEM::baseLength, checkObject(), CONDITION, DCM_ELEMENT::d, DCM_ELEMENT::data_offset, DCM_AE, DCM_AS, DCM_AT, DCM_CS, DCM_DA, DCM_DD, DCM_DS, DCM_DT, DCM_DumpElements(), DCM_FD, DCM_FL, DCM_IS, DCM_LO, DCM_LT, DCM_NORMAL, DCM_OB, DCM_OBJECT, DCM_OBJECTCOMMAND, DCM_OBJECTELEMENTLIST, DCM_OBJECTIMAGE, DCM_OBJECTUNKNOWN, DCM_OT, DCM_OW, DCM_PN, DCM_RET, DCM_SH, DCM_SL, DCM_SQ, DCM_SS, DCM_ST, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_TM, DCM_UI, DCM_UL, DCM_UN, DCM_US, DCM_UT, DCM_ELEMENT::description, dumpBinaryData(), PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, DCM_ELEMENT::length, LST_Head(), LST_Next(), LST_Position(), MIN, DCM_SEQUENCE_ITEM::object, object, DCM_ELEMENT::representation, RWC_NOHEX_MASK, RWC_NONAME_MASK, rwc_opt, RWC_printf(), rwc_vm, scratch, DCM_ELEMENT::tag, U32, and vm.
02288 {
02289 PRV_GROUP_ITEM
02290 * groupItem;
02291 PRV_ELEMENT_ITEM
02292 * elementItem;
02293 PRIVATE_OBJECT
02294 ** object;
02295 CONDITION
02296 cond;
02297 DCM_SEQUENCE_ITEM
02298 * sq;
02299 char
02300 scratch[128];
02301 int
02302 stringLength;
02303
02304 object = (PRIVATE_OBJECT **) callerObject;
02305
02306 cond = checkObject(object, "DCM_DumpElements");
02307 if (cond != DCM_NORMAL)
02308 return cond;
02309
02310 switch ((*object)->objectType) {
02311 case DCM_OBJECTUNKNOWN:
02312 RWC_printf("Object type: UNKNOWN\n");
02313 break;
02314 case DCM_OBJECTCOMMAND:
02315 RWC_printf("Object type: COMMAND\n");
02316 break;
02317 case DCM_OBJECTIMAGE:
02318 RWC_printf("Object type: IMAGE\n");
02319 break;
02320 case DCM_OBJECTELEMENTLIST:
02321 RWC_printf("Object type: ELEMENT LIST\n");
02322 break;
02323 default:
02324 RWC_printf("Object type: Unknown (error)\n");
02325 break;
02326 }
02327 RWC_printf("Object size: %ld\n", (*object)->objectSize);
02328
02329 groupItem = (void *)LST_Head(&(*object)->groupList);
02330 if (groupItem != NULL)
02331 (void) LST_Position(&(*object)->groupList, (void *)groupItem);
02332
02333 while (groupItem != NULL) {
02334 #ifdef MACOS
02335 RWC_printf("Group: %04x, Length: %8ld\n", groupItem->group,
02336 groupItem->baseLength);
02337 #else
02338 RWC_printf("Group: %04x, Length: %8d\n", groupItem->group,
02339 groupItem->baseLength);
02340 #endif
02341 elementItem = (void *)LST_Head(&groupItem->elementList);
02342 if (elementItem != NULL)
02343 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
02344 while (elementItem != NULL) {
02345 #ifdef MACOS
02346 (void) RWC_printf("%04x %04x %8ld [%-8lu] ",
02347 DCM_TAG_GROUP(elementItem->element.tag),
02348 DCM_TAG_ELEMENT(elementItem->element.tag),
02349 elementItem->element.length ,
02350 (unsigned long) elementItem->element.data_offset );
02351 #else
02352 (void) RWC_printf("%04x %04x %8d [%-8lu] ",
02353 DCM_TAG_GROUP(elementItem->element.tag),
02354 DCM_TAG_ELEMENT(elementItem->element.tag),
02355 elementItem->element.length ,
02356 (unsigned long) elementItem->element.data_offset );
02357 #endif
02358
02359 if( (rwc_opt & RWC_NONAME_MASK) == 0 )
02360 (void) RWC_printf("//%31s//", elementItem->element.description);
02361 else
02362 (void) RWC_printf("//") ;
02363
02364 if (elementItem->element.d.ot == NULL)
02365 (void) RWC_printf("Data on disk\n");
02366 else {
02367 switch (elementItem->element.representation) {
02368 case DCM_AE:
02369 case DCM_AS:
02370 case DCM_CS:
02371 case DCM_DA:
02372 case DCM_DT:
02373 stringLength = MIN(sizeof(scratch) - 1, elementItem->element.length);
02374 strncpy(scratch, elementItem->element.d.string, stringLength);
02375 scratch[stringLength] = '\0';
02376 (void) RWC_printf("%s\n", scratch);
02377 break;
02378 case DCM_DD:
02379 case DCM_FD:
02380 case DCM_FL:
02381 (void) RWC_printf("Unimplemented\n");
02382 break;
02383 case DCM_DS:
02384 case DCM_IS:
02385 case DCM_LO:
02386 case DCM_LT:
02387 case DCM_PN:
02388 case DCM_SH:
02389 case DCM_UT:
02390 stringLength = MIN(sizeof(scratch) - 1, elementItem->element.length);
02391 strncpy(scratch, elementItem->element.d.string, stringLength);
02392 scratch[stringLength] = '\0';
02393 (void) RWC_printf("%s\n", scratch);
02394 break;
02395 case DCM_SL:
02396 #ifdef MACOS
02397 (void) RWC_printf("%8lx %ld\n", *elementItem->element.d.sl,
02398 *elementItem->element.d.sl);
02399 #else
02400 if( (rwc_opt & RWC_NOHEX_MASK) == 0 )
02401 (void) RWC_printf("%8x %d\n", *elementItem->element.d.sl,
02402 *elementItem->element.d.sl);
02403 else
02404 (void) RWC_printf(" %d\n", *elementItem->element.d.sl ) ;
02405
02406 if (vm > 1)
02407 dumpBinaryData(elementItem->element.d.ot,
02408 elementItem->element.representation,
02409 elementItem->element.length / sizeof(U32), vm);
02410 #endif
02411 break;
02412 case DCM_SS:
02413 if( (rwc_opt & RWC_NOHEX_MASK) == 0 )
02414 (void) RWC_printf("%4x %d\n", *elementItem->element.d.ss,
02415 *elementItem->element.d.ss);
02416 else
02417 (void) RWC_printf(" %d\n", *elementItem->element.d.ss ) ;
02418
02419 if (vm > 1)
02420 dumpBinaryData(elementItem->element.d.ot,
02421 elementItem->element.representation,
02422 elementItem->element.length / sizeof(short), vm);
02423 break;
02424 case DCM_SQ:
02425 (void) RWC_printf("SEQUENCE\n");
02426 sq = (void *)LST_Head(&elementItem->element.d.sq);
02427 if (sq != NULL)
02428 (void) LST_Position(&elementItem->element.d.sq, (void *)sq);
02429 RWC_printf("DCM Dump SEQUENCE\n");
02430 while (sq != NULL) {
02431 (void) DCM_DumpElements(&sq->object, vm);
02432 sq = (void *)LST_Next(&elementItem->element.d.sq);
02433 }
02434 RWC_printf("DCM Dump SEQUENCE Complete\n");
02435 break;
02436 case DCM_ST:
02437 stringLength = MIN(sizeof(scratch) - 1, elementItem->element.length);
02438 strncpy(scratch, elementItem->element.d.string, stringLength);
02439 scratch[stringLength] = '\0';
02440 (void) RWC_printf("%s\n", scratch);
02441 break;
02442 case DCM_TM:
02443 case DCM_UI:
02444 stringLength = MIN(sizeof(scratch) - 1, elementItem->element.length);
02445 strncpy(scratch, elementItem->element.d.string, stringLength);
02446 scratch[stringLength] = '\0';
02447 (void) RWC_printf("%s\n", scratch);
02448 break;
02449 case DCM_AT:
02450 case DCM_UL:
02451 #ifdef MACOS
02452 (void) RWC_printf("%8lx %ld\n", *elementItem->element.d.ul,
02453 *elementItem->element.d.ul);
02454 #else
02455 if( (rwc_opt & RWC_NOHEX_MASK) == 0 )
02456 (void) RWC_printf("%8x %d\n", *elementItem->element.d.ul,
02457 *elementItem->element.d.ul);
02458 else
02459 (void) RWC_printf(" %d\n", *elementItem->element.d.ul ) ;
02460
02461 if (vm > 1)
02462 dumpBinaryData(elementItem->element.d.ot,
02463 elementItem->element.representation,
02464 elementItem->element.length / sizeof(U32), vm);
02465 #endif
02466 break;
02467 case DCM_US:{
02468 int nel = elementItem->element.length / sizeof(unsigned short) , rr ;
02469 for( rr=0 ; rr < nel ; rr++ ){
02470 if( (rwc_opt & RWC_NOHEX_MASK) == 0 )
02471 (void) RWC_printf("%4x %d", elementItem->element.d.us[rr],
02472 elementItem->element.d.us[rr]);
02473 else
02474 (void) RWC_printf(" %d", elementItem->element.d.us[rr] ) ;
02475 }
02476 RWC_printf("\n") ;
02477
02478 if (vm > 1)
02479 dumpBinaryData(elementItem->element.d.ot,
02480 elementItem->element.representation,
02481 elementItem->element.length / sizeof(unsigned short), vm);
02482 }
02483 break;
02484 case DCM_OB:
02485 case DCM_UN:
02486 dumpBinaryData(elementItem->element.d.ot,
02487 elementItem->element.representation,
02488 elementItem->element.length , MAX(rwc_vm,8));
02489 break;
02490
02491 case DCM_OT:
02492 case DCM_OW:
02493 /*case DCM_UNKNOWN:*/
02494 case DCM_RET:
02495 (void) RWC_printf("Unimplemented\n");
02496 break;
02497 default:
02498 (void) RWC_printf("Some unimplemented logic if here\n");
02499 break;
02500 }
02501 }
02502 elementItem = (void *)LST_Next(&groupItem->elementList);
02503 }
02504 groupItem = (void *)LST_Next(&(*object)->groupList);
02505 }
02506
02507 RWC_printf("DCM Dump Elements Complete\n");
02508 return DCM_NORMAL;
02509 }
|
|
|
Definition at line 8333 of file mri_dicom_hdr.c. References DIM_OF, vector::message, and RWC_printf().
08334 {
08335 int index;
08336
08337 for (index = 0; index < (int) DIM_OF(messageVector); index++) {
08338 if (messageVector[index].message != NULL)
08339 RWC_printf("%8x %8d %s\n", messageVector[index].cond,
08340 messageVector[index].cond,
08341 messageVector[index].message);
08342 }
08343 }
|
|
||||||||||||||||
|
Definition at line 10432 of file mri_dicom_hdr.c. References DCM_NORMAL, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_VALUEREPRESENTATION, GROUPPTR::dict, DIM_OF, DCMDICT::englishDescription, GROUPPTR::entries, i, p, r, DCMDICT::representation, and DCMDICT::tag.
10435 {
10436 int i;
10437 unsigned long j;
10438 GROUPPTR *p;
10439 DCMDICT *dictionaryPtr;
10440
10441 for (i = 0; i < (int) DIM_OF(group_dictionary); i++) {
10442 if ((DCM_TAG_GROUP(tag) == group_dictionary[i].group) ||
10443 (DCM_TAG_GROUP(tag) == 0xffff)) {
10444 p = &group_dictionary[i];
10445 dictionaryPtr = p->dict;
10446 for (j = 0; j < p->entries; j++, dictionaryPtr++) {
10447 if ((DCM_TAG_ELEMENT(tag) == 0xffff) ||
10448 (DCM_TAG_ELEMENT(tag) == DCM_TAG_ELEMENT(dictionaryPtr->tag))) {
10449 callback(dictionaryPtr->tag,
10450 dictionaryPtr->englishDescription,
10451 dictionaryPtr->representation,
10452 ctx);
10453 }
10454 }
10455 }
10456 }
10457 return DCM_NORMAL;
10458 }
|
|
||||||||||||||||||||||||||||
|
|
|
||||||||||||||||
|
Definition at line 2512 of file mri_dicom_hdr.c. References PRV_GROUP_ITEM::baseLength, checkObject(), CONDITION, DCM_ELEMENT::d, DCM_AE, DCM_AS, DCM_AT, DCM_CS, DCM_DA, DCM_DD, DCM_DS, DCM_DT, DCM_FD, DCM_FL, DCM_FormatElements(), DCM_IS, DCM_LO, DCM_LT, DCM_NORMAL, DCM_OB, DCM_OBJECT, DCM_OBJECTCOMMAND, DCM_OBJECTELEMENTLIST, DCM_OBJECTIMAGE, DCM_OBJECTUNKNOWN, DCM_OT, DCM_OW, DCM_PN, DCM_RET, DCM_SH, DCM_SL, DCM_SQ, DCM_SS, DCM_ST, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_TM, DCM_UI, DCM_UL, DCM_US, DCM_UT, DCM_ELEMENT::description, dumpBinaryData(), PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, DCM_ELEMENT::length, LST_Head(), LST_Next(), LST_Position(), MIN, DCM_SEQUENCE_ITEM::object, object, DCM_ELEMENT::representation, RWC_printf(), scratch, DCM_ELEMENT::tag, U32, and vm.
02513 {
02514 PRV_GROUP_ITEM
02515 * groupItem;
02516 PRV_ELEMENT_ITEM
02517 * elementItem;
02518 PRIVATE_OBJECT
02519 ** object;
02520 CONDITION
02521 cond;
02522 DCM_SEQUENCE_ITEM
02523 * sq;
02524 char
02525 scratch[128];
02526 int
02527 stringLength;
02528 char localPrefix[128];
02529
02530 object = (PRIVATE_OBJECT **) callerObject;
02531
02532 cond = checkObject(object, "DCM_DumpElements");
02533 if (cond != DCM_NORMAL)
02534 return cond;
02535
02536 RWC_printf("\n%sDCM Dump Elements\n", prefix);
02537 switch ((*object)->objectType) {
02538 case DCM_OBJECTUNKNOWN:
02539 RWC_printf("%sObject type: UNKNOWN\n", prefix);
02540 break;
02541 case DCM_OBJECTCOMMAND:
02542 RWC_printf("%sObject type: COMMAND\n", prefix);
02543 break;
02544 case DCM_OBJECTIMAGE:
02545 RWC_printf("%sObject type: IMAGE\n", prefix);
02546 break;
02547 case DCM_OBJECTELEMENTLIST:
02548 RWC_printf("%sObject type: ELEMENT LIST\n", prefix);
02549 break;
02550 default:
02551 RWC_printf("%sObject type: Unknown (error)\n", prefix);
02552 break;
02553 }
02554 RWC_printf("%sObject size: %ld\n", prefix, (*object)->objectSize);
02555
02556 groupItem = (void *)LST_Head(&(*object)->groupList);
02557 if (groupItem != NULL)
02558 (void) LST_Position(&(*object)->groupList, (void *)groupItem);
02559
02560 while (groupItem != NULL) {
02561 RWC_printf("%sGroup: %04x, Length: %8d\n", prefix, groupItem->group,
02562 groupItem->baseLength);
02563 elementItem = (void *)LST_Head(&groupItem->elementList);
02564 if (elementItem != NULL)
02565 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
02566 while (elementItem != NULL) {
02567 (void) RWC_printf("%s%04x %04x %8d ",
02568 prefix,
02569 DCM_TAG_GROUP(elementItem->element.tag),
02570 DCM_TAG_ELEMENT(elementItem->element.tag),
02571 elementItem->element.length);
02572 (void) RWC_printf("//%31s//", elementItem->element.description);
02573 if (elementItem->element.d.ot == NULL)
02574 (void) RWC_printf("Data on disk\n");
02575 else {
02576 switch (elementItem->element.representation) {
02577 case DCM_AE:
02578 case DCM_AS:
02579 case DCM_CS:
02580 case DCM_DA:
02581 case DCM_DT:
02582 stringLength = MIN(sizeof(scratch) - 1, elementItem->element.length);
02583 strncpy(scratch, elementItem->element.d.string, stringLength);
02584 scratch[stringLength] = '\0';
02585 (void) RWC_printf("%s\n", scratch);
02586 break;
02587 case DCM_DD:
02588 case DCM_FD:
02589 case DCM_FL:
02590 (void) RWC_printf("Unimplemented\n");
02591 break;
02592 case DCM_DS:
02593 case DCM_IS:
02594 case DCM_LO:
02595 case DCM_LT:
02596 case DCM_PN:
02597 case DCM_SH:
02598 case DCM_UT:
02599 stringLength = MIN(sizeof(scratch) - 1, elementItem->element.length);
02600 strncpy(scratch, elementItem->element.d.string, stringLength);
02601 scratch[stringLength] = '\0';
02602 (void) RWC_printf("%s\n", scratch);
02603 break;
02604 case DCM_SL:
02605 #ifdef MACOS
02606 (void) RWC_printf("%8lx %ld\n", *elementItem->element.d.sl,
02607 *elementItem->element.d.sl);
02608 #else
02609 (void) RWC_printf("%8x %d\n", *elementItem->element.d.sl,
02610 *elementItem->element.d.sl);
02611 if (vm > 1)
02612 dumpBinaryData(elementItem->element.d.ot,
02613 elementItem->element.representation,
02614 elementItem->element.length / sizeof(U32), vm);
02615 #endif
02616 break;
02617 case DCM_SS:
02618 (void) RWC_printf("%4x %d\n", *elementItem->element.d.ss,
02619 *elementItem->element.d.ss);
02620 if (vm > 1)
02621 dumpBinaryData(elementItem->element.d.ot,
02622 elementItem->element.representation,
02623 elementItem->element.length / sizeof(short), vm);
02624 break;
02625 case DCM_SQ:
02626 (void) RWC_printf("SEQUENCE\n");
02627 sq = (void *)LST_Head(&elementItem->element.d.sq);
02628 if (sq != NULL)
02629 (void) LST_Position(&elementItem->element.d.sq, (void *)sq);
02630 RWC_printf("%sDCM Dump SEQUENCE\n", prefix);
02631 strcpy(localPrefix, prefix);
02632 strcat(localPrefix, " ");
02633 while (sq != NULL) {
02634 (void) DCM_FormatElements(&sq->object, vm, localPrefix);
02635 sq = (void *)LST_Next(&elementItem->element.d.sq);
02636 }
02637 RWC_printf("%sDCM Dump SEQUENCE Complete\n", prefix);
02638 break;
02639 case DCM_ST:
02640 stringLength = MIN(sizeof(scratch) - 1, elementItem->element.length);
02641 strncpy(scratch, elementItem->element.d.string, stringLength);
02642 scratch[stringLength] = '\0';
02643 (void) RWC_printf("%s\n", scratch);
02644 break;
02645 case DCM_TM:
02646 case DCM_UI:
02647 stringLength = MIN(sizeof(scratch) - 1, elementItem->element.length);
02648 strncpy(scratch, elementItem->element.d.string, stringLength);
02649 scratch[stringLength] = '\0';
02650 (void) RWC_printf("%s\n", scratch);
02651 break;
02652 case DCM_AT:
02653 case DCM_UL:
02654 (void) RWC_printf("%8x %d\n", *elementItem->element.d.ul,
02655 *elementItem->element.d.ul);
02656 if (vm > 1)
02657 dumpBinaryData(elementItem->element.d.ot,
02658 elementItem->element.representation,
02659 elementItem->element.length / sizeof(U32), vm);
02660 break;
02661 case DCM_US:
02662 (void) RWC_printf("%4x %d\n", *elementItem->element.d.us,
02663 *elementItem->element.d.us);
02664 if (vm > 1)
02665 dumpBinaryData(elementItem->element.d.ot,
02666 elementItem->element.representation,
02667 elementItem->element.length / sizeof(unsigned short), vm);
02668 break;
02669 case DCM_OT:
02670 case DCM_OW:
02671 case DCM_OB:
02672 /*case DCM_UNKNOWN:*/
02673 case DCM_RET:
02674 (void) RWC_printf("Unimplemented\n");
02675 break;
02676 default:
02677 (void) RWC_printf("Some unimplemented logic if here\n");
02678 break;
02679 }
02680 }
02681 elementItem = (void *)LST_Next(&groupItem->elementList);
02682 }
02683 groupItem = (void *)LST_Next(&(*object)->groupList);
02684 }
02685
02686 RWC_printf("%sDCM Dump Elements Complete\n\n", prefix);
02687 return DCM_NORMAL;
02688 }
|
|
||||||||||||||||||||||||||||
|
Definition at line 7689 of file mri_dicom_hdr.c. References BIG_ORDER, BYTEORDER_REVERSE, checkObject(), COND_PushCondition(), CONDITION, CTN_MALLOC, CTNBOOLEAN, DCM_ELEMENT::d, PRV_ELEMENT_ITEM::dataOffset, DCM_ACCEPTVRMISMATCH, DCM_ELEMENTNOTFOUND, DCM_EXPLICITBIGENDIAN, DCM_EXPLICITLITTLEENDIAN, DCM_GET_COMPRESSED_CALLBACK, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_ORDERBIGENDIAN, DCM_ORDERLITTLEENDIAN, DCM_ORDERMASK, DCM_ORDERNATIVE, DCM_STREAMCOMPLETE, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UL, DCM_UNSPECIFIEDLENGTH, DCM_VRMASK, l, DCM_ELEMENT::length, LITTLE_ORDER, locateElement(), MIN, NATIVE_ORDER, object, PRV_ELEMENT_ITEM::originalDataLength, read(), readGroupElement(), readVRLength(), DCM_ELEMENT::representation, swapInPlace(), and U32.
07692 {
07693 PRIVATE_OBJECT
07694 ** object;
07695 PRV_ELEMENT_ITEM
07696 * elementItem;
07697 S32 nBytes;
07698 S32 toRead;
07699 CONDITION cond;
07700 int doneFlag = 0;
07701 size_t elementLength;
07702 unsigned char *ptr;
07703 U32 size = 0;
07704 off_t fileOffset = 0;
07705 unsigned long opt;
07706 int byteOrder;
07707 int explicitVR;
07708 CTNBOOLEAN acceptVRMismatch = FALSE;
07709 DCM_ELEMENT e;
07710 U32 sequenceLength = 0;
07711 CONDITION flag;
07712 int index = 0;
07713 CTNBOOLEAN firstBuffer = TRUE;
07714 U32 *offsetBuffer = NULL;
07715 U32 offsetBufferCount = 0;
07716 U32 streamOffset = 0;
07717 int startOfFragment = 1;
07718
07719 object = (PRIVATE_OBJECT **) callerObject;
07720 cond = checkObject(object, "DCM_GetCompressedValue");
07721 if (cond != DCM_NORMAL)
07722 return cond;
07723
07724 elementItem = locateElement(object, tag);
07725
07726 if (elementItem == NULL)
07727 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
07728 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
07729 DCM_TAG_ELEMENT(tag),
07730 "DCM_GetEncodedValue");
07731
07732 elementLength = elementItem->originalDataLength;
07733 ptr = NULL; /* Means reading from a file */
07734 size = DCM_UNSPECIFIEDLENGTH;
07735 fileOffset = elementItem->dataOffset;
07736
07737 opt |= (*object)->dataOptions & DCM_ORDERMASK;
07738 explicitVR = FALSE;
07739 switch (opt & DCM_ORDERMASK) {
07740 case DCM_ORDERNATIVE:
07741 byteOrder = NATIVE_ORDER;
07742 break;
07743 case DCM_ORDERLITTLEENDIAN:
07744 byteOrder = LITTLE_ORDER;
07745 break;
07746 case DCM_EXPLICITLITTLEENDIAN:
07747 byteOrder = LITTLE_ORDER;
07748 explicitVR = TRUE;
07749 break;
07750 case DCM_ORDERBIGENDIAN:
07751 byteOrder = BIG_ORDER;
07752 break;
07753 case DCM_EXPLICITBIGENDIAN:
07754 byteOrder = BIG_ORDER;
07755 explicitVR = TRUE;
07756 break;
07757 default:
07758 byteOrder = LITTLE_ORDER;
07759 explicitVR = TRUE;
07760 break;
07761 }
07762 if ((opt & DCM_VRMASK) == DCM_ACCEPTVRMISMATCH)
07763 acceptVRMismatch = TRUE;
07764
07765 (void) lseek((*object)->fd, elementItem->dataOffset, SEEK_SET);
07766 while (elementLength != 0) {
07767 sequenceLength = 0;
07768 memset(&e, 0, sizeof(e));
07769 flag = readGroupElement("", &ptr, (*object)->fd, &size, &fileOffset,
07770 FALSE, byteOrder, explicitVR, acceptVRMismatch,
07771 object, &sequenceLength, &e);
07772 if (flag == DCM_STREAMCOMPLETE)
07773 break;
07774 else if (flag != DCM_NORMAL)
07775 return flag;
07776
07777 flag = readVRLength("", &ptr, (*object)->fd, &size, &fileOffset,
07778 FALSE, /* Known length */
07779 byteOrder, explicitVR, acceptVRMismatch, object,
07780 &sequenceLength, &e);
07781 if (flag != DCM_NORMAL)
07782 return flag;
07783
07784 elementLength -= sequenceLength + e.length;
07785
07786 if (firstBuffer) {
07787 firstBuffer = FALSE;
07788 if (e.length != 0) {
07789 offsetBuffer = CTN_MALLOC(e.length);
07790 offsetBufferCount = e.length / sizeof(U32);
07791 if (offsetBuffer == NULL)
07792 exit(1); /* repair */
07793 nBytes = read((*object)->fd, offsetBuffer, e.length);
07794 if (nBytes != e.length) {
07795 exit(1); /* repair */
07796 }
07797 if (byteOrder == BYTEORDER_REVERSE) {
07798 DCM_ELEMENT offsetBufferElement;
07799 memset(&offsetBufferElement, 0, sizeof(DCM_ELEMENT));
07800 offsetBufferElement.length = e.length;
07801 offsetBufferElement.d.ul = offsetBuffer;
07802 offsetBufferElement.representation = DCM_UL;
07803 swapInPlace(object, &offsetBufferElement);
07804 }
07805 callback(offsetBuffer, e.length, index, 1, 0, 1, ctx);
07806 streamOffset = 0;
07807 } else {
07808 streamOffset = 0xffffffff;
07809 }
07810 } else {
07811 U32 l = e.length;
07812 int j;
07813 int lastIndex;
07814
07815 lastIndex = index;
07816 for (j = 0; j < offsetBufferCount; j++) {
07817 if (streamOffset == offsetBuffer[j])
07818 index = j + 1;
07819 }
07820 startOfFragment = 1;
07821 while (l != 0) {
07822 toRead = MIN(bufSize, l);
07823 nBytes = read((*object)->fd, buf, toRead);
07824 if (nBytes != toRead) {
07825 exit(1); /* repair */
07826 }
07827 callback(buf, toRead, index,
07828 (index != lastIndex) ? 1 : 0,
07829 0, startOfFragment, ctx);
07830 l -= toRead;
07831 lastIndex = index; /* Guarantee first flag is off */
07832 startOfFragment = 0;
07833 }
07834 streamOffset += sequenceLength + e.length;
07835 }
07836 fileOffset += e.length;
07837 index++;
07838 }
07839 callback(buf, 0, index, 0, 1, 1, ctx);
07840 return DCM_NORMAL;
07841 }
|
|
||||||||||||||||
|
Definition at line 3381 of file mri_dicom_hdr.c. References checkObject(), COND_PushCondition(), CONDITION, DCM_ELEMENT::d, DCM_ELEMENTNOTFOUND, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, PRV_ELEMENT_ITEM::element, and locateElement().
03382 {
03383 PRIVATE_OBJECT
03384 ** obj;
03385 CONDITION
03386 cond;
03387 PRV_ELEMENT_ITEM
03388 * elementItem;
03389
03390 obj = (PRIVATE_OBJECT **) callerObject;
03391 cond = checkObject(obj, "DCM_GetElementVM");
03392 if (cond != DCM_NORMAL)
03393 return cond;
03394
03395 elementItem = locateElement(obj, tag);
03396 if (elementItem == NULL)
03397 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
03398 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
03399 DCM_TAG_ELEMENT(tag),
03400 "DCM_GetElementVM");
03401 *element = elementItem->element;
03402 element->d.ot = NULL;
03403 return DCM_NORMAL;
03404 }
|
|
||||||||||||||||
|
Definition at line 1990 of file mri_dicom_hdr.c. References checkObject(), COND_PushCondition(), CONDITION, CTNBOOLEAN, DCM_ELEMENTNOTFOUND, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, DCM_ELEMENT::length, LST_Head(), LST_Next(), LST_Position(), object, DCM_ELEMENT::tag, and U32.
01992 {
01993 PRIVATE_OBJECT
01994 ** object;
01995 PRV_GROUP_ITEM
01996 * groupItem;
01997 PRV_ELEMENT_ITEM
01998 * elementItem;
01999 CONDITION
02000 cond;
02001 CTNBOOLEAN
02002 flag;
02003 unsigned short
02004 group,
02005 element;
02006
02007 object = (PRIVATE_OBJECT **) callerObject;
02008 cond = checkObject(object, "DCM_GetElementSize");
02009 if (cond != DCM_NORMAL)
02010 return cond;
02011
02012 group = DCM_TAG_GROUP(tag);
02013 element = DCM_TAG_ELEMENT(tag);
02014
02015 groupItem = (void *)LST_Head(&((*object)->groupList));
02016 if (groupItem == NULL)
02017 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
02018 DCM_Message(DCM_ELEMENTNOTFOUND), group, element,
02019 "DCM_GetElementSize");
02020
02021 (void) LST_Position(&((*object)->groupList), (void *)groupItem);
02022
02023 flag = FALSE;
02024 while ((groupItem != NULL) && (flag == FALSE)) {
02025 if (groupItem->group == group)
02026 flag = TRUE;
02027 else
02028 groupItem = (void *)LST_Next(&(*object)->groupList);
02029 }
02030 if (flag == FALSE)
02031 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
02032 DCM_Message(DCM_ELEMENTNOTFOUND), group, element,
02033 "DCM_GetElementSize");
02034
02035 elementItem = (void *)LST_Head(&groupItem->elementList);
02036 if (elementItem == NULL)
02037 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
02038 DCM_Message(DCM_ELEMENTNOTFOUND), group, element,
02039 "DCM_GetElementSize");
02040
02041 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
02042
02043 flag = FALSE;
02044 while ((elementItem != NULL) && (flag == FALSE)) {
02045 if (elementItem->element.tag == tag)
02046 flag = TRUE;
02047 else
02048 elementItem = (void *)LST_Next(&groupItem->elementList);
02049 }
02050
02051 if (flag == FALSE)
02052 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
02053 DCM_Message(DCM_ELEMENTNOTFOUND), group, element,
02054 "DCM_GetElementSize");
02055
02056
02057 *rtnLength = elementItem->element.length;
02058 return DCM_NORMAL;
02059 }
|
|
||||||||||||||||||||
|
Definition at line 1651 of file mri_dicom_hdr.c. References PRV_ELEMENT_ITEM::byteOrder, BYTEORDER_REVERSE, checkObject(), COND_PushCondition(), CONDITION, DCM_ELEMENT::d, PRV_ELEMENT_ITEM::dataOffset, DCM_AT, DCM_CANNOTGETSEQUENCEVALUE, DCM_ELEMENTNOTFOUND, DCM_FILEACCESSERROR, DCM_GETINCOMPLETE, DCM_ILLEGALCONTEXT, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_SQ, DCM_TAG_ELEMENT, DCM_TAG_GROUP, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, l, DCM_ELEMENT::length, LST_Head(), LST_Next(), LST_Position(), MIN, object, p, q, read(), DCM_ELEMENT::representation, swapATGroupElement(), swapInPlace(), DCM_ELEMENT::tag, and U32.
01653 {
01654 PRIVATE_OBJECT
01655 ** object;
01656 PRV_GROUP_ITEM
01657 * groupItem;
01658 PRV_ELEMENT_ITEM
01659 * elementItem;
01660 int
01661 nBytes;
01662 CONDITION
01663 cond;
01664
01665 object = (PRIVATE_OBJECT **) callerObject;
01666 cond = checkObject(object, "DCM_GetElementValue");
01667 if (cond != DCM_NORMAL)
01668 return cond;
01669
01670 groupItem = (void *)LST_Head(&(*object)->groupList);
01671 if (groupItem == NULL)
01672 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
01673 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(element->tag),
01674 DCM_TAG_ELEMENT(element->tag),
01675 "DCM_GetElementValue");
01676
01677 (void) LST_Position(&(*object)->groupList, (void *)groupItem);
01678 while (groupItem != NULL) {
01679 if (groupItem->group == DCM_TAG_GROUP(element->tag))
01680 break;
01681
01682 groupItem = (void *)LST_Next(&(*object)->groupList);
01683 }
01684 if (groupItem == NULL)
01685 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
01686 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(element->tag),
01687 DCM_TAG_ELEMENT(element->tag),
01688 "DCM_GetElementValue");
01689
01690 elementItem = (void *)LST_Head(&groupItem->elementList);
01691 if (elementItem == NULL)
01692 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
01693 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(element->tag),
01694 DCM_TAG_GROUP(element->tag),
01695 "DCM_GetElementValue");
01696
01697 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
01698 while (elementItem != NULL) {
01699 if (elementItem->element.tag == element->tag) {
01700 unsigned char *p;
01701 U32 l;
01702
01703 if (element->representation == DCM_SQ)
01704 return COND_PushCondition(DCM_CANNOTGETSEQUENCEVALUE,
01705 DCM_Message(DCM_CANNOTGETSEQUENCEVALUE),
01706 element->tag, "DCM_GetElementValue");
01707
01708 p = *ctx;
01709 if ((U32) p > elementItem->element.length)
01710 return COND_PushCondition(DCM_ILLEGALCONTEXT,
01711 DCM_Message(DCM_ILLEGALCONTEXT),
01712 "DCM_GetElementValue");
01713
01714 l = MIN(element->length, (elementItem->element.length - (U32) p));
01715
01716 *rtnLength = l;
01717 {
01718 if (elementItem->element.d.ot == NULL) {
01719 if ((*object)->fd != -1) {
01720 (void) lseek((*object)->fd,
01721 elementItem->dataOffset + (off_t) p, SEEK_SET);
01722 nBytes = read((*object)->fd, element->d.ot, (int) l);
01723 } else {
01724 (*object)->sk((*object)->userCtx,
01725 (long) (elementItem->dataOffset + (off_t) p), SEEK_SET);
01726 cond = (*object)->rd((*object)->userCtx, element->d.ot, l,
01727 &nBytes);
01728 }
01729 if ((unsigned) nBytes != l) {
01730 return COND_PushCondition(DCM_FILEACCESSERROR,
01731 DCM_Message(DCM_FILEACCESSERROR),
01732 (*object)->fileName,
01733 "DCM_GetElementValue");
01734 }
01735 if( LITTLE_ENDIAN_ARCHITECTURE ){
01736 if (elementItem->element.representation == DCM_AT) {
01737 DCM_ELEMENT e;
01738 e = elementItem->element;
01739 e.length = l;
01740 e.d.ot = element->d.ot;
01741 swapATGroupElement(&e);
01742 }
01743 }
01744 if (elementItem->byteOrder == BYTEORDER_REVERSE) {
01745 DCM_ELEMENT e;
01746 e = elementItem->element;
01747 e.length = l;
01748 e.d.ot = element->d.ot;
01749 swapInPlace(object, &e);
01750 }
01751 } else {
01752 unsigned char *q;
01753 q = (unsigned char *) elementItem->element.d.ot +
01754 (U32) p;
01755 (void) memcpy(element->d.ot, q, l);
01756 if (elementItem->byteOrder == BYTEORDER_REVERSE) {
01757 DCM_ELEMENT e;
01758 e = elementItem->element;
01759 e.length = l;
01760 e.d.ot = element->d.ot;
01761 swapInPlace(object, &e);
01762 }
01763 }
01764 p += l;
01765 *ctx = (void *) p;
01766 if ((unsigned) p == elementItem->element.length)
01767 return DCM_NORMAL;
01768 else
01769 return DCM_GETINCOMPLETE;
01770 }
01771
01772 }
01773 elementItem = (void *)LST_Next(&groupItem->elementList);
01774 }
01775 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
01776 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(element->tag),
01777 DCM_TAG_ELEMENT(element->tag),
01778 "DCM_GetElementValue");
01779 }
|
|
||||||||||||||||||||||||
|
Definition at line 3198 of file mri_dicom_hdr.c. References checkObject(), COND_PushCondition(), CONDITION, CTN_MALLOC, CTNBOOLEAN, DCM_ELEMENT::d, DCM_DELIMITOR, DCM_ELEMENTNOTFOUND, DCM_IsString(), DCM_LISTFAILURE, DCM_MALLOCFAILURE, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UNEXPECTEDREPRESENTATION, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, l, DCM_ELEMENT::length, LST_Enqueue(), LST_Head(), LST_Next(), LST_NORMAL, LST_Position(), object, p, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and U32.
03200 {
03201 PRIVATE_OBJECT
03202 ** obj;
03203 CONDITION
03204 cond;
03205 PRV_GROUP_ITEM
03206 * groupItem;
03207 PRV_ELEMENT_ITEM
03208 * elementItem;
03209 CTNBOOLEAN
03210 found = FALSE;
03211 char
03212 *src,
03213 *dst,
03214 *p;
03215 U32
03216 l;
03217
03218 obj = (PRIVATE_OBJECT **) object;
03219 cond = checkObject(obj, "DCM_GetSequenceList");
03220 if (cond != DCM_NORMAL)
03221 return cond;
03222
03223 groupItem = (void *)LST_Head(&(*obj)->groupList);
03224 if (groupItem == NULL)
03225 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
03226 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
03227 DCM_TAG_ELEMENT(tag),
03228 "DCM_GetSequenceList");
03229
03230 (void) LST_Position(&(*obj)->groupList, (void *)groupItem);
03231 while (groupItem != NULL) {
03232 if (groupItem->group == DCM_TAG_GROUP(tag))
03233 break;
03234
03235 groupItem = (void *)LST_Next(&(*obj)->groupList);
03236 }
03237 if (groupItem == NULL)
03238 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
03239 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
03240 DCM_TAG_ELEMENT(tag),
03241 "DCM_GetSequenceList");
03242
03243 elementItem = (void *)LST_Head(&groupItem->elementList);
03244 if (elementItem == NULL)
03245 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
03246 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
03247 DCM_TAG_GROUP(tag),
03248 "DCM_GetSequenceTag");
03249
03250 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
03251 while (!found && (elementItem != NULL)) {
03252 if (elementItem->element.tag == tag) {
03253 found = TRUE;
03254 } else
03255 elementItem = (void *)LST_Next(&groupItem->elementList);
03256 }
03257 if (!found)
03258 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
03259 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
03260 DCM_TAG_ELEMENT(tag),
03261 "DCM_GetElementValueList");
03262
03263 if (!DCM_IsString(elementItem->element.representation)) {
03264 return COND_PushCondition(DCM_UNEXPECTEDREPRESENTATION,
03265 DCM_Message(DCM_UNEXPECTEDREPRESENTATION), "DCM_GetElementValueList",
03266 "string");
03267 }
03268 src = elementItem->element.d.string;
03269 l = elementItem->element.length;
03270 while (l > 0) {
03271 while (l > 1 && (*src == ' ' || *src == DCM_DELIMITOR)) {
03272 l--;
03273 src++;
03274 }
03275 if ((l == 1) && (*src == ' ' || *src == DCM_DELIMITOR))
03276 l--;
03277
03278 if (l != 0) {
03279 p = CTN_MALLOC(structureSize);
03280 if (p == NULL)
03281 return COND_PushCondition(DCM_MALLOCFAILURE,
03282 DCM_Message(DCM_MALLOCFAILURE), structureSize,
03283 "DCM_GetElementValueList");
03284 dst = p + stringOffset;
03285 while ((l > 1) && (*src != DCM_DELIMITOR)) {
03286 *dst++ = *src++;
03287 l--;
03288 }
03289 if ((l == 1) && (*src != ' ')) {
03290 *dst++ = *src++;
03291 l--;
03292 }
03293 *dst = '\0';;
03294 cond = LST_Enqueue(list, (void *)p);
03295 if (cond != LST_NORMAL)
03296 return COND_PushCondition(DCM_LISTFAILURE,
03297 DCM_Message(DCM_LISTFAILURE), "DCM_GetElementValueList");
03298 }
03299 }
03300 return DCM_NORMAL;
03301 }
|
|
||||||||||||||||
|
Definition at line 1866 of file mri_dicom_hdr.c. References PRV_ELEMENT_ITEM::byteOrder, BYTEORDER_REVERSE, checkObject(), COND_PushCondition(), CONDITION, DCM_ELEMENT::d, PRV_ELEMENT_ITEM::dataOffset, DCM_AT, DCM_BADLENGTH, DCM_BADOFFSET, DCM_CANNOTGETSEQUENCEVALUE, DCM_ELEMENTNOTFOUND, DCM_FILEACCESSERROR, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_SQ, DCM_TAG_ELEMENT, DCM_TAG_GROUP, PRV_ELEMENT_ITEM::element, l, DCM_ELEMENT::length, locateElement(), object, offset, p, q, read(), DCM_ELEMENT::representation, swapATGroupElement(), swapInPlace(), DCM_ELEMENT::tag, and U32.
01868 {
01869 PRIVATE_OBJECT **object;
01870 PRV_ELEMENT_ITEM *elementItem;
01871 int nBytes;
01872 CONDITION cond;
01873
01874 object = (PRIVATE_OBJECT **) callerObject;
01875 cond = checkObject(object, "DCM_GetElementValue");
01876 if (cond != DCM_NORMAL)
01877 return cond;
01878
01879 elementItem = locateElement(object, element->tag);
01880 if (elementItem == NULL)
01881 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
01882 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(element->tag),
01883 DCM_TAG_ELEMENT(element->tag),
01884 "DCM_GetElementValueOffset");
01885
01886
01887 {
01888 unsigned char *p;
01889 U32 l;
01890
01891 if (element->representation == DCM_SQ)
01892 return COND_PushCondition(DCM_CANNOTGETSEQUENCEVALUE,
01893 DCM_Message(DCM_CANNOTGETSEQUENCEVALUE),
01894 element->tag, "DCM_GetElementValueOffset");
01895
01896 p = (unsigned char *) offset;;
01897 if ((U32) p > elementItem->element.length)
01898 return COND_PushCondition(DCM_BADOFFSET,
01899 DCM_Message(DCM_BADOFFSET),
01900 (int) offset,
01901 (int) elementItem->element.length,
01902 "DCM_GetElementValueLength");
01903
01904 l = element->length;
01905 if (l + offset > elementItem->element.length) {
01906 return COND_PushCondition(DCM_BADLENGTH,
01907 DCM_Message(DCM_BADLENGTH),
01908 (int) offset, (int) l,
01909 (int) elementItem->element.length,
01910 "DCM_GetElementValueLength");
01911 } {
01912 if (elementItem->element.d.ot == NULL) {
01913 if ((*object)->fd != -1) {
01914 (void) lseek((*object)->fd,
01915 elementItem->dataOffset + (off_t) p, SEEK_SET);
01916 nBytes = read((*object)->fd, element->d.ot, (int) l);
01917 } else {
01918 (*object)->sk((*object)->userCtx,
01919 (long) (elementItem->dataOffset + (off_t) p), SEEK_SET);
01920 cond = (*object)->rd((*object)->userCtx, element->d.ot, l,
01921 &nBytes);
01922 }
01923 if ((unsigned) nBytes != l) {
01924 return COND_PushCondition(DCM_FILEACCESSERROR,
01925 DCM_Message(DCM_FILEACCESSERROR),
01926 (*object)->fileName,
01927 "DCM_GetElementValueValue");
01928 }
01929 if( LITTLE_ENDIAN_ARCHITECTURE ){
01930 if (elementItem->element.representation == DCM_AT) {
01931 DCM_ELEMENT e;
01932 e = elementItem->element;
01933 e.length = l;
01934 e.d.ot = element->d.ot;
01935 swapATGroupElement(&e);
01936 }
01937 }
01938 if (elementItem->byteOrder == BYTEORDER_REVERSE) {
01939 DCM_ELEMENT e;
01940 e = elementItem->element;
01941 e.length = l;
01942 e.d.ot = element->d.ot;
01943 swapInPlace(object, &e);
01944 }
01945 } else {
01946 unsigned char *q;
01947 q = (unsigned char *) elementItem->element.d.ot +
01948 (U32) p;
01949 (void) memcpy(element->d.ot, q, l);
01950 if (elementItem->byteOrder == BYTEORDER_REVERSE) {
01951 DCM_ELEMENT e;
01952 e = elementItem->element;
01953 e.length = l;
01954 e.d.ot = element->d.ot;
01955 swapInPlace(object, &e);
01956 }
01957 }
01958 return DCM_NORMAL;
01959 }
01960
01961 }
01962 }
|
|
||||||||||||
|
dst = (DCM_OBJECT *) dstObj; Definition at line 8047 of file mri_dicom_hdr.c. References checkObject(), CONDITION, DCM_EMPTYOBJECT, DCM_GetNextElement(), DCM_NORMAL, DCM_OBJECT, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, LST_Head(), LST_Position(), and object.
08048 {
08049 PRIVATE_OBJECT** object;
08050 PRV_GROUP_ITEM* groupItem;
08051 PRV_ELEMENT_ITEM* elementItem;
08052 CONDITION cond;
08053
08054 object = (PRIVATE_OBJECT **) callerObject;
08055 cond = checkObject(object, "DCM_GetFirstElement");
08056 if (cond != DCM_NORMAL)
08057 return cond;
08058
08059 groupItem = (void *)LST_Head(&(*object)->groupList);
08060
08061 if (groupItem == NULL) {
08062 *e = 0;
08063 return DCM_EMPTYOBJECT;
08064 }
08065 (void) LST_Position(&(*object)->groupList, (void *)groupItem);
08066 (*object)->groupCtx = groupItem;
08067
08068 elementItem = (void *)LST_Head(&groupItem->elementList);
08069 (*object)->elementCtx = elementItem;
08070 if (elementItem == NULL) {
08071 return DCM_GetNextElement(callerObject, e);
08072 }
08073
08074 *e = &elementItem->element;
08075 return DCM_NORMAL;
08076 }
|
|
||||||||||||
|
Definition at line 8079 of file mri_dicom_hdr.c. References checkObject(), CONDITION, DCM_GetNextElement(), DCM_GETNEXTELEMENTCOMPLETE, DCM_NORMAL, DCM_OBJECT, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, LST_Head(), LST_Next(), LST_Position(), and object.
08080 {
08081 PRIVATE_OBJECT** object;
08082 PRV_GROUP_ITEM* groupItem;
08083 PRV_ELEMENT_ITEM* elementItem;
08084 CONDITION cond;
08085
08086 object = (PRIVATE_OBJECT **) callerObject;
08087 cond = checkObject(object, "DCM_GetNextElement");
08088 if (cond != DCM_NORMAL)
08089 return cond;
08090
08091 groupItem = (*object)->groupCtx;
08092 elementItem = (*object)->elementCtx;
08093
08094 if (elementItem != 0) {
08095 (void)LST_Position(&groupItem->elementList, (void *)elementItem);
08096 elementItem = (PRV_ELEMENT_ITEM*)LST_Next(&groupItem->elementList);
08097 }
08098
08099 if (elementItem == 0) {
08100 (void)LST_Position(&(*object)->groupList, (void *)groupItem);
08101 groupItem = (PRV_GROUP_ITEM*)LST_Next(&(*object)->groupList);
08102 if (groupItem != 0) {
08103 elementItem = (PRV_ELEMENT_ITEM*)LST_Head(&groupItem->elementList);
08104 }
08105 }
08106
08107 if (groupItem == 0) {
08108 *e = 0;
08109 return DCM_GETNEXTELEMENTCOMPLETE;
08110 }
08111
08112 (*object)->groupCtx = groupItem;
08113 (*object)->elementCtx = elementItem;
08114
08115 if (elementItem == 0)
08116 return DCM_GetNextElement(callerObject, e);
08117
08118 *e = &elementItem->element;
08119 return DCM_NORMAL;
08120 }
|
|
||||||||||||
|
Definition at line 2242 of file mri_dicom_hdr.c. References checkObject(), CONDITION, DCM_NORMAL, DCM_OBJECT, and object.
02243 {
02244 PRIVATE_OBJECT
02245 ** object;
02246 CONDITION
02247 cond;
02248
02249 object = (PRIVATE_OBJECT **) callerObject;
02250 cond = checkObject(object, "DCM_GetObjectSize");
02251 if (cond != DCM_NORMAL)
02252 return cond;
02253
02254 *returnlength = (*object)->objectSize;
02255 return DCM_NORMAL;
02256 }
|
|
||||||||||||||||||||
|
Definition at line 7880 of file mri_dicom_hdr.c. References checkObject(), COND_PushCondition(), CONDITION, DCM_ELEMENT::d, DCM_ELEMENTNOTFOUND, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, PRV_ELEMENT_ITEM::element, locateElement(), LST_Head(), LST_Next(), LST_Position(), DCM_SEQUENCE_ITEM::object, object, PRIVATE_OBJECT::offset, and offset.
07882 {
07883 PRIVATE_OBJECT **obj,
07884 *sqObject;
07885 CONDITION cond;
07886 PRV_ELEMENT_ITEM *elementItem;
07887 LST_HEAD *lst;
07888 DCM_SEQUENCE_ITEM *sqItem;
07889
07890 obj = (PRIVATE_OBJECT **) object;
07891 cond = checkObject(obj, "DCM_PrintSequenceList");
07892 if (cond != DCM_NORMAL)
07893 return cond;
07894
07895 elementItem = locateElement(obj, tag);
07896
07897 if (elementItem == NULL)
07898 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
07899 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
07900 DCM_TAG_ELEMENT(tag),
07901 "DCM_PrintSequenceList");
07902
07903 lst = elementItem->element.d.sq;
07904 sqItem = (void *)LST_Head(&lst);
07905 (void) LST_Position(&lst, (void *)sqItem);
07906 while (sqItem != NULL) {
07907 sqObject = (PRIVATE_OBJECT *) sqItem->object;
07908 if (sqObject->offset == offset) {
07909 *rtnObject = sqItem->object;
07910 return DCM_NORMAL;
07911 }
07912 sqItem = (void *)LST_Next(&lst);
07913 }
07914 return 0;
07915 }
|
|
||||||||||||||||
|
Definition at line 3139 of file mri_dicom_hdr.c. References checkObject(), COND_PushCondition(), CONDITION, CTNBOOLEAN, DCM_ELEMENT::d, DCM_ELEMENTNOTFOUND, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_ParseObject(), DCM_SQ, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UNEXPECTEDREPRESENTATION, PRV_ELEMENT_ITEM::element, locateElement(), LST_Head(), DCM_SEQUENCE_ITEM::object, object, DCM_ELEMENT::representation, and top.
03140 {
03141 PRIVATE_OBJECT **obj;
03142 CONDITION cond;
03143 PRV_GROUP_ITEM *groupItem;
03144 PRV_ELEMENT_ITEM *elementItem;
03145 DCM_SEQUENCE_ITEM *seqItem;
03146
03147 CTNBOOLEAN found = FALSE;
03148
03149 obj = (PRIVATE_OBJECT **) object;
03150 cond = checkObject(obj, "DCM_GetSequenceElement");
03151 if (cond != DCM_NORMAL)
03152 return cond;
03153
03154 elementItem = locateElement(obj, top);
03155 if (elementItem == NULL) {
03156 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
03157 DCM_Message(DCM_ELEMENTNOTFOUND),
03158 DCM_TAG_GROUP(top),
03159 DCM_TAG_ELEMENT(top),
03160 "DCM_GetElementSequence");
03161 }
03162 if (elementItem->element.representation != DCM_SQ) {
03163 return COND_PushCondition(DCM_UNEXPECTEDREPRESENTATION,
03164 DCM_Message(DCM_UNEXPECTEDREPRESENTATION),
03165 "DCM_GetSequenceElement", "sequence");
03166 }
03167 seqItem = (void *)LST_Head(&elementItem->element.d.sq);
03168 cond = DCM_ParseObject(&seqItem->object, e, 1, NULL, 0, NULL);
03169 return cond;
03170
03171 #if 0
03172 return DCM_NORMAL;
03173 #endif
03174 }
|
|
||||||||||||||||
|
Definition at line 3076 of file mri_dicom_hdr.c. References checkObject(), COND_PushCondition(), CONDITION, CTNBOOLEAN, DCM_ELEMENT::d, DCM_ELEMENTNOTFOUND, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, LST_Head(), LST_Next(), LST_Position(), object, and DCM_ELEMENT::tag.
03077 {
03078 PRIVATE_OBJECT
03079 ** obj;
03080 CONDITION
03081 cond;
03082 PRV_GROUP_ITEM
03083 * groupItem;
03084 PRV_ELEMENT_ITEM
03085 * elementItem;
03086 CTNBOOLEAN
03087 found = FALSE;
03088
03089 obj = (PRIVATE_OBJECT **) object;
03090 cond = checkObject(obj, "DCM_GetSequenceList");
03091 if (cond != DCM_NORMAL)
03092 return cond;
03093
03094 groupItem = (void *)LST_Head(&(*obj)->groupList);
03095 if (groupItem == NULL)
03096 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
03097 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
03098 DCM_TAG_ELEMENT(tag),
03099 "DCM_GetSequenceList");
03100
03101 (void) LST_Position(&(*obj)->groupList, (void *)groupItem);
03102 while (groupItem != NULL) {
03103 if (groupItem->group == DCM_TAG_GROUP(tag))
03104 break;
03105
03106 groupItem = (void *)LST_Next(&(*obj)->groupList);
03107 }
03108 if (groupItem == NULL)
03109 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
03110 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
03111 DCM_TAG_ELEMENT(tag),
03112 "DCM_GetSequenceList");
03113
03114 elementItem = (void *)LST_Head(&groupItem->elementList);
03115 if (elementItem == NULL)
03116 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
03117 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
03118 DCM_TAG_GROUP(tag),
03119 "DCM_GetSequenceTag");
03120
03121 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
03122 while (!found && (elementItem != NULL)) {
03123 if (elementItem->element.tag == tag) {
03124 *list = elementItem->element.d.sq;
03125 found = TRUE;
03126 }
03127 elementItem = (void *)LST_Next(&groupItem->elementList);
03128 }
03129 if (found)
03130 return DCM_NORMAL;
03131 else
03132 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
03133 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
03134 DCM_TAG_ELEMENT(tag),
03135 "DCM_GetSequenceList");
03136 }
|
|
||||||||||||
|
Definition at line 1782 of file mri_dicom_hdr.c. References AFMALL, COND_PopCondition(), CONDITION, DCM_ELEMENT::d, DCM_AT, DCM_CTX, DCM_DLM, DCM_FD, DCM_FL, DCM_GetElement(), DCM_IsString(), DCM_NORMAL, DCM_OB, DCM_OBJECT, DCM_OW, DCM_ParseObject(), DCM_RET, DCM_SL, DCM_SQ, DCM_SS, DCM_TAG, DCM_UL, DCM_UN, DCM_US, free, DCM_ELEMENT::length, malloc, DCM_ELEMENT::representation, and DCM_ELEMENT::tag.
01783 {
01784 DCM_ELEMENT e;
01785 CONDITION cond;
01786 char* s;
01787 char tmp[64] = "";
01788 char b[64] = "";
01789
01790 e.tag = tag;
01791 cond = DCM_GetElement(callerObject, tag, &e);
01792 if (cond != DCM_NORMAL) {
01793 COND_PopCondition(TRUE);
01794 return 0;
01795 }
01796
01797 if (DCM_IsString(e.representation)) {
01798 s = AFMALL( char, e.length + 1);
01799 e.d.string = s;
01800 cond = DCM_ParseObject(callerObject, &e, 1, 0, 0, 0);
01801 if (cond != DCM_NORMAL) {
01802 free(s);
01803 s = 0;
01804 }
01805 return s;
01806 }
01807
01808 if (e.representation == DCM_SQ) {
01809 return 0;
01810 }
01811
01812 if (e.length > sizeof(b))
01813 return 0;
01814
01815 e.d.ot = b;
01816 cond = DCM_ParseObject(callerObject, &e, 1, 0, 0, 0);
01817 if (cond != DCM_NORMAL) {
01818 COND_PopCondition(TRUE);
01819 return 0;
01820 }
01821
01822 switch (e.representation) {
01823 case DCM_AT:
01824 case DCM_FD:
01825 case DCM_FL:
01826 strcpy(tmp, "<Unimplemented>");
01827 break;
01828 case DCM_SL:
01829 sprintf(tmp, "%d", *e.d.sl);
01830 break;
01831 case DCM_SQ:
01832 strcpy(tmp, "<Unimplemented>");
01833 break;
01834 case DCM_SS:
01835 sprintf(tmp, "%d", *e.d.ss);
01836 break;
01837 case DCM_UL:
01838 sprintf(tmp, "%d", *e.d.ul);
01839 break;
01840 case DCM_UN:
01841 strcpy(tmp, "<Unimplemented>");
01842 break;
01843 case DCM_US:
01844 sprintf(tmp, "%d", *e.d.us);
01845 break;
01846 /*case DCM_UNKNOWN:*/
01847 case DCM_RET:
01848 case DCM_CTX:
01849 case DCM_OB:
01850 case DCM_OW:
01851 case DCM_DLM:
01852 default:
01853 strcpy(tmp, "<Unimplemented>");
01854 break;
01855 }
01856
01857 s = (char*) malloc(strlen(tmp) + 1);
01858 strcpy(s, tmp);
01859
01860 return s;
01861 }
|
|
||||||||||||||||
|
Definition at line 10384 of file mri_dicom_hdr.c. References DCM_NORMAL, DIM_OF, and i.
10386 {
10387 int i;
10388
10389 for (i = 0; i < (int) DIM_OF(groupTable); i++) {
10390 if ((group == 0xffff) || (group == groupTable[i].group)) {
10391 callback(groupTable[i].group, groupTable[i].description, ctx);
10392 }
10393 }
10394 return DCM_NORMAL;
10395 }
|
|
||||||||||||
|
Definition at line 3488 of file mri_dicom_hdr.c. References checkObject(), CONDITION, CTNBOOLEAN, DCM_NORMAL, DCM_OBJECT, PRV_GROUP_ITEM::group, LST_Head(), LST_Next(), LST_Position(), object, and U16.
03489 {
03490 PRIVATE_OBJECT **object;
03491 PRV_GROUP_ITEM * item;
03492 CONDITION cond;
03493 CTNBOOLEAN tooFar = FALSE;
03494
03495 object = (PRIVATE_OBJECT **) o1;
03496 cond = checkObject(object, "DCM_CompareAttributes");
03497 if (cond != DCM_NORMAL)
03498 return FALSE;
03499
03500
03501 item = (void *)LST_Head(&(*object)->groupList);
03502 if (item != NULL)
03503 (void) LST_Position(&(*object)->groupList, (void *)item);
03504
03505 while (item != NULL && !tooFar) {
03506 if (item->group == group) {
03507 return TRUE;
03508 } else if (item->group > group) {
03509 tooFar = TRUE;
03510 } else {
03511 item = (void *)LST_Next(&(*object)->groupList);
03512 }
03513 }
03514 return FALSE;
03515 }
|
|
||||||||||||||||||||
|
Definition at line 2203 of file mri_dicom_hdr.c. References COND_PushCondition(), DCM_ILLEGALOPTION, DCM_Message(), DCM_OBJECT, DCM_ORDERMASK, and readFile().
02205 {
02206 #ifdef DEBUG
02207 if (debug)
02208 (void) fprintf(stderr, "DCM_ImportStream, %ld bytes\n", length);
02209 #endif
02210
02211 if ((opt & DCM_ORDERMASK) == 0)
02212 return COND_PushCondition(DCM_ILLEGALOPTION,
02213 DCM_Message(DCM_ILLEGALOPTION), "Byte order",
02214 "DCM_ImportStream");
02215
02216 return readFile("", buf, -1, length, 0, 0, opt, callerObject, NULL, NULL,
02217 NULL, NULL, NULL);
02218 }
|
|
|
Definition at line 10611 of file mri_dicom_hdr.c. References CTNBOOLEAN, DCM_AE, DCM_AS, DCM_AT, DCM_CS, DCM_CTX, DCM_DA, DCM_DD, DCM_DS, DCM_DT, DCM_FD, DCM_FL, DCM_IS, DCM_LO, DCM_LT, DCM_OB, DCM_OT, DCM_OW, DCM_PN, DCM_RET, DCM_SH, DCM_SL, DCM_SQ, DCM_SS, DCM_ST, DCM_TM, DCM_UI, DCM_UL, DCM_US, DCM_UT, and DCM_VALUEREPRESENTATION.
10612 {
10613 CTNBOOLEAN
10614 flag = FALSE;
10615
10616 switch (representation) {
10617 case DCM_AE: /* Application Entity */
10618 case DCM_AS: /* Age string */
10619 flag = TRUE;
10620 break;
10621 case DCM_AT: /* Attribute tag */
10622 break;
10623 case DCM_CS: /* Control string */
10624 case DCM_DA: /* Date */
10625 flag = TRUE;
10626 break;
10627 case DCM_DD: /* Data set */
10628 break;
10629 case DCM_DS: /* Decimal string */
10630 case DCM_DT: /* Old date/time */
10631 flag = TRUE;
10632 break;
10633 case DCM_FD: /* Floating double */
10634 case DCM_FL: /* Float */
10635 break;
10636 case DCM_IS: /* Integer string */
10637 case DCM_LO: /* Long string */
10638 case DCM_LT: /* Long text */
10639 flag = TRUE;
10640 break;
10641 case DCM_OB: /* Other binary value (byte) */
10642 case DCM_OT: /* Other binary value */
10643 case DCM_OW: /* Other binary value (word) */
10644 break;
10645 case DCM_SH: /* Short string */
10646 flag = TRUE;
10647 break;
10648 case DCM_SL: /* Signed long */
10649 case DCM_SQ: /* Sequence of items */
10650 case DCM_SS: /* Signed short */
10651 break;
10652 case DCM_ST: /* Short text */
10653 case DCM_TM: /* Time */
10654 flag = TRUE;
10655 break;
10656 case DCM_UL: /* Unsigned long */
10657 case DCM_US: /* Unsigned short */
10658 /*case DCM_UNKNOWN:*/ /* Unknown/unspecified */
10659 case DCM_RET: /* Retired */
10660 case DCM_CTX: /* Context sensitive */
10661 break;
10662 case DCM_PN: /* Person Name */
10663 case DCM_UI: /* Unique identifier (UID) */
10664 case DCM_UT: /* Unlimited Text */
10665 flag = TRUE;
10666 break;
10667 };
10668 return flag;
10669 }
|
|
||||||||||||||||
|
Definition at line 10539 of file mri_dicom_hdr.c. References c, COND_PushCondition(), CTN_MALLOC, DCM_LISTFAILURE, DCM_MALLOCFAILURE, DCM_Message(), DCM_NORMAL, LST_Head(), LST_Next(), LST_Position(), offset, and p.
10540 {
10541 GENERIC
10542 * g;
10543 char
10544 *c,
10545 *p;
10546 long
10547 length;
10548
10549 *string = NULL;
10550 if (list == NULL)
10551 return DCM_NORMAL;
10552
10553 g = (void *)LST_Head(&list);
10554 if (g == NULL)
10555 return DCM_NORMAL;
10556
10557 (void) LST_Position(&list, (void *)g);
10558
10559 length = 0;
10560 while (g != NULL) {
10561 c = ((char *) g) + offset;
10562 length += strlen(c) + 1;
10563 g = (void *)LST_Next(&list);
10564 }
10565
10566 p = CTN_MALLOC(length);
10567 if (p == NULL)
10568 return COND_PushCondition(DCM_MALLOCFAILURE,
10569 DCM_Message(DCM_MALLOCFAILURE), length, "DCM_ListToString");
10570
10571 *string = p;
10572 g = (void *)LST_Head(&list);
10573 if (g == NULL)
10574 return COND_PushCondition(DCM_LISTFAILURE, DCM_Message(DCM_LISTFAILURE),
10575 "DCM_ListToString");
10576 (void) LST_Position(&list, (void *)g);
10577
10578 length = 0;
10579 while (g != NULL) {
10580 c = ((char *) g) + offset;
10581 length = strlen(c);
10582 (void) memcpy(p, c, length);
10583 p += length;
10584 *p++ = '\\';
10585 g = (void *)LST_Next(&list);
10586 }
10587 *--p = '\0';
10588 return DCM_NORMAL;
10589 }
|
|
|
Definition at line 10256 of file mri_dicom_hdr.c. References COND_PushCondition(), DCM_Message(), DCM_NORMAL, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UL, DCM_UN, DCM_UNRECOGNIZEDELEMENT, DCM_UNRECOGNIZEDGROUP, DCM_ELEMENT::description, GROUPPTR::dict, DCMDICT::englishDescription, GROUPPTR::entries, GROUPPTR::group, p, DCMDICT::representation, DCM_ELEMENT::representation, DCMDICT::tag, and DCM_ELEMENT::tag.
10257 {
10258 int
10259 found;
10260 unsigned long
10261 index,
10262 entries;
10263 GROUPPTR
10264 * p;
10265 DCMDICT
10266 * dictionaryPtr;
10267
10268 element->representation = DCM_UN;
10269 (void) strcpy(element->description, "");
10270
10271 for (index = 0, p = NULL;
10272 index < sizeof(group_dictionary) / sizeof(group_dictionary[0]) && p == NULL;
10273 index++)
10274 if (DCM_TAG_GROUP(element->tag) == group_dictionary[index].group)
10275 p = &group_dictionary[index];
10276
10277 if (p == NULL) {
10278 if (DCM_TAG_ELEMENT(element->tag) == 0x0000) {
10279 element->representation = DCM_UL;
10280 (void) strcpy(element->description, "Unknown group length");
10281 return DCM_NORMAL;
10282 }
10283 return COND_PushCondition(DCM_UNRECOGNIZEDGROUP,
10284 DCM_Message(DCM_UNRECOGNIZEDGROUP),
10285 DCM_TAG_GROUP(element->tag),
10286 "DCM_LookupElement");
10287 }
10288 entries = p->entries;
10289 dictionaryPtr = p->dict;
10290
10291 for (found = 0; !found && entries > 0; entries--)
10292 if (element->tag == dictionaryPtr->tag)
10293 found++;
10294 else
10295 dictionaryPtr++;
10296
10297 if (!found)
10298 return COND_PushCondition(DCM_UNRECOGNIZEDELEMENT,
10299 DCM_Message(DCM_UNRECOGNIZEDELEMENT),
10300 DCM_TAG_GROUP(element->tag),
10301 DCM_TAG_ELEMENT(element->tag),
10302 "DCM_LookupElement");
10303
10304
10305 element->representation = dictionaryPtr->representation;
10306 (void) strcpy(element->description, dictionaryPtr->englishDescription);
10307 return DCM_NORMAL;
10308 }
|
|
||||||||||||
|
Definition at line 7998 of file mri_dicom_hdr.c. References COND_PushCondition(), copySequence(), DCM_AddElement(), DCM_MALLOCFAILURE, DCM_Message(), DCM_NORMAL, DCM_NULLADDRESS, DCM_OBJECT, DCM_OBJECTCREATEFAILED, DCM_SQ, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, LST_Head(), LST_Next(), LST_Position(), and DCM_ELEMENT::representation.
07999 {
08000 PRIVATE_OBJECT **srcObj;
08001 PRIVATE_OBJECT *dstObj;
08002 PRV_GROUP_ITEM *groupItem;
08003 PRV_ELEMENT_ITEM *elementItem;
08004
08005 if (src == NULL) {
08006 (void) COND_PushCondition(DCM_NULLADDRESS,
08007 DCM_Message(DCM_NULLADDRESS), "DCM_MergeObject");
08008 return COND_PushCondition(DCM_OBJECTCREATEFAILED,
08009 DCM_Message(DCM_OBJECTCREATEFAILED), "DCM_MergeObject");
08010 }
08011 dstObj = *((PRIVATE_OBJECT **)dst);
08012 if (dstObj == NULL) {
08013 (void) COND_PushCondition(DCM_MALLOCFAILURE,
08014 DCM_Message(DCM_MALLOCFAILURE), sizeof(PRIVATE_OBJECT),
08015 "DCM_MergeObject");
08016 *dst = NULL;
08017 return COND_PushCondition(DCM_OBJECTCREATEFAILED,
08018 DCM_Message(DCM_OBJECTCREATEFAILED), "DCM_MergeObject");
08019 }
08020 srcObj = (PRIVATE_OBJECT **) src;
08021
08022 groupItem = (void *)LST_Head(&(*srcObj)->groupList);
08023 if (groupItem != NULL)
08024 (void) LST_Position(&(*srcObj)->groupList, (void *)groupItem);
08025
08026 while (groupItem != NULL) {
08027 elementItem = (void *)LST_Head(&groupItem->elementList);
08028 if (elementItem != NULL)
08029 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
08030 while (elementItem != NULL) {
08031 if (elementItem->element.representation == DCM_SQ) {
08032 copySequence(&dstObj, &elementItem->element);
08033 } else {
08034 DCM_AddElement((DCM_OBJECT **) & dstObj, &elementItem->element);
08035 }
08036 elementItem = (void *)LST_Next(&groupItem->elementList);
08037 }
08038 groupItem = (void *)LST_Next(&(*srcObj)->groupList);
08039 }
08040
08041 /**dst = (DCM_OBJECT *) dstObj;*/
08042 return DCM_NORMAL;
08043 }
|
|
|
Definition at line 8321 of file mri_dicom_hdr.c. References vector::cond, CONDITION, and vector::message.
08322 {
08323 int
08324 index;
08325
08326 for (index = 0; messageVector[index].message != NULL; index++)
08327 if (condition == messageVector[index].cond)
08328 return messageVector[index].message;
08329
08330 return NULL;
08331 }
|
|
||||||||||||||||||||||||||||
|
Definition at line 2827 of file mri_dicom_hdr.c. References c, checkObject(), COND_PopCondition(), CONDITION, DCM_ELEMENT::d, DCM_AddElement(), DCM_IsString(), DCM_NORMAL, DCM_OBJECT, DCM_RemoveElement(), DCM_FLAGGED_ELEMENT::e, DCM_FLAGGED_ELEMENT::flag, DCM_FLAGGED_ELEMENT::flagAddress, DCM_ELEMENT::length, object, DCM_ELEMENT::representation, and DCM_ELEMENT::tag.
02830 {
02831 PRIVATE_OBJECT
02832 ** object;
02833 CONDITION
02834 cond;
02835 DCM_ELEMENT
02836 e;
02837 int
02838 c = 0;
02839
02840 object = (PRIVATE_OBJECT **) callerObject;
02841 cond = checkObject(object, "DCM_ModifyElement");
02842 if (cond != DCM_NORMAL)
02843 return cond;
02844
02845 while (count-- > 0) {
02846 cond = DCM_RemoveElement(callerObject, vector->tag);
02847 if (cond != DCM_NORMAL)
02848 (void) COND_PopCondition(FALSE);
02849
02850 e = *vector;
02851 if (DCM_IsString(e.representation))
02852 e.length = strlen(e.d.string);
02853
02854 cond = DCM_AddElement(callerObject, &e);
02855 if (cond != DCM_NORMAL)
02856 return cond;
02857
02858 c++;
02859 vector++;
02860 }
02861
02862 while (flaggedCount-- > 0) {
02863 if ((*(flaggedVector->flagAddress) & flaggedVector->flag) != 0) {
02864 cond = DCM_RemoveElement(callerObject, flaggedVector->e.tag);
02865 if (cond != DCM_NORMAL)
02866 (void) COND_PopCondition(FALSE);
02867
02868 e = flaggedVector->e;
02869 if (DCM_IsString(e.representation))
02870 e.length = strlen(e.d.string);
02871 cond = DCM_AddElement(callerObject, &e);
02872 if (cond != DCM_NORMAL)
02873 return cond;
02874 c++;
02875 }
02876 flaggedVector++;
02877 }
02878
02879 if (updateCount != NULL)
02880 *updateCount = c;
02881 return DCM_NORMAL;
02882 }
|
|
||||||||||||||||
|
Definition at line 1001 of file mri_dicom_hdr.c. References close(), COND_PushCondition(), CONDITION, CTNBOOLEAN, DCM_DumpElements(), DCM_FILEACCESSERROR, DCM_FILEFORMATMASK, DCM_FILENAMEMASK, DCM_FILEOPENFAILED, DCM_ILLEGALOPTION, DCM_LENGTHTOENDMASK, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_ORDERMASK, DCM_TRYFILENAMECHANGE, DCM_USELENGTHTOEND, ENTRY, fd, fileSize(), name, O_BINARY, readFile(), readFile1(), readLengthToEnd(), remapFileName(), RETURN, rwc_fd, and U32.
01002 {
01003 CONDITION cond;
01004 int fd;
01005 off_t fileOffset = 0;
01006 U32 lengthToEnd;
01007 U32 size;
01008 CTNBOOLEAN
01009 remainFileOpen = FALSE; /* Leave file open after parse ? */
01010
01011 ENTRY("DCM_OpenFile") ;
01012
01013 if ((opt & (DCM_ORDERMASK | DCM_FILEFORMATMASK)) == 0)
01014 RETURN(COND_PushCondition(DCM_ILLEGALOPTION,
01015 DCM_Message(DCM_ILLEGALOPTION), "Byte order",
01016 "DCM_OpenFile"));
01017
01018 #ifdef _MSC_VER
01019 fd = open(name, O_RDONLY | O_BINARY);
01020 #else
01021 rwc_fd = fd = open(name, O_RDONLY);
01022 #endif
01023 if ((fd < 0) && ((opt & DCM_FILENAMEMASK) == DCM_TRYFILENAMECHANGE)) {
01024 char mapName[1024];
01025 remapFileName(name, mapName);
01026 #ifdef _MSC_VER
01027 fd = open(mapName, O_RDONLY | O_BINARY);
01028 #else
01029 fd = open(mapName, O_RDONLY);
01030 if (fd < 0) {
01031 strcat(mapName, ".");
01032 fd = open(mapName, O_RDONLY);
01033 }
01034 #endif
01035 }
01036 if (fd < 0) {
01037 char msg[1024] ;
01038 sprintf(msg,"DCM_OpenFile open(%s) fails",name) ;
01039 perror(msg) ;
01040 RETURN(COND_PushCondition(DCM_FILEOPENFAILED,
01041 DCM_Message(DCM_FILEOPENFAILED), name,
01042 "DCM_OpenFile"));
01043 }
01044 size = fileSize(fd);
01045 if (size <= 0)
01046 RETURN(DCM_FILEACCESSERROR);
01047
01048 if ((opt & DCM_LENGTHTOENDMASK) == DCM_USELENGTHTOEND) {
01049 cond = readLengthToEnd(fd, name,
01050 opt & (~DCM_LENGTHTOENDMASK), &lengthToEnd);
01051 if (cond != DCM_NORMAL) {
01052 (void) close(fd); rwc_fd = -1 ;
01053 RETURN(COND_PushCondition(DCM_FILEOPENFAILED,
01054 DCM_Message(DCM_FILEOPENFAILED), name, "DCM_OpenFile"));
01055 }
01056 size = lengthToEnd;
01057 fileOffset = 24;
01058 (void) lseek(fd, 24, SEEK_SET);
01059 }
01060 #ifdef OLDSMM
01061 cond = readFile(name, NULL, fd, size, 0, 0, opt, callerObject, NULL,
01062 &remainFileOpen, NULL, NULL, NULL);
01063 #endif
01064 cond = readFile1(name, NULL, fd, size, &fileOffset, 0, opt, NULL,
01065 callerObject, NULL, &remainFileOpen, NULL, NULL, NULL);
01066 if ((cond != DCM_NORMAL) || !remainFileOpen){
01067 (void) close(fd); rwc_fd = -1 ;
01068 }
01069 if (cond != DCM_NORMAL) {
01070 if (debug)
01071 DCM_DumpElements(callerObject, 1);
01072 RETURN(COND_PushCondition(DCM_FILEOPENFAILED,
01073 DCM_Message(DCM_FILEOPENFAILED), name, "DCM_OpenFile"));
01074 } else
01075 RETURN(DCM_NORMAL);
01076 }
|
|
||||||||||||||||||||||||||||
|
Definition at line 2917 of file mri_dicom_hdr.c. References c, checkObject(), COND_PopCondition(), CONDITION, DCM_ELEMENT::d, DCM_GetElementValue(), DCM_IsString(), DCM_NORMAL, DCM_OBJECT, DCM_FLAGGED_ELEMENT::e, DCM_FLAGGED_ELEMENT::flag, DCM_FLAGGED_ELEMENT::flagAddress, l, object, p, DCM_ELEMENT::representation, and U32.
02920 {
02921 PRIVATE_OBJECT
02922 ** object;
02923 CONDITION
02924 cond;
02925 void
02926 *ctx;
02927 U32
02928 l;
02929 int
02930 c = 0;
02931 char
02932 *p;
02933
02934 object = (PRIVATE_OBJECT **) callerObject;
02935 cond = checkObject(object, "DCM_ParseObject");
02936 if (cond != DCM_NORMAL)
02937 return cond;
02938
02939 while (count-- > 0) {
02940 ctx = NULL;
02941 cond = DCM_GetElementValue(callerObject, vector, &l, &ctx);
02942 if (cond != DCM_NORMAL)
02943 return cond;
02944 if (DCM_IsString(vector->representation)) {
02945 vector->d.string[l] = '\0';
02946 p = vector->d.string + l - 1;
02947 while (p >= vector->d.string && (*p == ' '))
02948 *p-- = '\0';
02949 }
02950 c++;
02951 vector++;
02952 }
02953
02954 while (flagCount-- > 0) {
02955 ctx = NULL;
02956 cond = DCM_GetElementValue(callerObject, &flaggedVector->e, &l, &ctx);
02957 if (cond != DCM_NORMAL) {
02958 (void) COND_PopCondition(FALSE);
02959 } else {
02960 c++;
02961 if (DCM_IsString(flaggedVector->e.representation)) {
02962 flaggedVector->e.d.string[l] = '\0';
02963 p = flaggedVector->e.d.string + l - 1;
02964 while (p >= flaggedVector->e.d.string && (*p == ' '))
02965 *p-- = '\0';
02966 }
02967 *(flaggedVector->flagAddress) |= flaggedVector->flag;
02968 }
02969 flaggedVector++;
02970 }
02971
02972 if (parseCount != NULL)
02973 *parseCount = c;
02974 return DCM_NORMAL;
02975 }
|
|
||||||||||||
|
Definition at line 7844 of file mri_dicom_hdr.c. References checkObject(), COND_PushCondition(), CONDITION, DCM_ELEMENT::d, DCM_ELEMENTNOTFOUND, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, PRV_ELEMENT_ITEM::element, locateElement(), LST_Head(), LST_Next(), LST_Position(), DCM_SEQUENCE_ITEM::object, object, PRIVATE_OBJECT::objectSize, PRIVATE_OBJECT::offset, PRIVATE_OBJECT::pixelOffset, and RWC_printf().
07845 {
07846 PRIVATE_OBJECT **obj,
07847 *sqObject;
07848 CONDITION cond;
07849 PRV_ELEMENT_ITEM *elementItem;
07850 LST_HEAD *lst;
07851 DCM_SEQUENCE_ITEM *sqItem;
07852
07853 obj = (PRIVATE_OBJECT **) object;
07854 cond = checkObject(obj, "DCM_PrintSequenceList");
07855 if (cond != DCM_NORMAL)
07856 return cond;
07857
07858 elementItem = locateElement(obj, tag);
07859
07860 if (elementItem == NULL)
07861 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
07862 DCM_Message(DCM_ELEMENTNOTFOUND), DCM_TAG_GROUP(tag),
07863 DCM_TAG_ELEMENT(tag),
07864 "DCM_PrintSequenceList");
07865
07866 lst = elementItem->element.d.sq;
07867 sqItem = (void *)LST_Head(&lst);
07868 (void) LST_Position(&lst, (void *)sqItem);
07869 while (sqItem != NULL) {
07870 sqObject = (PRIVATE_OBJECT *) sqItem->object;
07871 RWC_printf("size: %6d offset: %6d, pixel offset: %6d\n",
07872 sqObject->objectSize,
07873 sqObject->offset,
07874 sqObject->pixelOffset);
07875 sqItem = (void *)LST_Next(&lst);
07876 }
07877 }
|
|
||||||||||||||||||||||||||||
|
Definition at line 1079 of file mri_dicom_hdr.c. References COND_PushCondition(), CONDITION, CTNBOOLEAN, DCM_FILEFORMATMASK, DCM_ILLEGALOPTION, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_ORDERMASK, DCM_READSTREAMFAILED, fd, offset, and readFile1().
01083 {
01084 CONDITION cond;
01085 int fd = -1;
01086 CTNBOOLEAN
01087 remainFileOpen = FALSE; /* Leave file open after parse ? */
01088 off_t fileOffset = 0;
01089
01090 if ((opt & (DCM_ORDERMASK | DCM_FILEFORMATMASK)) == 0)
01091 return COND_PushCondition(DCM_ILLEGALOPTION,
01092 DCM_Message(DCM_ILLEGALOPTION), "Byte order",
01093 "DCM_ReadStream");
01094
01095 cond = readFile1("", NULL, fd, size, &fileOffset, 0, opt, NULL,
01096 callerObject, NULL, &remainFileOpen, ctx, rd, sk);
01097 if (cond != DCM_NORMAL)
01098 return COND_PushCondition(DCM_READSTREAMFAILED,
01099 DCM_Message(DCM_READSTREAMFAILED), "DCM_ReadStream");
01100 else
01101 return DCM_NORMAL;
01102 }
|
|
||||||||||||
|
Definition at line 1511 of file mri_dicom_hdr.c. References PRV_GROUP_ITEM::baseLength, checkObject(), COND_PushCondition(), CONDITION, CTN_FREE, CTNBOOLEAN, DCM_ELEMENT::d, DCM_ELEMENTNOTFOUND, DCM_Message(), DCM_NORMAL, DCM_OB, DCM_OBJECT, DCM_OW, DCM_SQ, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UNSPECIFIEDLENGTH, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, PRV_GROUP_ITEM::longVRAttributes, LST_Head(), LST_K_AFTER, LST_Next(), LST_Position(), LST_Remove(), object, PRV_ELEMENT_ITEM::paddedDataLength, DCM_ELEMENT::representation, and DCM_ELEMENT::tag.
01512 {
01513 PRIVATE_OBJECT
01514 ** object;
01515 PRV_GROUP_ITEM
01516 * groupItem;
01517 PRV_ELEMENT_ITEM
01518 * elementItem,
01519 *groupLengthItem;
01520 CONDITION
01521 cond;
01522 CTNBOOLEAN
01523 flag;
01524 unsigned short
01525 group,
01526 element;
01527
01528 object = (PRIVATE_OBJECT **) callerObject;
01529 cond = checkObject(object, "DCM_RemoveElement");
01530 if (cond != DCM_NORMAL)
01531 return cond;
01532
01533 group = DCM_TAG_GROUP(tag);
01534 element = DCM_TAG_ELEMENT(tag);
01535
01536 groupItem = (void *)LST_Head(&((*object)->groupList));
01537 if (groupItem == NULL)
01538 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
01539 DCM_Message(DCM_ELEMENTNOTFOUND), group, element,
01540 "DCM_RemoveElement");
01541
01542 (void) LST_Position(&((*object)->groupList), (void *)groupItem);
01543
01544 flag = FALSE;
01545 while ((groupItem != NULL) && (flag == FALSE)) {
01546 if (groupItem->group == group)
01547 flag = TRUE;
01548 else
01549 groupItem = (void *)LST_Next(&(*object)->groupList);
01550 }
01551 if (flag == FALSE)
01552 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
01553 DCM_Message(DCM_ELEMENTNOTFOUND), group, element,
01554 "DCM_RemoveElement");
01555
01556 elementItem = (void *)LST_Head(&groupItem->elementList);
01557 if (elementItem == NULL)
01558 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
01559 DCM_Message(DCM_ELEMENTNOTFOUND), group, element,
01560 "DCM_RemoveElement");
01561
01562 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
01563
01564 groupLengthItem = elementItem;
01565 if (DCM_TAG_ELEMENT(groupLengthItem->element.tag) != 0x0000)
01566 groupLengthItem = NULL;
01567
01568
01569 flag = FALSE;
01570 while ((elementItem != NULL) && (flag == FALSE)) {
01571 if (DCM_TAG_ELEMENT(elementItem->element.tag) == element)
01572 flag = TRUE;
01573 else
01574 elementItem = (void *)LST_Next(&groupItem->elementList);
01575 }
01576
01577 if (flag == FALSE)
01578 return COND_PushCondition(DCM_ELEMENTNOTFOUND,
01579 DCM_Message(DCM_ELEMENTNOTFOUND), group, element,
01580 "DCM_RemoveElement");
01581
01582 if (groupItem->baseLength != DCM_UNSPECIFIEDLENGTH) {
01583 groupItem->baseLength -= elementItem->paddedDataLength + 2 + 2 + 4;
01584 if (groupLengthItem != NULL) {
01585 *groupLengthItem->element.d.ul = groupItem->baseLength;
01586 }
01587 }
01588 if ((*object)->objectSize != DCM_UNSPECIFIEDLENGTH)
01589 (*object)->objectSize -= elementItem->paddedDataLength + 2 + 2 + 4;
01590 if (elementItem->element.representation == DCM_OW ||
01591 elementItem->element.representation == DCM_OB ||
01592 elementItem->element.representation == DCM_SQ) {
01593 groupItem->longVRAttributes--;
01594 (*object)->longVRAttributes--;
01595 }
01596 (void) LST_Remove(&(groupItem->elementList), LST_K_AFTER);
01597 CTN_FREE(elementItem);
01598 return DCM_NORMAL;
01599 }
|
|
||||||||||||
|
Definition at line 3002 of file mri_dicom_hdr.c. References checkObject(), COND_PushCondition(), CONDITION, CTN_FREE, CTNBOOLEAN, DCM_GROUPNOTFOUND, DCM_LISTFAILURE, DCM_Message(), DCM_NORMAL, DCM_OBJECT, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, LST_Destroy(), LST_Head(), LST_K_AFTER, LST_Next(), LST_NORMAL, LST_Pop(), LST_Position(), LST_Remove(), and object.
03003 {
03004 PRIVATE_OBJECT
03005 ** object;
03006 CONDITION
03007 cond;
03008 PRV_GROUP_ITEM
03009 * groupItem;
03010 PRV_ELEMENT_ITEM
03011 * elementItem;
03012 CTNBOOLEAN
03013 found = FALSE;
03014
03015 object = (PRIVATE_OBJECT **) callerObject;
03016 cond = checkObject(object, "DCM_RemoveGroup");
03017 if (cond != DCM_NORMAL)
03018 return cond;
03019
03020 groupItem = (void *)LST_Head(&(*object)->groupList);
03021 if (groupItem == NULL)
03022 return COND_PushCondition(DCM_GROUPNOTFOUND,
03023 DCM_Message(DCM_GROUPNOTFOUND), (int) group, "DCM_RemoveGroup");
03024
03025 (void) LST_Position(&(*object)->groupList, (void *)groupItem);
03026
03027 while (!found && (groupItem != NULL)) {
03028 if (groupItem->group == group)
03029 found = TRUE;
03030 else
03031 groupItem = (void *)LST_Next(&(*object)->groupList);
03032 }
03033 if (groupItem == NULL)
03034 return COND_PushCondition(DCM_GROUPNOTFOUND,
03035 DCM_Message(DCM_GROUPNOTFOUND), (int) group, "DCM_RemoveGroup");
03036
03037
03038 while ((elementItem = (void *)LST_Pop(&groupItem->elementList)) != NULL)
03039 CTN_FREE(elementItem);
03040
03041 groupItem = (void *)LST_Remove(&(*object)->groupList, LST_K_AFTER);
03042 cond = LST_Destroy(&groupItem->elementList);
03043 if (cond != LST_NORMAL)
03044 return COND_PushCondition(DCM_LISTFAILURE,
03045 DCM_Message(DCM_LISTFAILURE), "DCM_RemoveGroup");
03046 CTN_FREE(groupItem);
03047 return DCM_NORMAL;
03048 }
|
|
||||||||||||||||||||||||||||||||
|
Definition at line 2104 of file mri_dicom_hdr.c. References checkObject(), CONDITION, copyData(), CTNBOOLEAN, DCM_IsString(), DCM_NORMAL, DCM_OBJECT, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, i, l, LST_Head(), LST_Next(), LST_Position(), object, p, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and U32.
02108 {
02109 PRIVATE_OBJECT
02110 ** object;
02111 PRV_GROUP_ITEM
02112 * groupItem;
02113 PRV_ELEMENT_ITEM
02114 * elementItem;
02115 CONDITION
02116 cond;
02117 CTNBOOLEAN
02118 done = FALSE;
02119 DCM_ELEMENT
02120 e;
02121 int
02122 i;
02123 CTNBOOLEAN
02124 found;
02125 U32
02126 l;
02127 char
02128 *p;
02129
02130 object = (PRIVATE_OBJECT **) callerObject;
02131 cond = checkObject(object, "DCM_ScanParseObject");
02132 if (cond != DCM_NORMAL)
02133 return cond;
02134
02135 groupItem = (void *)LST_Head(&((*object)->groupList));
02136 (void) LST_Position(&((*object)->groupList), (void *)groupItem);
02137 while (groupItem != NULL && !done) {
02138 elementItem = (void *)LST_Head(&groupItem->elementList);
02139 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
02140 while (elementItem != NULL && !done) {
02141 for (found = FALSE, i = 0; !found && i < vectorLength; i++) {
02142 if (elementItem->element.tag == elementVector[i].e.tag) {
02143 found = TRUE;
02144 (void)copyData(object,elementItem,&elementVector[i].e, &l);
02145 *elementVector[i].flagAddress |= elementVector[i].flag;
02146
02147 if (DCM_IsString(elementVector[i].e.representation)) {
02148 elementVector[i].e.d.string[l] = '\0';
02149 p = elementVector[i].e.d.string + l - 1;
02150 while (p >= elementVector[i].e.d.string && (*p == ' '))
02151 *p-- = '\0';
02152 }
02153 }
02154 }
02155 if (!found) {
02156 e = elementItem->element;
02157 cond = callback(&e, ctx);
02158 if (cond != DCM_NORMAL)
02159 done = TRUE;
02160 }
02161 elementItem = (void *)LST_Next(&groupItem->elementList);
02162 }
02163 groupItem = (void *)LST_Next(&((*object)->groupList));
02164 }
02165 return DCM_NORMAL;
02166 }
|
|
||||||||||||||||
|
Definition at line 2747 of file mri_dicom_hdr.c. References checkObject(), close(), COND_PushCondition(), CONDITION, DCM_ExportStream(), DCM_FILECREATEFAILED, DCM_Message(), DCM_NORMAL, DCM_OBJECT, fd, file, O_BINARY, O_WRONLY, object, strerror(), and writeFile().
02748 {
02749 PRIVATE_OBJECT
02750 ** object;
02751 int
02752 fd;
02753 unsigned char
02754 buf[2048];
02755 CONDITION
02756 cond;
02757
02758 object = (PRIVATE_OBJECT **) callerObject;
02759 cond = checkObject(object, "DCM_WriteFile");
02760 if (cond != DCM_NORMAL)
02761 return cond;
02762 #ifdef MACOS
02763 fd = open(file, O_WRONLY | O_CREAT | O_TRUNC);
02764 #elif _MSC_VER
02765 fd = _open(file, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
02766 _S_IREAD | _S_IWRITE);
02767 #else
02768 fd = open(file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
02769 #endif
02770 if (fd < 0) {
02771 return COND_PushCondition(DCM_FILECREATEFAILED,
02772 DCM_Message(DCM_FILECREATEFAILED), file, strerror(errno),
02773 "DCM_WriteFile");
02774 }
02775 cond = DCM_ExportStream(callerObject, opt, buf,
02776 (unsigned long) sizeof(buf), writeFile, &fd);
02777 if (cond != DCM_NORMAL)
02778 return cond;
02779
02780 (void) close(fd);
02781 return DCM_NORMAL;
02782 }
|
|
||||||||||||||||||||
|
Definition at line 7566 of file mri_dicom_hdr.c. References DCM_OB, DCM_SL, DCM_SS, DCM_UL, DCM_UN, DCM_US, DCM_VALUEREPRESENTATION, dumpOB(), dumpSL(), dumpSS(), dumpUL(), dumpUS(), U32, and vm.
07568 {
07569 vm = (vm < vmLimit) ? vm : vmLimit;
07570
07571 if (vm <= 1)
07572 return;
07573
07574 switch (vr) {
07575 case DCM_SL:
07576 dumpSL((S32 *) d, vm);
07577 break;
07578 case DCM_UL:
07579 dumpUL((U32 *) d, vm);
07580 break;
07581 case DCM_SS:
07582 dumpSS((short *) d, vm);
07583 break;
07584 case DCM_US:
07585 dumpUS((unsigned short *) d, vm);
07586 break;
07587 case DCM_OB:
07588 case DCM_UN:
07589 dumpOB((unsigned char*) d, vm);
07590 break;
07591 default:
07592 break;
07593 }
07594 }
|
|
||||||||||||
|
Definition at line 7553 of file mri_dicom_hdr.c. References c, RWC_printf(), and vm.
07554 {
07555 long index = 0;
07556 RWC_printf("hex OB:") ;
07557 while (index < vm) {
07558 RWC_printf("%02x ", *(c++));
07559 if ((++index) % 8 == 0)
07560 RWC_printf("\n");
07561 }
07562 if( index%8 != 0 ) RWC_printf("\n");
07563 }
|
|
||||||||||||
|
Definition at line 7516 of file mri_dicom_hdr.c. References RWC_printf(), and vm.
07517 {
07518 long index = 0;
07519 RWC_printf("decimal SL:") ;
07520 while (index < vm) {
07521 RWC_printf("%7d ", *(sl++));
07522 if ((++index) % 8 == 0)
07523 RWC_printf("\n");
07524 }
07525 RWC_printf("\n");
07526 }
|
|
||||||||||||
|
Definition at line 7503 of file mri_dicom_hdr.c. References RWC_printf(), and vm.
07504 {
07505 long index = 0;
07506 RWC_printf("decimal SS:") ;
07507 while (index < vm) {
07508 RWC_printf("%7d ", *(ss++));
07509 if ((++index) % 8 == 0)
07510 RWC_printf("\n");
07511 }
07512 RWC_printf("\n");
07513 }
|
|
|
Definition at line 644 of file mri_dicom_hdr.c. References stackPtr.
|
|
||||||||||||
|
Definition at line 7541 of file mri_dicom_hdr.c. References RWC_printf(), U32, and vm.
07542 {
07543 long index = 0;
07544 RWC_printf("decimal UL:") ;
07545 while (index < vm) {
07546 RWC_printf("%7d ", *(ul++));
07547 if ((++index) % 8 == 0)
07548 RWC_printf("\n");
07549 }
07550 RWC_printf("\n");
07551 }
|
|
||||||||||||
|
Definition at line 7529 of file mri_dicom_hdr.c. References RWC_printf(), and vm.
07530 {
07531 long index = 0;
07532 RWC_printf("decimal US:") ;
07533 while (index < vm) {
07534 RWC_printf("%7d ", *(us++));
07535 if ((++index) % 8 == 0)
07536 RWC_printf("\n");
07537 }
07538 RWC_printf("\n");
07539 }
|
|
||||||||||||||||||||||||||||||||
|
Definition at line 4440 of file mri_dicom_hdr.c. References PRV_ELEMENT_ITEM::byteOrder, BYTEORDER_SAME, COND_PushCondition(), CONDITION, PRV_ELEMENT_ITEM::currentOffset, DCM_ELEMENT::d, DCM_AE, DCM_AS, DCM_AT, DCM_CS, DCM_DA, DCM_DD, DCM_DS, DCM_DT, DCM_FD, DCM_FILEACCESSERROR, DCM_FL, DCM_GENERALWARNING, DCM_IS, DCM_LO, DCM_LT, DCM_Message(), DCM_NORMAL, DCM_OB, DCM_OT, DCM_OW, DCM_PN, DCM_PXLPIXELDATA, DCM_SH, DCM_SL, DCM_SQ, DCM_SS, DCM_ST, DCM_TAG, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_TM, DCM_UI, DCM_UL, DCM_UN, DCM_US, DCM_UT, PRV_ELEMENT_ITEM::element, groupElement, DCM_ELEMENT::length, object, p, read(), DCM_ELEMENT::representation, swab, swapATGroupElement(), swapInPlace(), DCM_ELEMENT::tag, and U32.
04444 {
04445 /* repair OT for pixel data*/
04446 unsigned char
04447 *p;
04448 DCM_TAG
04449 * tag;
04450 DCM_ELEMENT
04451 * element;
04452 int nBytes;
04453 CONDITION cond;
04454
04455 element = &item->element;
04456
04457 *rtnLength = 0;
04458 if (element->d.ot == NULL) {
04459 if ((*object)->fd != -1) {
04460 (void) lseek((*object)->fd, item->currentOffset, SEEK_SET);
04461 nBytes = read((*object)->fd, b, (int) length);
04462 } else {
04463 (*object)->sk((*object)->userCtx, item->currentOffset, SEEK_SET);
04464 cond = (*object)->rd((*object)->userCtx, b, (long) length, &nBytes);
04465 }
04466 if ((U32) nBytes != length) {
04467 char b[512];
04468 sprintf(b, "byte count: %d %d, errno: %d", nBytes, length, errno);
04469 (void) COND_PushCondition(DCM_GENERALWARNING,
04470 DCM_Message(DCM_GENERALWARNING), "exportData", b);
04471 return COND_PushCondition(DCM_FILEACCESSERROR,
04472 DCM_Message(DCM_FILEACCESSERROR), (*object)->fileName,
04473 "exportData");
04474 }
04475 if( LITTLE_ENDIAN_ARCHITECTURE ){
04476 if (item->element.representation == DCM_AT) {
04477 DCM_ELEMENT e;
04478 e = *element;
04479 e.length = length;
04480 e.d.ot = b;
04481 swapATGroupElement(&e);
04482 }
04483 }
04484 if (byteOrder != item->byteOrder) {
04485 DCM_ELEMENT e;
04486 e = *element;
04487 e.length = length;
04488 e.d.ot = b;
04489 swapInPlace(object, &e);
04490 }
04491 *rtnLength = (U32) nBytes;
04492 item->currentOffset += nBytes;
04493 } else {
04494 p = src;
04495 switch (element->representation) {
04496 case DCM_AE:
04497 case DCM_AS:
04498 case DCM_CS:
04499 case DCM_DA:
04500 case DCM_DT:
04501 case DCM_DD:
04502 case DCM_DS:
04503 case DCM_FD:
04504 case DCM_IS:
04505 case DCM_LO:
04506 case DCM_LT:
04507 case DCM_OB:
04508 case DCM_OT:
04509 case DCM_PN:
04510 case DCM_SH:
04511 case DCM_SQ:
04512 case DCM_ST:
04513 case DCM_TM:
04514 case DCM_UI:
04515 case DCM_UT:
04516 (void) memcpy(b, p, length);
04517 *rtnLength = length;
04518 break;
04519 case DCM_AT:
04520 tag = (DCM_TAG *) p;
04521 while (length >= 4) {
04522 groupElement.sh[0] = DCM_TAG_GROUP(*tag);
04523 groupElement.sh[1] = DCM_TAG_ELEMENT(*tag);
04524 if (byteOrder == BYTEORDER_SAME) {
04525 *b++ = groupElement.ch[0]; /* Copy the group */
04526 *b++ = groupElement.ch[1];
04527 *b++ = groupElement.ch[2]; /* Now, the element */
04528 *b++ = groupElement.ch[3];
04529 } else {
04530 *b++ = groupElement.ch[1]; /* Copy the group */
04531 *b++ = groupElement.ch[0];
04532 *b++ = groupElement.ch[3]; /* Now, the element */
04533 *b++ = groupElement.ch[2];
04534 }
04535 tag++;
04536 length -= 4;
04537 *rtnLength += 4;
04538 }
04539 break;
04540 case DCM_SL:
04541 case DCM_UL:
04542 case DCM_FL:
04543 while (length >= 4) {
04544 if (byteOrder == BYTEORDER_SAME) {
04545 *b++ = *p++;
04546 *b++ = *p++;
04547 *b++ = *p++;
04548 *b++ = *p++;
04549 } else {
04550 *b++ = p[3];
04551 *b++ = p[2];
04552 *b++ = p[1];
04553 *b++ = p[0];
04554 p += 4;
04555 }
04556 length -= 4;
04557 *rtnLength += 4;
04558 }
04559 break;
04560 case DCM_SS:
04561 case DCM_US:
04562 case DCM_OW:
04563 /*
04564 * Temorary hack by Nilesh to support memory mapping for testing
04565 * purposes.
04566 */
04567 length &= ~1;
04568 *rtnLength += length;
04569 if (element->tag == DCM_PXLPIXELDATA) {
04570 if (byteOrder == item->byteOrder)
04571 (void) memcpy(b, p, length);
04572 else
04573 #ifdef SOLARIS
04574 swab((char *) p, (char *) b, length);
04575 #elif defined AIXV3
04576 swab((short *) p, (short *) b, length);
04577 #elif defined MACOS
04578 /* Not Yet Defined */
04579 #else
04580 swab(p, b, length);
04581 #endif
04582 } else {
04583 if (byteOrder == BYTEORDER_SAME)
04584 (void) memcpy(b, p, length);
04585 else
04586 #ifdef SOLARIS
04587 swab((char *) p, (char *) b, length);
04588 #elif defined AIXV3
04589 swab((short *) p, (short *) b, length);
04590 #elif defined MACOS
04591 /* Not Yet Defined */
04592 #else
04593 swab(p, b, length);
04594 #endif
04595 }
04596 break;
04597 /*case DCM_UNKNOWN:*/
04598 case DCM_UN:
04599 default:
04600 #if 0
04601 fprintf(stderr, "Should not get to default in exportData: %08x\n",
04602 element->tag);
04603 #endif
04604 (void) memcpy(b, p, length);
04605 *rtnLength = length;
04606 break;
04607 }
04608 }
04609 return DCM_NORMAL;
04610 }
|
|
||||||||||||||||||||||||||||
|
Definition at line 4613 of file mri_dicom_hdr.c. References COND_PushCondition(), CONDITION, DCM_ELEMENT::d, PRV_ELEMENT_ITEM::dataOffset, DCM_CALLBACKABORTED, DCM_DLM, DCM_EXPORT_STREAM_CALLBACK, DCM_FILEACCESSERROR, DCM_GENERALWARNING, DCM_Message(), DCM_NOFRAGMENTSINOBJECT, DCM_NORMAL, DCM_OB, DCM_PXLPIXELDATA, PRV_ELEMENT_ITEM::element, exportFixedFields(), DCM_FRAGMENT_ITEM::fragment, PRV_ELEMENT_ITEM::fragmentFlag, DCM_FRAGMENT_ITEM::length, DCM_ELEMENT::length, LITTLE_ORDER, LST_Head(), LST_Next(), LST_Position(), object, PRV_ELEMENT_ITEM::originalDataLength, read(), DCM_ELEMENT::representation, RWC_printf(), DCM_ELEMENT::tag, and U32.
04616 {
04617 DCM_ELEMENT * element;
04618 int nBytes;
04619 CONDITION cond;
04620 U32 toExport;
04621 int length;
04622 DCM_FRAGMENT_ITEM* fragmentItem = 0;
04623 DCM_ELEMENT e;
04624 U32 rtnLength = 0;
04625
04626 element = &item->element;
04627 if (element->d.ot == NULL) {
04628 if ((*object)->fd != -1) {
04629 /* Seek to the beginning of the data. Have to back up 12 bytes to
04630 ** get the pixel tag, VR, etc
04631 */
04632 (void) lseek((*object)->fd, item->dataOffset-12, SEEK_SET);
04633 } else {
04634 (*object)->sk((*object)->userCtx, item->dataOffset-12, SEEK_SET);
04635 }
04636
04637 toExport = item->originalDataLength + 12;
04638 while(toExport > 0) {
04639 length = (toExport < bufferlength) ? toExport : bufferlength;
04640
04641 if ((*object)->fd != -1) {
04642 nBytes = read((*object)->fd, buffer, length);
04643 } else {
04644 cond = (*object)->rd((*object)->userCtx, buffer, (long) length, &nBytes);
04645 }
04646 if ((U32) nBytes != length) {
04647 char b[512];
04648 sprintf(b, "byte count: %d %d, errno: %d", nBytes, length, errno);
04649 (void) COND_PushCondition(DCM_GENERALWARNING,
04650 DCM_Message(DCM_GENERALWARNING), "exportEncapsualtedPixels", b);
04651 return COND_PushCondition(DCM_FILEACCESSERROR,
04652 DCM_Message(DCM_FILEACCESSERROR), (*object)->fileName,
04653 "exportEncapsualtedPixels");
04654 }
04655 cond = callback(buffer, length, 0, ctx);
04656 if (cond != DCM_NORMAL) {
04657 return COND_PushCondition(DCM_CALLBACKABORTED,
04658 DCM_Message(DCM_CALLBACKABORTED), "exportStream");
04659 }
04660 toExport -= length;
04661 }
04662 } else {
04663 if (item->fragmentFlag != 1) {
04664 return COND_PushCondition(DCM_NOFRAGMENTSINOBJECT,
04665 "DCM Exporting pixels but did not find expected fragments in object");
04666 }
04667 e.tag = DCM_PXLPIXELDATA;
04668 e.d.ot = 0;
04669 e.representation = DCM_OB;
04670 e.length = 0xffffffff;
04671 exportFixedFields(&e, buffer, bufferlength,
04672 LITTLE_ORDER /*byteOrder*/,
04673 1 /* explicitV*/,
04674 &rtnLength);
04675 toExport = rtnLength;
04676 e.tag = 0xfffee000;
04677 e.length = 0;
04678 e.representation = DCM_DLM;
04679 e.d.ot = 0;
04680 exportFixedFields(&e, buffer+toExport, bufferlength,
04681 LITTLE_ORDER /*byteOrder*/,
04682 1 /* explicitV*/,
04683 &rtnLength);
04684 toExport += rtnLength;
04685
04686 cond = callback(buffer, toExport, 0, ctx);
04687 if (cond != DCM_NORMAL) {
04688 return COND_PushCondition(DCM_CALLBACKABORTED,
04689 DCM_Message(DCM_CALLBACKABORTED), "exportEncapsulatedPixels");
04690 }
04691
04692 fragmentItem = (DCM_FRAGMENT_ITEM*)LST_Head(&item->element.d.fragments);
04693 (void)LST_Position(&item->element.d.fragments, (void *)fragmentItem);
04694 while (fragmentItem != NULL) {
04695 RWC_printf("Fragment size: %6d\n", fragmentItem->length);
04696 e.tag = 0xfffee000;
04697 e.length = fragmentItem->length;
04698 e.representation = DCM_DLM;
04699 exportFixedFields(&e, buffer, bufferlength,
04700 LITTLE_ORDER /*byteOrder*/,
04701 1 /* explicitV*/,
04702 &rtnLength);
04703 cond = callback(buffer, rtnLength, 0, ctx);
04704 if (cond != DCM_NORMAL) {
04705 return COND_PushCondition(DCM_CALLBACKABORTED,
04706 DCM_Message(DCM_CALLBACKABORTED), "exportEncapsulatedPixels");
04707 }
04708 cond = callback(fragmentItem->fragment, fragmentItem->length, 0, ctx);
04709 if (cond != DCM_NORMAL) {
04710 return COND_PushCondition(DCM_CALLBACKABORTED,
04711 DCM_Message(DCM_CALLBACKABORTED), "exportEncapsulatedPixels");
04712 }
04713
04714 fragmentItem = (void *)LST_Next(&item->element.d.fragments);
04715 }
04716 e.tag = 0xfffee0dd;
04717 e.length = 0;
04718 e.representation = DCM_DLM;
04719 e.d.ot = 0;
04720 exportFixedFields(&e, buffer, bufferlength,
04721 LITTLE_ORDER /*byteOrder*/,
04722 1 /* explicitV*/,
04723 &rtnLength);
04724 cond = callback(buffer, rtnLength, 0, ctx);
04725 if (cond != DCM_NORMAL) {
04726 return COND_PushCondition(DCM_CALLBACKABORTED,
04727 DCM_Message(DCM_CALLBACKABORTED), "exportEncapsulatedPixels");
04728 }
04729 }
04730 return DCM_NORMAL;
04731 }
|
|
||||||||||||||||||||||||||||
|
Definition at line 4306 of file mri_dicom_hdr.c. References BYTEORDER_SAME, CTNBOOLEAN, DCM_DLM, DCM_TAG_ELEMENT, DCM_TAG_GROUP, exportVRLength(), DCM_ELEMENT::length, p, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and U32.
04309 {
04310 unsigned char
04311 *p;
04312 unsigned short
04313 group,
04314 element;
04315 U32
04316 minimumLength;
04317
04318 group = DCM_TAG_GROUP(e->tag);
04319 element = DCM_TAG_ELEMENT(e->tag);
04320 if (e->representation == DCM_DLM)
04321 explicitVR = FALSE;
04322
04323 minimumLength = sizeof(group) + sizeof(element) + sizeof(e->length);
04324 if (explicitVR)
04325 minimumLength += 4;
04326
04327 *rtnLength = 0;
04328 if (length >= minimumLength) {
04329 if (byteOrder == BYTEORDER_SAME) {
04330 p = (unsigned char *) &group;
04331 *b++ = *p++;
04332 *b++ = *p++;
04333 p = (unsigned char *) &element;
04334 *b++ = *p++;
04335 *b++ = *p++;
04336 *rtnLength += 4;
04337 if (explicitVR) {
04338 exportVRLength(e, b, byteOrder, rtnLength);
04339 } else {
04340 p = (unsigned char *) &e->length;
04341 *b++ = *p++;
04342 *b++ = *p++;
04343 *b++ = *p++;
04344 *b++ = *p++;
04345 *rtnLength += 4;
04346 }
04347 } else {
04348 p = (unsigned char *) &group;
04349 *b++ = p[1];
04350 *b++ = p[0];
04351 p = (unsigned char *) &element;
04352 *b++ = p[1];
04353 *b++ = p[0];
04354 *rtnLength += 4;
04355 if (explicitVR) {
04356 exportVRLength(e, b, byteOrder, rtnLength);
04357 } else {
04358 p = (unsigned char *) &e->length;
04359 *b++ = p[3];
04360 *b++ = p[2];
04361 *b++ = p[1];
04362 *b++ = p[0];
04363 *rtnLength += 4;
04364 }
04365 }
04366 }
04367 }
|
|
||||||||||||||||||||||||||||||||||||||||
|
Definition at line 4734 of file mri_dicom_hdr.c. References c, COND_PushCondition(), CONDITION, PRV_ELEMENT_ITEM::currentOffset, DCM_ELEMENT::d, PRV_ELEMENT_ITEM::dataOffset, DCM_CALLBACKABORTED, DCM_EXPORT_STREAM_CALLBACK, DCM_FILEACCESSERROR, DCM_GENERALWARNING, DCM_Message(), DCM_NORMAL, PRV_ELEMENT_ITEM::element, exportData(), exportEncapsulatedPixels(), exportFixedFields(), DCM_ELEMENT::length, object, PRV_ELEMENT_ITEM::originalDataLength, read(), DCM_ELEMENT::tag, and U32.
04739 {
04740 DCM_ELEMENT * element;
04741 int nBytes;
04742 CONDITION cond;
04743 U32 toExport;
04744 U32 bytesExported = 0;
04745 U32 exportLength = 0;
04746 int length;
04747 U32 rtnLength;
04748 U32 remainingData;
04749 unsigned char* dst;
04750 unsigned char* src;
04751 int c;
04752
04753 if (encapsulatedPixels) {
04754 return exportEncapsulatedPixels(object, item, buffer,
04755 bufferlength, callback, ctx);
04756 }
04757
04758 element = &item->element;
04759 rtnLength = 0;
04760 dst = buffer;
04761 c = bufferlength;
04762 exportFixedFields(element, dst, bufferlength, byteOrder,
04763 explicitVR, &rtnLength);
04764 dst += rtnLength;
04765 c -= rtnLength;
04766 bytesExported = rtnLength;
04767
04768 remainingData = element->length;
04769 src = element->d.ot;
04770 item->currentOffset = item->dataOffset;
04771
04772 while (remainingData > 0) {
04773 if (debug) {
04774 fprintf(stderr, "Export: (%08x) %d\n", element->tag, element->length);
04775 }
04776
04777 if (element->d.ot != NULL) {
04778 remainingData = element->length -
04779 (src - ((unsigned char *) element->d.ot));
04780 } else {
04781 remainingData = element->length -
04782 (item->currentOffset - item->dataOffset);
04783 }
04784
04785 exportLength = (remainingData < c) ? remainingData : c;
04786 cond = exportData(object, item, src, dst,
04787 exportLength, byteOrder, &rtnLength);
04788 if (cond != DCM_NORMAL)
04789 return cond;
04790
04791 src += rtnLength;
04792 dst += rtnLength;
04793 bytesExported += rtnLength;
04794 c -= rtnLength;
04795
04796 if (c <= 20) {
04797 cond = callback(buffer, bytesExported, 0, ctx);
04798 if (cond != DCM_NORMAL) {
04799 return COND_PushCondition(DCM_CALLBACKABORTED,
04800 DCM_Message(DCM_CALLBACKABORTED), "exportPixels");
04801 }
04802 bytesExported = 0;
04803 c = bufferlength;
04804 dst = (unsigned char *) buffer;
04805 }
04806 }
04807 if (bytesExported > 0) {
04808 cond = callback(buffer, bytesExported, 0, ctx);
04809 if (cond != DCM_NORMAL) {
04810 return COND_PushCondition(DCM_CALLBACKABORTED,
04811 DCM_Message(DCM_CALLBACKABORTED), "exportPixels");
04812 }
04813 }
04814
04815 return DCM_NORMAL;
04816
04817 #if 0
04818 if (element->d.ot == NULL) {
04819 if ((*object)->fd != -1) {
04820 /* Seek to the beginning of the data. Have to back up 12 bytes to
04821 ** get the pixel tag, VR, etc
04822 */
04823 (void) lseek((*object)->fd, item->dataOffset-12, SEEK_SET);
04824 } else {
04825 (*object)->sk((*object)->userCtx, item->dataOffset-12, SEEK_SET);
04826 }
04827
04828 toExport = item->originalDataLength + 12;
04829 while(toExport > 0) {
04830 length = (toExport < bufferlength) ? toExport : bufferlength;
04831
04832 if ((*object)->fd != -1) {
04833 nBytes = read((*object)->fd, buffer, length);
04834 } else {
04835 cond = (*object)->rd((*object)->userCtx, buffer, (long) length, &nBytes);
04836 }
04837 if ((U32) nBytes != length) {
04838 char b[512];
04839 sprintf(b, "byte count: %d %d, errno: %d", nBytes, length, errno);
04840 (void) COND_PushCondition(DCM_GENERALWARNING,
04841 DCM_Message(DCM_GENERALWARNING), "exportPixels", b);
04842 return COND_PushCondition(DCM_FILEACCESSERROR,
04843 DCM_Message(DCM_FILEACCESSERROR), (*object)->fileName,
04844 "exportPixels");
04845 }
04846 cond = callback(buffer, length, 0, ctx);
04847 if (cond != DCM_NORMAL) {
04848 return COND_PushCondition(DCM_CALLBACKABORTED,
04849 DCM_Message(DCM_CALLBACKABORTED), "exportStream");
04850 }
04851 toExport -= length;
04852 }
04853 } else {
04854 }
04855 return DCM_NORMAL;
04856 #endif
04857
04858 }
|
|
||||||||||||||||||||
|
Definition at line 4252 of file mri_dicom_hdr.c. References COND_PushCondition(), DCM_EXPORTBUFFERTOOSMALL, DCM_Message(), DCM_NORMAL, DCM_PREAMBLELENGTH, and U32.
04254 {
04255 *rtnLength = 0;
04256 if (bufferLength < (DCM_PREAMBLELENGTH + 4))
04257 return COND_PushCondition(DCM_EXPORTBUFFERTOOSMALL,
04258 DCM_Message(DCM_EXPORTBUFFERTOOSMALL), (int) bufferLength,
04259 "exportPreamble");
04260
04261 (void) memcpy(dst, (*obj)->preamble, DCM_PREAMBLELENGTH);
04262 dst += DCM_PREAMBLELENGTH;
04263 (void) memcpy(dst, "DICM", 4);
04264 *rtnLength += DCM_PREAMBLELENGTH + 4;
04265
04266 return DCM_NORMAL;
04267 }
|
|
||||||||||||||||||||||||||||||||
|
Definition at line 5182 of file mri_dicom_hdr.c. References BIG_ORDER, c, checkObject(), computeGroupLength(), COND_PushCondition(), CONDITION, CTNBOOLEAN, PRV_ELEMENT_ITEM::currentOffset, DCM_ELEMENT::d, PRV_ELEMENT_ITEM::dataOffset, DCM_CALLBACKABORTED, DCM_DLM, DCM_DLMITEM, DCM_DLMITEMDELIMITATIONITEM, DCM_DLMSEQUENCEDELIMITATIONITEM, DCM_ENCAPSULATEDPIXELS, DCM_EXPLICITBIGENDIAN, DCM_EXPLICITLITTLEENDIAN, DCM_EXPORT_STREAM_CALLBACK, DCM_FILEFORMATMASK, DCM_GROUPFILEMETA, DCM_ILLEGALOPTION, DCM_LISTFAILURE, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_ORDERBIGENDIAN, DCM_ORDERLITTLEENDIAN, DCM_ORDERMASK, DCM_ORDERNATIVE, DCM_PART10FILE, DCM_PXLPIXELDATA, DCM_SEQUENCELENGTHMASK, DCM_SQ, DCM_TAG_ELEMENT, DCM_UNSPECIFIEDLENGTH, DCM_UNSPECIFIEDLENGTHFLAG, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, exportData(), exportFixedFields(), exportPixels(), exportPreamble(), exportStream(), extractFileOptions(), PRV_GROUP_ITEM::group, l, DCM_ELEMENT::length, LITTLE_ORDER, LST_Head(), LST_Next(), LST_Position(), NATIVE_ORDER, DCM_SEQUENCE_ITEM::object, object, PRV_ELEMENT_ITEM::paddedDataLength, DCM_ELEMENT::representation, setFileOptions(), DCM_ELEMENT::tag, and U32.
05185 {
05186 PRIVATE_OBJECT
05187 ** object;
05188 PRV_GROUP_ITEM
05189 * groupItem;
05190 PRV_ELEMENT_ITEM
05191 * elementItem;
05192 DCM_ELEMENT
05193 element;
05194 int
05195 byteOrder;
05196 int
05197 lastFlag = 0;
05198 unsigned char
05199 *src,
05200 *dst;
05201 U32
05202 c,
05203 bytesExported = 0,
05204 rtnLength,
05205 remainingData,
05206 exportLength;
05207 CONDITION
05208 cond;
05209 DCM_SEQUENCE_ITEM
05210 * sequenceItem;
05211 DCM_ELEMENT
05212 itemMarker = {
05213 DCM_DLMITEM, DCM_DLM, "", 1, DCM_UNSPECIFIEDLENGTH, NULL
05214 },
05215 itemDelimiter = {
05216 DCM_DLMITEMDELIMITATIONITEM, DCM_DLM, "", 1, 0, NULL
05217 },
05218 sequenceDelimiter = {
05219 DCM_DLMSEQUENCEDELIMITATIONITEM, DCM_DLM, "", 1, 0, NULL
05220 };
05221 CTNBOOLEAN
05222 unspecifiedSQLength = FALSE,
05223 explicitVR = FALSE,
05224 part10File = FALSE,
05225 encapsulatedPixels = FALSE;
05226 unsigned long fileOptions = 0;
05227
05228 object = (PRIVATE_OBJECT **) callerObject;
05229 cond = checkObject(object, "exportStream");
05230 if (cond != DCM_NORMAL)
05231 return cond;
05232
05233 if ((opt & DCM_FILEFORMATMASK) == DCM_PART10FILE) {
05234 part10File = TRUE;
05235 opt &= ~DCM_ORDERMASK;
05236 opt |= DCM_EXPLICITLITTLEENDIAN;
05237 cond = setFileOptions(callerObject, &fileOptions);
05238 if (cond != DCM_NORMAL)
05239 return cond;
05240 }
05241 if ((opt & DCM_ORDERMASK) == 0)
05242 return COND_PushCondition(DCM_ILLEGALOPTION,
05243 DCM_Message(DCM_ILLEGALOPTION), "Byte order",
05244 "exportStream");
05245
05246 switch (opt & DCM_ORDERMASK) {
05247 case DCM_ORDERNATIVE:
05248 byteOrder = NATIVE_ORDER;
05249 break;
05250 case DCM_ORDERLITTLEENDIAN:
05251 byteOrder = LITTLE_ORDER;
05252 break;
05253 case DCM_EXPLICITLITTLEENDIAN:
05254 byteOrder = LITTLE_ORDER;
05255 explicitVR = TRUE;
05256 break;
05257 case DCM_ORDERBIGENDIAN:
05258 byteOrder = BIG_ORDER;
05259 break;
05260 case DCM_EXPLICITBIGENDIAN:
05261 byteOrder = BIG_ORDER;
05262 explicitVR = TRUE;
05263 break;
05264 case DCM_ENCAPSULATEDPIXELS:
05265 byteOrder = LITTLE_ORDER;
05266 explicitVR = TRUE;
05267 encapsulatedPixels = TRUE;
05268 break;
05269 default:
05270 byteOrder = LITTLE_ORDER;
05271 break;
05272 }
05273
05274 /* We are making this step mandatory for now (smm)*/
05275
05276 opt &= ~DCM_SEQUENCELENGTHMASK;
05277 opt |= DCM_UNSPECIFIEDLENGTHFLAG;
05278
05279 /* End of something that is out of place */
05280
05281 if ((opt & DCM_SEQUENCELENGTHMASK) == DCM_UNSPECIFIEDLENGTHFLAG)
05282 unspecifiedSQLength = TRUE;
05283
05284 dst = (unsigned char *) buffer;
05285 c = bufferlength;
05286
05287 if (part10File) {
05288 cond = exportPreamble(object, dst, c, &rtnLength);
05289 if (cond != DCM_NORMAL)
05290 return cond;
05291
05292 dst += rtnLength;
05293 c -= rtnLength;
05294 bytesExported += rtnLength;
05295 }
05296 if (sequenceLevel != 0) {
05297 if (!unspecifiedSQLength)
05298 itemMarker.length = (*object)->objectSize;
05299 exportFixedFields(&itemMarker, dst, bufferlength, byteOrder,
05300 explicitVR, &rtnLength);
05301 dst += rtnLength;
05302 c -= rtnLength;
05303 bytesExported += rtnLength;
05304 }
05305 groupItem = (void *)LST_Head(&(*object)->groupList);
05306
05307 /* Take this code out to allow empty groups. */
05308 #if 0
05309 if (groupItem == NULL)
05310 return COND_PushCondition(DCM_LISTFAILURE,
05311 DCM_Message(DCM_LISTFAILURE), "exportStream");
05312 #endif
05313 if (groupItem != NULL)
05314 (void) LST_Position(&(*object)->groupList, (void *)groupItem);
05315
05316 while (groupItem != NULL) {
05317 if (part10File && groupItem->group != DCM_GROUPFILEMETA) {
05318 if (opt != fileOptions) {
05319 opt = fileOptions;
05320 cond = extractFileOptions(opt, &part10File,
05321 &explicitVR, &byteOrder,
05322 &encapsulatedPixels);
05323 if (cond != DCM_NORMAL)
05324 return cond;
05325 }
05326 }
05327 elementItem = (void *)LST_Head(&groupItem->elementList);
05328 if (elementItem != NULL)
05329 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
05330 if (DCM_TAG_ELEMENT(elementItem->element.tag) == 0x0000) {
05331 U32 l;
05332 l = computeGroupLength(groupItem, explicitVR);
05333 *elementItem->element.d.ul = l;
05334
05335 /* We have some problems computing group length for groups with sequences.
05336 ** For now, just remove this attribute, except for group 0000 and 0002.
05337 */
05338 if (groupItem->group != 0x0000 && groupItem->group != 0x0002)
05339 elementItem = (void *)LST_Next(&groupItem->elementList);
05340 }
05341 while (elementItem != NULL) {
05342 if (c <= 20) {
05343 cond = callback(buffer, bytesExported, 0, ctx);
05344 if (cond != DCM_NORMAL)
05345 return COND_PushCondition(DCM_CALLBACKABORTED,
05346 DCM_Message(DCM_CALLBACKABORTED), "exportStream");
05347
05348 bytesExported = 0;
05349 c = bufferlength;
05350 dst = (unsigned char *) buffer;
05351 }
05352 element = elementItem->element;
05353
05354 if (element.tag == DCM_PXLPIXELDATA) {
05355 /* Lots of special rules for pixel data. Handle separately */
05356 /* First, dump the current buffer */
05357 cond = callback(buffer, bytesExported, 0, ctx);
05358 if (cond != DCM_NORMAL)
05359 return COND_PushCondition(DCM_CALLBACKABORTED,
05360 DCM_Message(DCM_CALLBACKABORTED), "exportStream");
05361
05362 cond = exportPixels(object, elementItem, encapsulatedPixels,
05363 buffer, bufferlength, callback, ctx, byteOrder, explicitVR);
05364 if (cond != DCM_NORMAL)
05365 return cond;
05366
05367 bytesExported = 0;
05368 c = bufferlength;
05369 dst = (unsigned char *) buffer;
05370 rtnLength = 0;
05371 } else if (element.representation == DCM_SQ) {
05372 if (unspecifiedSQLength)
05373 element.length = DCM_UNSPECIFIEDLENGTH;
05374
05375 exportFixedFields(&element, dst, bufferlength, byteOrder,
05376 explicitVR, &rtnLength);
05377 } else {
05378 element.length = elementItem->paddedDataLength;
05379 exportFixedFields(&element, dst, bufferlength, byteOrder,
05380 explicitVR, &rtnLength);
05381 }
05382 dst += rtnLength;
05383 c -= rtnLength;
05384 bytesExported += rtnLength;
05385
05386 remainingData = element.length;
05387 src = element.d.ot;
05388 elementItem->currentOffset = elementItem->dataOffset;
05389
05390 if (element.tag == DCM_PXLPIXELDATA) {
05391 /* Then, we did that above */
05392 ;
05393 } else if (element.representation == DCM_SQ) {
05394
05395 cond = callback(buffer, bytesExported, 0, ctx);
05396 if (cond != DCM_NORMAL)
05397 return COND_PushCondition(DCM_CALLBACKABORTED,
05398 DCM_Message(DCM_CALLBACKABORTED), "exportStream");
05399
05400 bytesExported = 0;
05401 c = bufferlength;
05402 dst = (unsigned char *) buffer;
05403
05404 if (element.d.sq != NULL) {
05405 sequenceItem = (void *)LST_Head(&element.d.sq);
05406 if (sequenceItem != NULL)
05407 (void) LST_Position(&element.d.sq, (void *)sequenceItem);
05408 while (sequenceItem != NULL) {
05409 cond = exportStream(&sequenceItem->object, opt,
05410 buffer, bufferlength, callback, ctx,
05411 sequenceLevel + 1);
05412 if (cond != DCM_NORMAL)
05413 return cond;
05414 sequenceItem = (void *)LST_Next(&element.d.sq);
05415 }
05416 }
05417 if (element.length == DCM_UNSPECIFIEDLENGTH) {
05418 sequenceDelimiter.length = 0;
05419 exportFixedFields(&sequenceDelimiter, dst, bufferlength,
05420 byteOrder, explicitVR, &rtnLength);
05421 dst += rtnLength;
05422 c -= rtnLength;
05423 bytesExported += rtnLength;
05424 }
05425 } else {
05426 while (remainingData > 0) {
05427 if (debug)
05428 fprintf(stderr, "Export: (%08x) %d\n",
05429 element.tag, element.length);
05430 if (element.d.ot != NULL)
05431 remainingData = element.length -
05432 (src - ((unsigned char *) element.d.ot));
05433 else
05434 remainingData = element.length -
05435 (elementItem->currentOffset - elementItem->dataOffset);
05436
05437 exportLength = (remainingData < c) ? remainingData : c;
05438 cond = exportData(object, elementItem, src, dst,
05439 exportLength, byteOrder, &rtnLength);
05440 if (cond != DCM_NORMAL)
05441 return cond;
05442
05443 src += rtnLength;
05444 dst += rtnLength;
05445 bytesExported += rtnLength;
05446 c -= rtnLength;
05447
05448 if (c <= 20) {
05449 cond = callback(buffer, bytesExported, 0, ctx);
05450 if (cond != DCM_NORMAL)
05451 return COND_PushCondition(DCM_CALLBACKABORTED,
05452 DCM_Message(DCM_CALLBACKABORTED), "exportStream");
05453
05454 bytesExported = 0;
05455 c = bufferlength;
05456 dst = (unsigned char *) buffer;
05457 }
05458 }
05459 }
05460 elementItem = (void *)LST_Next(&groupItem->elementList);
05461 }
05462 groupItem = (void *)LST_Next(&(*object)->groupList);
05463 }
05464 if ((sequenceLevel != 0) && unspecifiedSQLength) {
05465 if (c <= 20) {
05466 cond = callback(buffer, bytesExported, 0, ctx);
05467 if (cond != DCM_NORMAL)
05468 return COND_PushCondition(DCM_CALLBACKABORTED,
05469 DCM_Message(DCM_CALLBACKABORTED), "exportStream");
05470
05471 bytesExported = 0;
05472 c = bufferlength;
05473 dst = (unsigned char *) buffer;
05474 }
05475 exportFixedFields(&itemDelimiter, dst, bufferlength, byteOrder,
05476 explicitVR, &rtnLength);
05477 dst += rtnLength;
05478 c -= rtnLength;
05479 bytesExported += rtnLength;
05480 }
05481 lastFlag = (sequenceLevel == 0) ? 1 : 0;
05482 cond = callback(buffer, bytesExported, lastFlag, ctx);
05483 if (cond != DCM_NORMAL)
05484 return COND_PushCondition(DCM_CALLBACKABORTED,
05485 DCM_Message(DCM_CALLBACKABORTED), "exportStream");
05486
05487 return DCM_NORMAL;
05488 }
|
|
||||||||||||||||||||||||||||||||
|
|
|
||||||||||||||||||||
|
Definition at line 4195 of file mri_dicom_hdr.c. References BYTEORDER_SAME, c, DCM_MAKETAG, DCM_OB, DCM_OW, DCM_SQ, DCM_UN, DCM_VALUEREPRESENTATION, DIM_OF, i, DCM_ELEMENT::length, p, DCM_ELEMENT::representation, DCM_ELEMENT::tag, U16, and U32.
04197 {
04198 int i;
04199 char *c = "xx";
04200 unsigned char *p;
04201 U16 shortLength;
04202 DCM_VALUEREPRESENTATION vr;
04203
04204 vr = e->representation;
04205 if (e->tag == DCM_MAKETAG(0x003a, 0x1000))
04206 vr = DCM_OB;
04207
04208 for (i = 0; i < DIM_OF(vrMap); i++) {
04209 if (vr == vrMap[i].representation) {
04210 c = vrMap[i].code;
04211 break;
04212 }
04213 }
04214
04215 *b++ = *c++;
04216 *b++ = *c++;
04217 *rtnLength += 2;
04218
04219 if (vr == DCM_OB || vr == DCM_OW || vr == DCM_SQ || vr == DCM_UN) {
04220 *b++ = 0x00;
04221 *b++ = 0x00;
04222 if (byteOrder == BYTEORDER_SAME) {
04223 p = (unsigned char *) &e->length;
04224 *b++ = *p++;
04225 *b++ = *p++;
04226 *b++ = *p++;
04227 *b++ = *p++;
04228 } else {
04229 p = (unsigned char *) &e->length;
04230 *b++ = p[3];
04231 *b++ = p[2];
04232 *b++ = p[1];
04233 *b++ = p[0];
04234 }
04235 *rtnLength += 6;
04236 } else {
04237 shortLength = (U16) e->length;
04238 if (byteOrder == BYTEORDER_SAME) {
04239 p = (unsigned char *) &shortLength;
04240 *b++ = *p++;
04241 *b++ = *p++;
04242 } else {
04243 p = (unsigned char *) &shortLength;
04244 *b++ = p[1];
04245 *b++ = p[0];
04246 }
04247 *rtnLength += 2;
04248 }
04249 }
|
|
||||||||||||||||||||||||
|
Definition at line 5086 of file mri_dicom_hdr.c. References BIG_ORDER, COND_PushCondition(), CTNBOOLEAN, DCM_ENCAPSULATEDPIXELS, DCM_EXPLICITBIGENDIAN, DCM_EXPLICITLITTLEENDIAN, DCM_FILEFORMATMASK, DCM_ILLEGALOPTION, DCM_Message(), DCM_NORMAL, DCM_ORDERBIGENDIAN, DCM_ORDERLITTLEENDIAN, DCM_ORDERMASK, DCM_ORDERNATIVE, DCM_PART10FILE, LITTLE_ORDER, and NATIVE_ORDER.
05089 {
05090 *part10File = *explicitVR = FALSE;
05091
05092 if ((opt & DCM_FILEFORMATMASK) == DCM_PART10FILE) {
05093 *part10File = TRUE;
05094 opt &= ~DCM_ORDERMASK;
05095 opt |= DCM_EXPLICITLITTLEENDIAN;
05096 }
05097 if ((opt & DCM_ORDERMASK) == 0)
05098 return COND_PushCondition(DCM_ILLEGALOPTION,
05099 DCM_Message(DCM_ILLEGALOPTION), "Byte order",
05100 "extractFileOptions");
05101
05102 switch (opt & DCM_ORDERMASK) {
05103 case DCM_ORDERNATIVE:
05104 *byteOrder = NATIVE_ORDER;
05105 *encapsulatedPixels = FALSE;
05106 break;
05107 case DCM_ORDERLITTLEENDIAN:
05108 *byteOrder = LITTLE_ORDER;
05109 *encapsulatedPixels = FALSE;
05110 break;
05111 case DCM_EXPLICITLITTLEENDIAN:
05112 *byteOrder = LITTLE_ORDER;
05113 *explicitVR = TRUE;
05114 *encapsulatedPixels = FALSE;
05115 break;
05116 case DCM_ORDERBIGENDIAN:
05117 *byteOrder = BIG_ORDER;
05118 *encapsulatedPixels = FALSE;
05119 break;
05120 case DCM_EXPLICITBIGENDIAN:
05121 *byteOrder = BIG_ORDER;
05122 *explicitVR = TRUE;
05123 *encapsulatedPixels = FALSE;
05124 break;
05125 case DCM_ENCAPSULATEDPIXELS:
05126 *byteOrder = LITTLE_ORDER;
05127 *explicitVR = TRUE;
05128 *encapsulatedPixels = TRUE;
05129 break;
05130 default:
05131 *byteOrder = LITTLE_ORDER;
05132 *encapsulatedPixels = FALSE;
05133 break;
05134 }
05135
05136 return DCM_NORMAL;
05137 }
|
|
|
Definition at line 4884 of file mri_dicom_hdr.c. References fd.
04885 {
04886 int
04887 status;
04888 struct stat
04889 im_stat;
04890
04891 status = fstat(fd, &im_stat);
04892 if (status < 0) {
04893 return status;
04894 } else
04895 return im_stat.st_size;
04896 }
|
|
||||||||||||||||
|
Definition at line 3637 of file mri_dicom_hdr.c. References PRV_GROUP_ITEM::baseLength, COND_PushCondition(), CONDITION, CTN_MALLOC, CTNBOOLEAN, DCM_ELEMENT::d, DCM_ELEMENTCREATEFAILED, DCM_LISTFAILURE, DCM_MAKETAG, DCM_Message(), DCM_NORMAL, DCM_UL, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, l, DCM_ELEMENT::length, PRV_GROUP_ITEM::longVRAttributes, LST_Create(), LST_Enqueue(), LST_Head(), LST_Insert(), LST_K_AFTER, LST_K_BEFORE, LST_Next(), LST_NORMAL, LST_Position(), newElementItem(), object, DCM_ELEMENT::tag, and U32.
03639 {
03640 PRV_GROUP_ITEM
03641 * item;
03642 CONDITION
03643 cond;
03644 CTNBOOLEAN
03645 tooFar = FALSE;
03646
03647 item = (void *)LST_Head(&(*object)->groupList);
03648 if (item != NULL)
03649 (void) LST_Position(&(*object)->groupList, (void *)item);
03650
03651 while (item != NULL && !tooFar) {
03652 if (item->group == group) {
03653 *groupItem = item;
03654 return DCM_NORMAL;
03655 } else if (item->group > group) {
03656 tooFar = TRUE;
03657 } else {
03658 item = (void *)LST_Next(&(*object)->groupList);
03659 }
03660 }
03661
03662 {
03663 U32 l;
03664 PRV_GROUP_ITEM *newGroupItem;
03665 DCM_ELEMENT groupLength = {0, DCM_UL, "", 1, sizeof(l), NULL};
03666 PRV_ELEMENT_ITEM *groupLengthItem;
03667
03668 newGroupItem = CTN_MALLOC(sizeof(*newGroupItem));
03669 if (newGroupItem == NULL)
03670 return COND_PushCondition(DCM_ELEMENTCREATEFAILED,
03671 DCM_Message(DCM_ELEMENTCREATEFAILED),
03672 "findCreateGroup",
03673 group, 0xffff, sizeof(*newGroupItem));
03674
03675
03676 *groupItem = newGroupItem;
03677 newGroupItem->group = group;
03678 newGroupItem->baseLength = 0;
03679 newGroupItem->longVRAttributes = 0;
03680 newGroupItem->elementList = LST_Create();
03681 if (newGroupItem->elementList == NULL)
03682 return COND_PushCondition(DCM_LISTFAILURE,
03683 DCM_Message(DCM_LISTFAILURE),
03684 "findCreateGroup");
03685
03686 if (tooFar)
03687 cond = LST_Insert(&(*object)->groupList, (void *)newGroupItem, LST_K_BEFORE);
03688 else
03689 cond = LST_Enqueue(&(*object)->groupList, (void *)newGroupItem);
03690 if (cond != LST_NORMAL)
03691 return COND_PushCondition(DCM_LISTFAILURE,
03692 DCM_Message(DCM_LISTFAILURE),
03693 "findCreateGroup");
03694 (void) LST_Position(&(*object)->groupList, (void *)newGroupItem);
03695 if (cond != LST_NORMAL)
03696 return COND_PushCondition(DCM_LISTFAILURE,
03697 DCM_Message(DCM_LISTFAILURE),
03698 "findCreateGroup");
03699
03700 groupLength.d.ul = &l;
03701 l = 0;
03702 if ((*object)->groupLengthFlag) {
03703 groupLength.tag = DCM_MAKETAG(group, 0);
03704 cond = newElementItem(&groupLength, TRUE, &groupLengthItem);
03705 (void) memcpy(groupLengthItem->element.d.ot, &l, sizeof(l));
03706
03707 if (LST_Insert(&newGroupItem->elementList, (void *)groupLengthItem, LST_K_AFTER) !=
03708 LST_NORMAL)
03709 return COND_PushCondition(DCM_LISTFAILURE,
03710 DCM_Message(DCM_LISTFAILURE),
03711 "findCreateGroup");
03712
03713 (*object)->objectSize += 8 + groupLengthItem->element.length;
03714 }
03715 }
03716 return DCM_NORMAL;
03717 }
|
|
||||||||||||||||
|
Definition at line 6888 of file mri_dicom_hdr.c. References COND_PushCondition(), CTN_MALLOC, CTNBOOLEAN, DCM_CloseObject(), DCM_ELEMENTCREATEFAILED, DCM_LISTFAILURE, DCM_Message(), DCM_NORMAL, DCM_OBJECT, LST_Create(), LST_Enqueue(), and LST_NORMAL.
06890 {
06891 CTNBOOLEAN createGroupFlag;
06892
06893 if (*groupItem == NULL)
06894 createGroupFlag = TRUE;
06895 else if ((*groupItem)->group != group)
06896 createGroupFlag = TRUE;
06897 else
06898 createGroupFlag = FALSE;
06899
06900 if (createGroupFlag == TRUE) {
06901 *groupItem = CTN_MALLOC(sizeof(**groupItem));
06902 if (*groupItem == NULL) {
06903 (void) DCM_CloseObject((DCM_OBJECT **) obj);
06904 return COND_PushCondition(DCM_ELEMENTCREATEFAILED,
06905 DCM_Message(DCM_ELEMENTCREATEFAILED),
06906 "handleGroupItem",
06907 group, 0xffff, sizeof(**groupItem));
06908 }
06909 (*groupItem)->group = group;
06910 (*groupItem)->baseLength = 0;
06911 (*groupItem)->longVRAttributes = 0;
06912 (*groupItem)->elementList = LST_Create();
06913 if ((*groupItem)->elementList == NULL) {
06914 (void) DCM_CloseObject((DCM_OBJECT **) obj);
06915 return COND_PushCondition(DCM_LISTFAILURE,
06916 DCM_Message(DCM_LISTFAILURE),
06917 "handleGroupItem");
06918 }
06919 if (LST_Enqueue(&(*obj)->groupList, (void *)*groupItem) != LST_NORMAL) {
06920 (void) DCM_CloseObject((DCM_OBJECT **) obj);
06921 return COND_PushCondition(DCM_LISTFAILURE,
06922 DCM_Message(DCM_LISTFAILURE),
06923 "handleGroupItem");
06924 }
06925 }
06926 return DCM_NORMAL;
06927 }
|
|
||||||||||||
|
Definition at line 3757 of file mri_dicom_hdr.c. References PRV_GROUP_ITEM::baseLength, PRV_ELEMENT_ITEM::byteOrder, COND_PushCondition(), CONDITION, CTN_FREE, DCM_ELEMENT::d, DCM_AE, DCM_AS, DCM_BADELEMENTINGROUP, DCM_CS, DCM_DA, DCM_DS, DCM_IS, DCM_LISTFAILURE, DCM_LO, DCM_LT, DCM_Message(), DCM_NORMAL, DCM_OB, DCM_ORDERNATIVE, DCM_OW, DCM_PN, DCM_SH, DCM_SQ, DCM_ST, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_TM, DCM_UI, DCM_UNEVENELEMENTLENGTH, DCM_UNSPECIFIEDLENGTH, DCM_UT, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, DCM_ELEMENT::length, PRV_GROUP_ITEM::longVRAttributes, LST_Current(), LST_Enqueue(), LST_Head(), LST_Insert(), LST_K_BEFORE, LST_Next(), LST_NORMAL, LST_Position(), newElementItem(), object, p, PRV_ELEMENT_ITEM::paddedDataLength, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and updateSpecialElements().
03758 {
03759 PRV_ELEMENT_ITEM
03760 * nextItem,
03761 *newItem;
03762 PRV_GROUP_ITEM
03763 * groupItem;
03764 CONDITION
03765 cond;
03766 char
03767 *p;
03768
03769 cond = newElementItem(element, TRUE, &newItem);
03770 if (cond != DCM_NORMAL) {
03771 return cond;
03772 }
03773 newItem->byteOrder = DCM_ORDERNATIVE;
03774 if ((newItem->element.length & 1) != 0) {
03775 if (newItem->element.representation == DCM_AE) {
03776 p = newItem->element.d.string; /* repair, check for 16 */
03777 p[newItem->element.length] = ' ';
03778 newItem->paddedDataLength = element->length + 1;
03779 (void) memcpy(p, element->d.string, element->length);
03780 } else if (newItem->element.representation == DCM_AS) {
03781 p = newItem->element.d.string;
03782 p[newItem->element.length] = ' ';
03783 newItem->paddedDataLength = element->length + 1;
03784 (void) memcpy(p, element->d.string, element->length);
03785 } else if (newItem->element.representation == DCM_CS) {
03786 p = newItem->element.d.string;
03787 p[newItem->element.length] = ' ';
03788 newItem->paddedDataLength = element->length + 1;
03789 (void) memcpy(p, element->d.string, element->length);
03790 } else if (newItem->element.representation == DCM_DA) {
03791 p = newItem->element.d.string;
03792 p[newItem->element.length] = ' ';
03793 newItem->paddedDataLength = element->length + 1;
03794 (void) memcpy(p, element->d.string, element->length);
03795 } else if (newItem->element.representation == DCM_DS) {
03796 p = newItem->element.d.string;
03797 p[newItem->element.length] = ' ';
03798 newItem->paddedDataLength = element->length + 1;
03799 (void) memcpy(p, element->d.string, element->length);
03800 } else if (newItem->element.representation == DCM_IS) {
03801 p = newItem->element.d.string;
03802 p[newItem->element.length] = ' ';
03803 newItem->paddedDataLength = element->length + 1;
03804 (void) memcpy(p, element->d.string, element->length);
03805 } else if (newItem->element.representation == DCM_LT) {
03806 p = newItem->element.d.string;
03807 p[newItem->element.length] = ' ';
03808 newItem->paddedDataLength = element->length + 1;
03809 (void) memcpy(p, element->d.string, element->length);
03810 } else if (newItem->element.representation == DCM_LO) {
03811 p = newItem->element.d.string;
03812 p[newItem->element.length] = ' ';
03813 newItem->paddedDataLength = element->length + 1;
03814 (void) memcpy(p, element->d.string, element->length);
03815 } else if (newItem->element.representation == DCM_PN) {
03816 p = newItem->element.d.string;
03817 p[newItem->element.length] = ' ';
03818 newItem->paddedDataLength = element->length + 1;
03819 (void) memcpy(p, element->d.string, element->length);
03820 } else if (newItem->element.representation == DCM_SH) {
03821 p = newItem->element.d.string;
03822 p[newItem->element.length] = ' ';
03823 newItem->paddedDataLength = element->length + 1;
03824 (void) memcpy(p, element->d.string, element->length);
03825 } else if (newItem->element.representation == DCM_ST) {
03826 p = newItem->element.d.string;
03827 p[newItem->element.length] = ' ';
03828 newItem->paddedDataLength = element->length + 1;
03829 (void) memcpy(p, element->d.string, element->length);
03830 } else if (newItem->element.representation == DCM_TM) {
03831 p = newItem->element.d.string;
03832 p[newItem->element.length] = ' ';
03833 newItem->paddedDataLength = element->length + 1;
03834 (void) memcpy(p, element->d.string, element->length);
03835 } else if (newItem->element.representation == DCM_UI) {
03836 p = newItem->element.d.string;
03837 p[newItem->element.length] = '\0';
03838 newItem->paddedDataLength = element->length + 1;
03839 (void) memcpy(p, element->d.string, element->length);
03840 } else if (newItem->element.representation == DCM_UT) {
03841 p = newItem->element.d.string;
03842 p[newItem->element.length] = ' ';
03843 newItem->paddedDataLength = element->length + 1;
03844 (void) memcpy(p, element->d.string, element->length);
03845 } else if (newItem->element.representation == DCM_SQ) {
03846 /* newItem->element.length = 0xffffffff; */
03847 newItem->element.d.sq = element->d.sq;
03848 } else {
03849 CTN_FREE(newItem);
03850 return COND_PushCondition(DCM_UNEVENELEMENTLENGTH,
03851 DCM_Message(DCM_UNEVENELEMENTLENGTH),
03852 DCM_TAG_GROUP(element->tag),
03853 DCM_TAG_ELEMENT(element->tag), element->length,
03854 "insertNewElement");
03855 }
03856 } else if (newItem->element.representation != DCM_SQ) {
03857 (void) memcpy(newItem->element.d.ot, element->d.ot, element->length);
03858 } else {
03859 /* newItem->element.length = 0xffffffff; */
03860 newItem->element.d.sq = element->d.sq;
03861 }
03862 if ((*object)->objectSize != DCM_UNSPECIFIEDLENGTH)
03863 (*object)->objectSize += 8 + newItem->paddedDataLength;
03864
03865 /* repair */
03866 cond = updateSpecialElements(object, newItem);
03867 if (cond != DCM_NORMAL)
03868 return cond;
03869
03870 groupItem = (void *)LST_Current(&(*object)->groupList);
03871 if (groupItem == NULL)
03872 return COND_PushCondition(DCM_LISTFAILURE,
03873 DCM_Message(DCM_LISTFAILURE), "insertNewElement");
03874
03875 if (groupItem->baseLength != DCM_UNSPECIFIEDLENGTH)
03876 groupItem->baseLength += 2 + 2 + 4 + newItem->paddedDataLength;
03877
03878 if (newItem->element.representation == DCM_OW ||
03879 newItem->element.representation == DCM_OB ||
03880 newItem->element.representation == DCM_SQ) {
03881 groupItem->longVRAttributes++;
03882 (*object)->longVRAttributes++;
03883 }
03884 if ((nextItem = (void *)LST_Head(&groupItem->elementList)) == NULL) {
03885 cond = LST_Enqueue(&groupItem->elementList, (void *)newItem);
03886 if (cond != LST_NORMAL)
03887 return COND_PushCondition(DCM_LISTFAILURE,
03888 DCM_Message(DCM_LISTFAILURE),
03889 "insertNewElement");
03890 else
03891 return DCM_NORMAL;
03892 }
03893 (void) LST_Position(&groupItem->elementList, (void *)nextItem);
03894 if (DCM_TAG_ELEMENT(nextItem->element.tag) == 0x0000)
03895 (void) memcpy(nextItem->element.d.ot, &groupItem->baseLength,
03896 sizeof(groupItem->baseLength));
03897
03898 /* Now, search through the linked list for a place to insert/append
03899 ** this new item.
03900 */
03901
03902 while (nextItem != NULL) {
03903 if (DCM_TAG_GROUP(element->tag) !=
03904 DCM_TAG_GROUP(nextItem->element.tag)) {
03905 return COND_PushCondition(DCM_BADELEMENTINGROUP,
03906 DCM_Message(DCM_BADELEMENTINGROUP),
03907 DCM_TAG_GROUP(nextItem->element.tag),
03908 DCM_TAG_ELEMENT(nextItem->element.tag),
03909 groupItem->group, "insertNewElement");
03910 } else if (DCM_TAG_ELEMENT(element->tag) <
03911 DCM_TAG_ELEMENT(nextItem->element.tag)) {
03912 cond = LST_Insert(&groupItem->elementList, (void *)newItem, LST_K_BEFORE);
03913 if (cond != LST_NORMAL)
03914 return COND_PushCondition(DCM_LISTFAILURE,
03915 DCM_Message(DCM_LISTFAILURE),
03916 "insertNewElement");
03917 else
03918 return DCM_NORMAL;
03919 }
03920 nextItem = (void *)LST_Next(&groupItem->elementList);
03921 }
03922
03923 /* If we fall out of the loop, we must have reached the end of
03924 ** the group. Add the element to the end of the list of elements
03925 ** in this group.
03926 */
03927
03928 cond = LST_Enqueue(&groupItem->elementList, (void *)newItem);
03929 if (cond != LST_NORMAL)
03930 return COND_PushCondition(DCM_LISTFAILURE,
03931 DCM_Message(DCM_LISTFAILURE),
03932 "insertNewElement");
03933 else
03934 return DCM_NORMAL;
03935 }
|
|
||||||||||||
|
Definition at line 3938 of file mri_dicom_hdr.c. References PRV_GROUP_ITEM::baseLength, COND_PushCondition(), CONDITION, DCM_ELEMENT::d, DCM_BADELEMENTINGROUP, DCM_LISTFAILURE, DCM_Message(), DCM_NORMAL, DCM_OB, DCM_OW, DCM_SQ, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UNSPECIFIEDLENGTH, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, findCreateGroup(), PRV_GROUP_ITEM::group, PRV_GROUP_ITEM::longVRAttributes, LST_Enqueue(), LST_Head(), LST_Insert(), LST_K_BEFORE, LST_Next(), LST_NORMAL, LST_Position(), object, PRV_ELEMENT_ITEM::paddedDataLength, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and updateSpecialElements().
03939 {
03940 PRV_ELEMENT_ITEM * nextItem;
03941 PRV_GROUP_ITEM * groupItem = 0;
03942 CONDITION cond;
03943
03944 /* repair */
03945 cond = updateSpecialElements(object, newItem);
03946 if (cond != DCM_NORMAL)
03947 return cond;
03948
03949 cond = findCreateGroup(object, DCM_TAG_GROUP(newItem->element.tag),
03950 &groupItem);
03951
03952 if (groupItem == NULL)
03953 return COND_PushCondition(DCM_LISTFAILURE,
03954 DCM_Message(DCM_LISTFAILURE), "insertThisElementItem");
03955
03956 if (groupItem->baseLength != DCM_UNSPECIFIEDLENGTH)
03957 groupItem->baseLength += 2 + 2 + 4 + newItem->paddedDataLength;
03958
03959 if (newItem->element.representation == DCM_OW ||
03960 newItem->element.representation == DCM_OB ||
03961 newItem->element.representation == DCM_SQ) {
03962 groupItem->longVRAttributes++;
03963 (*object)->longVRAttributes++;
03964 }
03965
03966 if ((nextItem = (void *)LST_Head(&groupItem->elementList)) == NULL) {
03967 cond = LST_Enqueue(&groupItem->elementList, (void *)newItem);
03968 if (cond != LST_NORMAL)
03969 return COND_PushCondition(DCM_LISTFAILURE,
03970 DCM_Message(DCM_LISTFAILURE),
03971 "insertThisElementItem");
03972 else
03973 return DCM_NORMAL;
03974 }
03975
03976 (void) LST_Position(&groupItem->elementList, (void *)nextItem);
03977 if (DCM_TAG_ELEMENT(nextItem->element.tag) == 0x0000)
03978 (void) memcpy(nextItem->element.d.ot, &groupItem->baseLength,
03979 sizeof(groupItem->baseLength));
03980
03981 /* Now, search through the linked list for a place to insert/append
03982 ** this new item.
03983 */
03984
03985 while (nextItem != NULL) {
03986 if (DCM_TAG_GROUP(newItem->element.tag) !=
03987 DCM_TAG_GROUP(nextItem->element.tag)) {
03988 return COND_PushCondition(DCM_BADELEMENTINGROUP,
03989 DCM_Message(DCM_BADELEMENTINGROUP),
03990 DCM_TAG_GROUP(nextItem->element.tag),
03991 DCM_TAG_ELEMENT(nextItem->element.tag),
03992 groupItem->group, "insertThisElementItem");
03993 } else if (DCM_TAG_ELEMENT(newItem->element.tag) <
03994 DCM_TAG_ELEMENT(nextItem->element.tag)) {
03995 cond = LST_Insert(&groupItem->elementList, (void *)newItem, LST_K_BEFORE);
03996 if (cond != LST_NORMAL)
03997 return COND_PushCondition(DCM_LISTFAILURE,
03998 DCM_Message(DCM_LISTFAILURE),
03999 "insertThisElementItem");
04000 else
04001 return DCM_NORMAL;
04002 }
04003 nextItem = (void *)LST_Next(&groupItem->elementList);
04004 }
04005
04006 /* If we fall out of the loop, we must have reached the end of
04007 ** the group. Add the element to the end of the list of elements
04008 ** in this group.
04009 */
04010
04011 cond = LST_Enqueue(&groupItem->elementList, (void *)newItem);
04012 if (cond != LST_NORMAL)
04013 return COND_PushCondition(DCM_LISTFAILURE,
04014 DCM_Message(DCM_LISTFAILURE),
04015 "insertThisElementItem");
04016 else
04017 return DCM_NORMAL;
04018 }
|
|
||||||||||||
|
Definition at line 7230 of file mri_dicom_hdr.c. References CTNBOOLEAN, DCM_TAG, DCM_TAG_GROUP, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, PRV_GROUP_ITEM::group, LST_Head(), LST_Next(), LST_Position(), and DCM_ELEMENT::tag.
07231 {
07232 PRV_GROUP_ITEM
07233 * groupItem;
07234 PRV_ELEMENT_ITEM
07235 * elementItem;
07236 CTNBOOLEAN
07237 found = FALSE;
07238
07239 groupItem = (void *)LST_Head(&(*obj)->groupList);
07240 if (groupItem == NULL)
07241 return NULL;
07242
07243 (void) LST_Position(&(*obj)->groupList, (void *)groupItem);
07244 while (groupItem != NULL) {
07245 if (groupItem->group == DCM_TAG_GROUP(tag))
07246 break;
07247
07248 groupItem = (void *)LST_Next(&(*obj)->groupList);
07249 }
07250 if (groupItem == NULL)
07251 return NULL;
07252
07253 elementItem = (void *)LST_Head(&groupItem->elementList);
07254 if (elementItem == NULL)
07255 return NULL;
07256
07257 (void) LST_Position(&groupItem->elementList, (void *)elementItem);
07258 while (!found && (elementItem != NULL)) {
07259 if (elementItem->element.tag == tag) {
07260 found = TRUE;
07261 } else
07262 elementItem = (void *)LST_Next(&groupItem->elementList);
07263 }
07264 if (found)
07265 return elementItem;
07266 else
07267 return NULL;
07268 }
|
|
|
Definition at line 4166 of file mri_dicom_hdr.c.
|
|
|
Definition at line 10869 of file mri_dicom_hdr.c.
10874 {
10875 return (*list)->count;
10876 }
|
|
|
Definition at line 10727 of file mri_dicom_hdr.c. References lst_head::count, CTN_MALLOC, lst_head::current, lst_head::head, and lst_head::tail. Referenced by copySequence(), DCM_AddFragment(), DCM_CopyObject(), DCM_CreateObject(), findCreateGroup(), handleGroupItem(), readFile(), and readSequence().
|
|
|
Definition at line 10893 of file mri_dicom_hdr.c.
10899 {
10900 return (*list)->current;
10901 }
|
|
|
Definition at line 10811 of file mri_dicom_hdr.c. References lst_node::next, and lst_node::previous.
10817 {
10818 LST_NODE
10819 * ptr;
10820
10821 if ((*list)->head == NULL) {/* list is empty */
10822 (*list)->count = 0;
10823 return NULL;
10824 }
10825 ptr = (*list)->head; /* save the head */
10826 (*list)->head = ptr->next; /* set new head of list */
10827 if ((*list)->head == NULL) /* if the list is now empty */
10828 (*list)->tail = NULL; /* there is no tail anymore */
10829 else
10830 (*list)->head->previous = NULL; /* new head has no previous */
10831 ptr->next = NULL; /* hide data from user */
10832 (*list)->count--; /* list has one fewer node */
10833 /* now */
10834 return ptr;
10835 }
|
|
|
Definition at line 10750 of file mri_dicom_hdr.c. References CTN_FREE, LST_LISTNOTEMPTY, and LST_NORMAL.
10756 {
10757
10758 if ((*list)->count != 0)
10759 return LST_LISTNOTEMPTY;
10760
10761 CTN_FREE(*list);
10762 *list = NULL;
10763 return LST_NORMAL;
10764 }
|
|
||||||||||||
|
Definition at line 10769 of file mri_dicom_hdr.c. References LST_NORMAL, lst_node::next, and lst_node::previous.
10775 {
10776 node->next = NULL; /* no next node */
10777 node->previous = (*list)->tail; /* previous is old tail */
10778 if ((*list)->head == NULL) /* if list was empty... */
10779 (*list)->head = node; /* it has a head now! */
10780 else
10781 (*list)->tail->next = node; /* old tail now has a next */
10782
10783 (*list)->tail = node; /* list now has a new tail */
10784 (*list)->count++; /* bump the counter */
10785 return LST_NORMAL;
10786 }
|
|
|
Definition at line 10881 of file mri_dicom_hdr.c.
10887 {
10888 return (*list)->head;
10889 }
|
|
||||||||||||
|
Definition at line 11186 of file mri_dicom_hdr.c. References l, LST_Head(), LST_Next(), and LST_Position().
11187 {
11188 LST_NODE
11189 * n;
11190
11191 n = LST_Head(l);
11192 if (n == NULL)
11193 return NULL;
11194
11195 index--;
11196 LST_Position(l, n);
11197 while (index-- > 0 && n != NULL)
11198 n = LST_Next(l);
11199
11200 return n;
11201 }
|
|
||||||||||||||||
|
Definition at line 10918 of file mri_dicom_hdr.c. References CURRENT, LST_BADEND, LST_END, LST_K_AFTER, LST_K_BEFORE, LST_NOCURRENT, LST_NORMAL, lst_node::next, OLD_NEXT, OLD_PREV, and lst_node::previous.
10926 {
10927 if ((where != LST_K_BEFORE) && (where != LST_K_AFTER))
10928 goto badend;
10929
10930 if ((*list)->head == NULL) {/* if the list was empty */
10931 (*list)->tail = node; /* set the tail pointer */
10932 (*list)->head = node; /* set the head pointer */
10933 (*list)->count = 0; /* will get bumped later... */
10934 (node)->next = NULL; /* there is no next */
10935 (node)->previous = NULL;/* and no previous */
10936
10937 } else if (CURRENT == NULL) /* is he mixing semantics? */
10938 goto nocurrent;
10939
10940 else if ((CURRENT == (*list)->head) && /* if at the head */
10941 (where == LST_K_BEFORE)) { /* and inserting BEFORE */
10942 node->next = CURRENT; /* splice new node in */
10943 CURRENT->previous = node; /* before the current */
10944 node->previous = NULL; /* new one has no previous */
10945 (*list)->head = node; /* new one is first now */
10946
10947 } else if ((CURRENT == (*list)->tail) && /* if at the tail */
10948 (where == LST_K_AFTER)) { /* and inserting AFTER */
10949 node->next = NULL; /* new node has no next */
10950 node->previous = (*list)->tail; /* previous is old tail */
10951 CURRENT->next = node; /* splice new node in */
10952 (*list)->tail = node; /* new node is now the tail */
10953
10954 } else if (where == LST_K_AFTER) { /* not a special case */
10955 OLD_NEXT->previous = node; /* we preceed a node */
10956 node->next = OLD_NEXT; /* the old next follows us */
10957 node->previous = CURRENT; /* the current preceeds us */
10958 CURRENT->next = node; /* we follow current */
10959
10960 } else { /* not a special case */
10961 OLD_PREV->next = node; /* we follow the previous */
10962 node->previous = OLD_PREV; /* of current */
10963 node->next = CURRENT; /* current follows us and */
10964 CURRENT->previous = node; /* we preceed current */
10965 };
10966
10967 (*list)->count++; /* bump the counter */
10968 (*list)->current = node; /* and set current */
10969 return LST_NORMAL;
10970
10971 badend:
10972 return LST_BADEND;
10973
10974 nocurrent:
10975 return LST_NOCURRENT;
10976 }
|
|
|
Definition at line 11053 of file mri_dicom_hdr.c. References CURRENT.
|
|
|
Definition at line 10840 of file mri_dicom_hdr.c. References lst_node::next, and lst_node::previous.
10846 {
10847 LST_NODE
10848 * ptr;
10849
10850 if ((*list)->head == NULL) {/* list is empty */
10851 (*list)->count = 0;
10852 return NULL;
10853 }
10854 ptr = (*list)->head; /* save the head */
10855 (*list)->head = ptr->next; /* set new head of list */
10856 if ((*list)->head == NULL) /* if the list is now empty */
10857 (*list)->tail = NULL; /* there is no tail anymore */
10858 else
10859 (*list)->head->previous = NULL; /* new head has no previous */
10860 ptr->next = NULL; /* hide data from user */
10861 (*list)->count--; /* list has one fewer node */
10862 /* now */
10863 return ptr;
10864 }
|
|
||||||||||||
|
Definition at line 11098 of file mri_dicom_hdr.c. References CURRENT, lst_node::next, and lst_node::previous.
11103 : node = lst_position(list, lst_head(list)); 11104 * makes the node at the head of the list current 11105 * and returns a pointer to it. 11106 * 11107 * The routine tries to verify that "node" is in the list 11108 * by doing a few consistency checks. It assumes that if 11109 * any of three "known" pointers are what they should be 11110 * that all is well. Its not damnfoolproof, but... 11111 */ 11112 { 11113 if ((*list)->head == NULL) {/* list is empty */ 11114 return NULL; 11115 } 11116 if (node == NULL) 11117 return NULL; 11118 if (((node->previous == NULL) && ((*list)->head == node)) || 11119 ((node->next == NULL) && ((*list)->tail == node)) || 11120 (node->previous->next == node)) { /* its probably OK */ 11121 11122 CURRENT = node; 11123 return CURRENT; 11124 }; 11125 11126 return NULL; 11127 } |
|
|
Definition at line 11074 of file mri_dicom_hdr.c. References CURRENT.
11080 {
11081 if ((*list)->head == NULL) {/* list is empty */
11082 (*list)->count = 0;
11083 return NULL;
11084 }
11085 if (CURRENT == NULL) { /* there is no CURRENT */
11086 return NULL;
11087 }
11088 if (CURRENT->previous == NULL) { /* no PREVIOUS */
11089 return NULL;
11090 }
11091 CURRENT = CURRENT->previous;/* found it */
11092 return CURRENT;
11093 }
|
|
||||||||||||
|
Definition at line 10789 of file mri_dicom_hdr.c. References LST_NORMAL, lst_node::next, and lst_node::previous.
10796 {
10797 node->next = (*list)->head; /* set the forward link */
10798 node->previous = NULL; /* set rearward link */
10799 if ((*list)->tail == NULL) /* if the list was empty */
10800 (*list)->tail = node; /* set the tail pointer */
10801 else /* otherwise, */
10802 (*list)->head->previous = node; /* old head now has a previous */
10803
10804 (*list)->head = node; /* set new first node */
10805 (*list)->count++; /* bump the counter */
10806 return LST_NORMAL;
10807
10808 }
|
|
||||||||||||
|
Definition at line 10981 of file mri_dicom_hdr.c. References CURRENT, LST_END, LST_K_AFTER, LST_K_BEFORE, lst_node::next, OLD_NEXT, OLD_PREV, and lst_node::previous.
10991 {
10992 LST_NODE
10993 * ptr;
10994
10995 if ((dir != LST_K_BEFORE) && (dir != LST_K_AFTER))
10996 goto baddir;
10997 if (CURRENT == NULL)
10998 goto nocurrent;
10999 if ((*list)->head == NULL)
11000 goto listempty;
11001
11002 ptr = CURRENT; /* save node */
11003
11004 if (CURRENT == (*list)->head) { /* removing the head */
11005 (*list)->head = OLD_NEXT; /* set new head of list */
11006 if ((*list)->head == NULL) /* if the list is now empty */
11007 (*list)->tail = NULL; /* no tail anymore either */
11008 else
11009 (*list)->head->previous = NULL; /* new head has no previous */
11010 if (dir == LST_K_BEFORE)/* there is nothing before */
11011 (*list)->current = NULL; /* the head of the list */
11012 else /* otherwise, remain */
11013 (*list)->current = (*list)->head; /* at the head... */
11014
11015 } else if (CURRENT == (*list)->tail) { /* removing the tail */
11016 (*list)->tail = OLD_PREV; /* set new tail of list */
11017 (*list)->tail->next = NULL; /* new tail has no next */
11018 if (dir == LST_K_AFTER) /* there is nothing after */
11019 (*list)->current = NULL; /* the tail of a list */
11020 else /* otherwise, remain */
11021 (*list)->current = (*list)->tail; /* at the tail... */
11022
11023 } else { /* not a special case */
11024 OLD_PREV->next = CURRENT->next; /* set forward pointer */
11025 OLD_NEXT->previous = CURRENT->previous; /* set backward pointer */
11026 if (dir == LST_K_BEFORE)/* depending on direction, */
11027 (*list)->current = CURRENT->previous; /* set current */
11028 else /* in the */
11029 (*list)->current = CURRENT->next; /* list head */
11030 }
11031
11032 (*list)->count--; /* one fewer nodes now */
11033 ptr->previous = NULL; /* hide data from user */
11034 ptr->next = NULL; /* hide data from user */
11035 return ptr;
11036
11037 baddir:
11038 return NULL;
11039
11040 nocurrent:
11041 return NULL;
11042
11043 listempty:
11044 (*list)->count = 0;
11045 (*list)->current = NULL;
11046 (*list)->head = (*list)->tail = NULL;
11047 return NULL;
11048 }
|
|
||||||||||||||||
|
Definition at line 11135 of file mri_dicom_hdr.c. References AFNI_CALL_VALU_2ARG, compare(), lst_head::count, CTNBOOLEAN, lst_head::current, lst_head::head, LST_Dequeue(), LST_Enqueue(), LST_Head(), LST_Insert(), LST_K_BEFORE, LST_Next(), LST_NORMAL, LST_Position(), n1, n2, and lst_head::tail.
11136 {
11137 LST_NODE
11138 * n1,
11139 *n2;
11140 LST_HEAD
11141 temp,
11142 *head;
11143 CTNBOOLEAN
11144 inserted;
11145 int ccc ;
11146
11147 if ((*list)->head == NULL) {/* list is empty */
11148 return LST_NORMAL;
11149 }
11150 head = &temp;
11151 head->head = NULL;
11152 head->tail = NULL;
11153 head->current = NULL;
11154 head->count = 0;
11155
11156 while ((n1 = LST_Dequeue(list)) != NULL) {
11157 n2 = LST_Head(&head);
11158 if (n2 != NULL)
11159 (void) LST_Position(&head, n2);
11160 inserted = FALSE;
11161 while (n2 != NULL && !inserted) {
11162 #if 0
11163 if (compare(n1, n2) < 0) {
11164 #else
11165 AFNI_CALL_VALU_2ARG(compare,int,ccc,LST_NODE *,n1,LST_NODE *,n2) ;
11166 if( ccc < 0 ){
11167 #endif
11168 (void) LST_Insert(&head, n1, LST_K_BEFORE);
11169 inserted = TRUE;
11170 } else
11171 n2 = LST_Next(&head);
11172 }
11173 if (n2 == NULL)
11174 (void) LST_Enqueue(&head, n1);
11175 }
11176 **list = *head;
11177 return LST_NORMAL;
11178 }
|
|
|
Definition at line 10906 of file mri_dicom_hdr.c.
10912 {
10913 return (*list)->tail;
10914 }
|
|
||||||||||||
|
Definition at line 4179 of file mri_dicom_hdr.c. References DCM_VALUEREPRESENTATION, DIM_OF, and i.
|
|
|
Definition at line 203 of file mri_dicom_hdr.c. References close(), COND_PopCondition(), CONDITION, CTNBOOLEAN, DCM_CloseObject(), DCM_Debug(), DCM_DumpElements(), DCM_FormatElements(), DCM_NORMAL, DCM_OBJECT, DCM_OpenFile(), DCM_ORDERLITTLEENDIAN, DCM_PART10FILE, ENTRY, getenv(), object, p, pbuf, pxl_len, pxl_off, RETURN, RWC_clear_pbuf(), rwc_fd, RWC_printf(), RWC_set_endianosity(), rwc_vm, and STATUS.
00204 {
00205 DCM_OBJECT * object;
00206 CONDITION cond;
00207 CTNBOOLEAN verbose = FALSE ,
00208 exitFlag = FALSE,
00209 formatFlag = FALSE;
00210 unsigned long
00211 options = DCM_ORDERLITTLEENDIAN;
00212 long vmLimit = rwc_vm ; /* 28 Oct 2002 */
00213 LST_HEAD* fileNames = 0;
00214 UTL_FILEITEM* p = NULL;
00215
00216 char *ppp=NULL ;
00217
00218 ENTRY("mri_dicom_header") ;
00219
00220 if( fname == NULL ) RETURN(NULL) ;
00221
00222 RWC_set_endianosity() ;
00223
00224 { char *eee = getenv("AFNI_TRACE") ;
00225 if( eee!=NULL && (*eee=='y' || *eee=='Y') ) verbose = TRUE ;
00226 }
00227
00228 DCM_Debug(verbose);
00229
00230 RWC_clear_pbuf() ; pxl_len = 0 ; pxl_off = 0 ;
00231
00232 STATUS(fname) ;
00233 rwc_fd = -1 ;
00234 cond = DCM_OpenFile(fname, options, &object);
00235 if (cond != DCM_NORMAL && ((options & DCM_PART10FILE) == 0)) {
00236 STATUS("DCM_OpenFile open failed; try again as Part 10") ;
00237 (void) DCM_CloseObject(&object);
00238 (void) COND_PopCondition(TRUE);
00239 if( rwc_fd >= 0 ){ close(rwc_fd); rwc_fd = -1; }
00240 cond = DCM_OpenFile(fname, options | DCM_PART10FILE, &object);
00241 }
00242 if (cond == DCM_NORMAL) {
00243 STATUS("DCM_OpenFile is good") ;
00244 RWC_printf("DICOM File: %s\n", fname);
00245 if (formatFlag)
00246 cond = DCM_FormatElements(&object, vmLimit, "");
00247 else
00248 cond = DCM_DumpElements(&object, vmLimit);
00249 } else {
00250 STATUS("DCM_OpenFile failed") ;
00251 }
00252 (void) DCM_CloseObject(&object);
00253 (void) COND_PopCondition(TRUE);
00254
00255 if( pbuf != NULL ){
00256 ppp = strdup(pbuf) ; RWC_clear_pbuf() ;
00257 }
00258
00259 if( rwc_fd >= 0 ){ close(rwc_fd); rwc_fd = -1; }
00260
00261 RETURN(ppp);
00262 }
|
|
|
Definition at line 173 of file mri_dicom_hdr.c. References RWC_NOHEX_MASK, and rwc_opt.
00174 {
00175 if( ii )
00176 rwc_opt |= RWC_NOHEX_MASK ;
00177 else if( rwc_opt & RWC_NOHEX_MASK )
00178 rwc_opt ^= RWC_NOHEX_MASK ;
00179 }
|
|
|
Definition at line 165 of file mri_dicom_hdr.c. References RWC_NONAME_MASK, and rwc_opt.
00166 {
00167 if( ii )
00168 rwc_opt |= RWC_NONAME_MASK ;
00169 else if( rwc_opt & RWC_NONAME_MASK )
00170 rwc_opt ^= RWC_NONAME_MASK ;
00171 }
|
|
||||||||||||
|
Definition at line 153 of file mri_dicom_hdr.c. References pxl_len, and pxl_off.
|
|
|
Definition at line 194 of file mri_dicom_hdr.c. References rwc_err.
00195 {
00196 rwc_err = vv ; /* 07 May 2003: an error will subtract 1 from rwc_err */
00197 }
|
|
|
Definition at line 185 of file mri_dicom_hdr.c. References rwc_vm.
00186 {
00187 rwc_vm = vv ;
00188 }
|
|
||||||||||||||||
|
Definition at line 3547 of file mri_dicom_hdr.c. References COND_PushCondition(), CTN_MALLOC, CTNBOOLEAN, DCM_ELEMENTCREATEFAILED, DCM_Message(), DCM_NORMAL, DCM_SQ, DCM_TAG_ELEMENT, DCM_TAG_GROUP, l, DCM_ELEMENT::length, NATIVE_ORDER, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and U32.
03549 {
03550 U32
03551 l;
03552
03553 if (allocateData && (src->representation != DCM_SQ)) {
03554 l = src->length;
03555 if (l & 1)
03556 l++;
03557 } else
03558 l = 0;
03559
03560 if (debug)
03561 fprintf(stderr, "newElementItem: CTN_MALLOC %8d %8d ", l,
03562 (int)(sizeof(PRV_ELEMENT_ITEM) + l));
03563
03564 *dst = (PRV_ELEMENT_ITEM *) CTN_MALLOC(sizeof(PRV_ELEMENT_ITEM) + l);
03565 if (debug)
03566 fprintf(stderr, "%8p\n", *dst);
03567
03568 if (*dst == NULL) {
03569 return COND_PushCondition(DCM_ELEMENTCREATEFAILED,
03570 DCM_Message(DCM_ELEMENTCREATEFAILED), "newElementItem",
03571 DCM_TAG_GROUP(src->tag),
03572 DCM_TAG_ELEMENT(src->tag),
03573 l);
03574 }
03575 memset(*dst, 0, sizeof(PRV_ELEMENT_ITEM));
03576 (*dst)->element = *src;
03577 (*dst)->byteOrder = NATIVE_ORDER;
03578 (*dst)->allocatedDataLength = (size_t) l;
03579 (*dst)->originalDataLength = src->length;
03580 (*dst)->paddedDataLength = src->length;
03581 if (allocateData)
03582 (*dst)->element.d.ot = ((char *) (*dst)) + sizeof(PRV_ELEMENT_ITEM);
03583 else
03584 (*dst)->element.d.ot = NULL;
03585
03586 (*dst)->fragmentFlag = 0;
03587 return DCM_NORMAL;
03588 }
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Definition at line 6738 of file mri_dicom_hdr.c. References BYTEORDER_SAME, COND_PushCondition(), CONDITION, CTNBOOLEAN, DCM_AT, DCM_CloseObject(), DCM_FILEACCESSERROR, DCM_Message(), DCM_NORMAL, DCM_OB, DCM_OBJECT, DCM_OW, DCM_PXLPIXELDATA, DCM_UNSPECIFIEDLENGTH, fd, name, newElementItem(), object, pxl_len, pxl_off, read(), scanCompressedPixels(), swapATGroupElement(), swapInPlace(), DCM_ELEMENT::tag, U32, and verifyFormat().
06746 {
06747 CTNBOOLEAN pixelFlag;
06748 CONDITION cond;
06749 int nBytes;
06750
06751 pixelFlag = (e->tag == DCM_PXLPIXELDATA);
06752 cond = newElementItem(e, (pixelFlag == FALSE), elementItem);
06753 if (cond != DCM_NORMAL) {
06754 (void) DCM_CloseObject((DCM_OBJECT **) object);
06755 return cond;
06756 }
06757 (*elementItem)->element.data_offset = 0 ; /* RWCox */
06758 if (pixelFlag) {
06759 if (fileFlag)
06760 *remainOpenFlag = TRUE;
06761 (*elementItem)->byteOrder = byteOrder;
06762 (*elementItem)->dataOffset = *fileOffset;
06763 (*elementItem)->currentOffset = 0;
06764 (*elementItem)->element.d.ot = NULL;
06765 if ((*object)->pixelBitsAllocated == 8)
06766 (*elementItem)->element.representation = DCM_OB;
06767 else
06768 (*elementItem)->element.representation = DCM_OW;
06769 if (fileFlag) {
06770 if (fd != -1) {
06771 if ((*elementItem)->element.length != DCM_UNSPECIFIEDLENGTH){
06772
06773 pxl_off = lseek( fd , 0 , SEEK_CUR ) ;
06774 pxl_len = (*elementItem)->element.length ;
06775
06776 (*elementItem)->element.data_offset = pxl_off ; /* RWCox */
06777
06778 (void) lseek(fd,
06779 (off_t) (*elementItem)->element.length,
06780 SEEK_CUR);
06781 } else {
06782 U32 l1 = 0;
06783 U32 s1;
06784 off_t f1 = 0;
06785
06786 s1 = *size;
06787 scanCompressedPixels("", ptr, fd,
06788 &s1, /* size */
06789 &f1, /* fileOffset */
06790 0, 0,
06791 byteOrder, explicitVR,
06792 acceptVRMismatch,
06793 fileFlag, remainOpenFlag,
06794 convertFlag, object,
06795 &l1, /* scannedLength */
06796 e, elementItem);
06797 (*elementItem)->originalDataLength = l1;
06798 (*elementItem)->paddedDataLength = l1;
06799 }
06800 } else {
06801 (*object)->sk((*object)->userCtx,
06802 (*elementItem)->element.length, SEEK_CUR);
06803 }
06804 (*object)->fd = fd;
06805 }
06806 } else {
06807 if (fileFlag) {
06808 if (fd != -1) {
06809 (*elementItem)->element.data_offset = lseek(fd,0,SEEK_CUR); /* RWCox */
06810 nBytes = read(fd, (*elementItem)->element.d.ot,
06811 (int) (*elementItem)->element.length);
06812 } else {
06813 cond = (*object)->rd((*object)->userCtx,
06814 (*elementItem)->element.d.ot,
06815 (long) (*elementItem)->element.length, &nBytes);
06816 }
06817 if (nBytes != (int) (*elementItem)->element.length) {
06818 (void) DCM_CloseObject((DCM_OBJECT **) object);
06819 return COND_PushCondition(DCM_FILEACCESSERROR,
06820 DCM_Message(DCM_FILEACCESSERROR), name, "readFile");
06821 }
06822 } else {
06823 (void) memcpy((*elementItem)->element.d.ot, ptr,
06824 (*elementItem)->element.length);
06825 ptr += (*elementItem)->originalDataLength;
06826 }
06827 if( LITTLE_ENDIAN_ARCHITECTURE ){
06828 if ((*elementItem)->element.representation == DCM_AT)
06829 swapATGroupElement(&(*elementItem)->element);
06830 }
06831 if (byteOrder != BYTEORDER_SAME)
06832 swapInPlace(object, &(*elementItem)->element);
06833 if (convertFlag) {
06834 cond = verifyFormat(*elementItem);
06835 if (cond != DCM_NORMAL)
06836 return cond;
06837 }
06838 }
06839 if (*size != (long) DCM_UNSPECIFIEDLENGTH)
06840 *size -= (*elementItem)->originalDataLength;
06841 *fileOffset += (off_t) (*elementItem)->originalDataLength;
06842 if (scannedLength != NULL)
06843 (*scannedLength) += (*elementItem)->originalDataLength;
06844
06845 if ((*elementItem)->element.length != DCM_UNSPECIFIEDLENGTH) {
06846 (*elementItem)->paddedDataLength = (*elementItem)->element.length;
06847 }
06848 if (((*elementItem)->paddedDataLength != DCM_UNSPECIFIEDLENGTH) &&
06849 ((*elementItem)->paddedDataLength & 1) )
06850 (*elementItem)->paddedDataLength += 1;
06851 (*object)->objectSize += (*elementItem)->paddedDataLength;
06852
06853 return DCM_NORMAL;
06854
06855 }
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Definition at line 5728 of file mri_dicom_hdr.c. References PRV_GROUP_ITEM::baseLength, BIG_ORDER, PRV_ELEMENT_ITEM::byteOrder, BYTEORDER_SAME, computeVM(), COND_PopCondition(), COND_PushCondition(), CONDITION, CTN_FREE, CTN_MALLOC, CTNBOOLEAN, ctxSensitiveLookup(), PRV_ELEMENT_ITEM::currentOffset, DCM_ELEMENT::d, PRV_ELEMENT_ITEM::dataOffset, DCM_AT, DCM_CloseObject(), DCM_CONVERTMASK, DCM_CreateObject(), DCM_CTX, DCM_DELETEMASK, DCM_DELETEONCLOSE, DCM_DLMITEM, DCM_DLMITEMDELIMITATIONITEM, DCM_DLMSEQUENCEDELIMITATIONITEM, DCM_DumpElements(), DCM_ELEMENTCREATEFAILED, DCM_ELEMENTLENGTHERROR, DCM_ELEMENTOUTOFORDER, DCM_EXPLICITBIGENDIAN, DCM_EXPLICITLITTLEENDIAN, DCM_FILEACCESSERROR, DCM_FORMATCONVERSION, DCM_ILLEGALSTREAMLENGTH, DCM_LISTFAILURE, DCM_LookupElement(), DCM_MAKETAG, DCM_MALLOCFAILURE, DCM_Message(), DCM_NORMAL, DCM_OB, DCM_OBJECT, DCM_ORDERBIGENDIAN, DCM_ORDERLITTLEENDIAN, DCM_ORDERMASK, DCM_ORDERNATIVE, DCM_OW, DCM_PXLPIXELDATA, DCM_SQ, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UNEVENELEMENTLENGTH, DCM_UNSPECIFIEDLENGTH, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, fd, GET_LONG_REVERSE_ORDER, GET_LONG_SAME_ORDER, GET_SHORT_REVERSE_ORDER, GET_SHORT_SAME_ORDER, PRV_GROUP_ITEM::group, DCM_ELEMENT::length, LITTLE_ORDER, PRV_GROUP_ITEM::longVRAttributes, LST_Create(), LST_Enqueue(), LST_Head(), LST_Next(), LST_NORMAL, LST_Position(), name, NATIVE_ORDER, newElementItem(), DCM_SEQUENCE_ITEM::object, object, offset, PRV_ELEMENT_ITEM::originalDataLength, PRV_ELEMENT_ITEM::paddedDataLength, read(), readFile(), DCM_ELEMENT::representation, swapATGroupElement(), swapInPlace(), DCM_ELEMENT::tag, U32, updateObjectType(), updateSpecialElements(), and verifyFormat().
05735 {
05736 CONDITION
05737 cond;
05738 int
05739 byteOrder;
05740 long
05741 lastGroup = -1,
05742 lastElement = -1;
05743 U32
05744 sequenceLength,
05745 localLength;
05746 PRIVATE_OBJECT
05747 ** object;
05748 PRV_GROUP_ITEM
05749 * groupItem = NULL;
05750 unsigned short
05751 group,
05752 element,
05753 tagGroup,
05754 tagElement;
05755 DCM_ELEMENT
05756 e,
05757 tagE;
05758 CTNBOOLEAN
05759 pixelFlag,
05760 convertFlag = FALSE,
05761 done = FALSE,
05762 knownLength = TRUE,
05763 sequenceDone = FALSE,
05764 createGroupFlag,
05765 explicitVR = FALSE;
05766 unsigned char
05767 buf[8],
05768 *ptr;
05769 int
05770 nBytes;
05771 PRV_ELEMENT_ITEM
05772 * elementItem = NULL;
05773 DCM_OBJECT
05774 * sequenceObject;
05775 DCM_SEQUENCE_ITEM
05776 * sequenceItem;
05777 CTNBOOLEAN
05778 fileFlag = TRUE;
05779
05780 if (callerBuf != NULL) {
05781 ptr = callerBuf;
05782 fileFlag = FALSE;
05783 } else
05784 ptr = buf;
05785
05786 switch (opt & DCM_ORDERMASK) {
05787 case DCM_ORDERNATIVE:
05788 byteOrder = NATIVE_ORDER;
05789 break;
05790 case DCM_ORDERLITTLEENDIAN:
05791 byteOrder = LITTLE_ORDER;
05792 break;
05793 case DCM_EXPLICITLITTLEENDIAN:
05794 byteOrder = LITTLE_ORDER;
05795 explicitVR = TRUE;
05796 break;
05797 case DCM_ORDERBIGENDIAN:
05798 byteOrder = BIG_ORDER;
05799 break;
05800 case DCM_EXPLICITBIGENDIAN:
05801 byteOrder = BIG_ORDER;
05802 explicitVR = TRUE;
05803 break;
05804 default:
05805 byteOrder = NATIVE_ORDER;
05806 break;
05807 }
05808 if ((opt & DCM_CONVERTMASK) == DCM_FORMATCONVERSION)
05809 convertFlag = TRUE;
05810
05811 if (scannedLength != NULL)
05812 *scannedLength = 0;
05813
05814 cond = DCM_CreateObject(callerObject, opt);
05815 if (cond != DCM_NORMAL)
05816 return cond;
05817
05818 object = (PRIVATE_OBJECT **) callerObject;
05819 if (fileFlag)
05820 strcpy((*object)->fileName, name);
05821
05822 (*object)->fd = -1;
05823 (*object)->rd = rd;
05824 (*object)->sk = sk;
05825 (*object)->userCtx = ctx;
05826 if (size == (long) DCM_UNSPECIFIEDLENGTH)
05827 knownLength = FALSE;
05828
05829 if ((fileFlag) && ((opt & DCM_DELETEMASK) == DCM_DELETEONCLOSE) && (recursionLevel == 0))
05830 (*object)->deleteFlag = TRUE;
05831
05832 if (knownLength && (size == 0))
05833 done = TRUE;
05834
05835 while (!done) {
05836
05837 if ((size < 8) && knownLength) {
05838 if (debug)
05839 (void) DCM_DumpElements(callerObject, 0);
05840 (void) DCM_CloseObject(callerObject);
05841 return COND_PushCondition(DCM_ILLEGALSTREAMLENGTH,
05842 DCM_Message(DCM_ILLEGALSTREAMLENGTH), size,
05843 "readFile");
05844 }
05845 if (fileFlag) {
05846 if (fd != -1) {
05847 nBytes = read(fd, buf, 4);
05848 } else {
05849 cond = (*object)->rd((*object)->userCtx, buf, 4, &nBytes);
05850 }
05851
05852 if (nBytes != 4)
05853 return COND_PushCondition(DCM_FILEACCESSERROR,
05854 DCM_Message(DCM_FILEACCESSERROR), name,
05855 "readFile");
05856 ptr = buf;
05857 }
05858 if (knownLength)
05859 size -= 4;
05860 fileOffset += (off_t) 4;
05861 if (scannedLength != NULL)
05862 (*scannedLength) += 4;
05863 (*object)->objectSize += 4;
05864
05865 if (byteOrder == BYTEORDER_SAME) {
05866 GET_SHORT_SAME_ORDER(ptr, group);
05867 GET_SHORT_SAME_ORDER(ptr + 2, element);
05868 e.tag = DCM_MAKETAG(group, element);
05869 } else {
05870 GET_SHORT_REVERSE_ORDER(ptr, group);
05871 GET_SHORT_REVERSE_ORDER(ptr + 2, element);
05872 e.tag = DCM_MAKETAG(group, element);
05873 }
05874 ptr += 4;
05875
05876 if (explicitVR) {
05877 if (fileFlag) {
05878 if (fd != -1) {
05879 nBytes = read(fd, buf, 4);
05880 } else {
05881 cond = (*object)->rd((*object)->userCtx, buf, 4, &nBytes);
05882 }
05883
05884 if (nBytes != 4)
05885 return COND_PushCondition(DCM_FILEACCESSERROR,
05886 DCM_Message(DCM_FILEACCESSERROR), name,
05887 "readFile");
05888 ptr = buf;
05889 }
05890 if (knownLength)
05891 size -= 4;
05892 fileOffset += (off_t) 4;
05893 if (scannedLength != NULL)
05894 (*scannedLength) += 4;
05895 (*object)->objectSize += 4;
05896 if ((strncmp((char *) ptr, "OB", 2) == 0) ||
05897 (strncmp((char *) ptr, "OW", 2) == 0) ||
05898 (strncmp((char *) ptr, "SQ", 2) == 0)) {
05899 } else {
05900 }
05901 } else {
05902
05903 if (fileFlag) {
05904 if (fd != -1) {
05905 nBytes = read(fd, buf, 4);
05906 } else {
05907 cond = (*object)->rd((*object)->userCtx, buf, 4, &nBytes);
05908 }
05909
05910 if (nBytes != 4)
05911 return COND_PushCondition(DCM_FILEACCESSERROR,
05912 DCM_Message(DCM_FILEACCESSERROR), name,
05913 "readFile");
05914 ptr = buf;
05915 }
05916 if (knownLength)
05917 size -= 4;
05918 fileOffset += (off_t) 4;
05919 if (scannedLength != NULL)
05920 (*scannedLength) += 4;
05921 (*object)->objectSize += 4;
05922
05923
05924 if (byteOrder == BYTEORDER_SAME) {
05925 GET_LONG_SAME_ORDER(ptr, e.length);
05926 } else {
05927 GET_LONG_REVERSE_ORDER(ptr, e.length);
05928 }
05929 ptr += 4;
05930 }
05931
05932 if (((e.length & 1) != 0) && (e.length != DCM_UNSPECIFIEDLENGTH)) {
05933 if (debug)
05934 (void) DCM_DumpElements(callerObject, 0);
05935 (void) DCM_CloseObject(callerObject);
05936 return COND_PushCondition(DCM_UNEVENELEMENTLENGTH,
05937 DCM_Message(DCM_UNEVENELEMENTLENGTH),
05938 group, element, e.length,
05939 "readFile");
05940 }
05941 if ((e.length != (U32) DCM_UNSPECIFIEDLENGTH) && (e.length > (U32) size)) {
05942 if (debug)
05943 (void) DCM_DumpElements(callerObject, 0);
05944 (void) DCM_CloseObject(callerObject);
05945 return COND_PushCondition(DCM_ELEMENTLENGTHERROR,
05946 DCM_Message(DCM_ELEMENTLENGTHERROR),
05947 group, element, e.length, size, "readFile");
05948 }
05949 if ((e.tag == DCM_DLMITEMDELIMITATIONITEM) ||
05950 (e.tag == DCM_DLMSEQUENCEDELIMITATIONITEM)) {
05951 return DCM_NORMAL;
05952 }
05953 cond = DCM_LookupElement(&e);
05954 if (cond != DCM_NORMAL)
05955 (void) COND_PopCondition(0);
05956 if (e.representation == DCM_CTX)
05957 ctxSensitiveLookup(object, &e);
05958
05959 if (e.representation == DCM_SQ) {
05960 cond = newElementItem(&e, FALSE, &elementItem);
05961 if (cond != DCM_NORMAL)
05962 return cond;
05963 elementItem->element.d.sq = LST_Create();
05964 if (elementItem->element.d.sq == NULL)
05965 return COND_PushCondition(DCM_LISTFAILURE,
05966 DCM_Message(DCM_LISTFAILURE), "readFile");
05967
05968 localLength = elementItem->element.length;
05969 sequenceDone = (localLength == 0);
05970
05971 while (!sequenceDone) {
05972 if (debug)
05973 fprintf(stderr, "Sequence Length: %d %x\n", localLength,
05974 localLength);
05975 if (fileFlag) {
05976 if (fd != -1) {
05977 nBytes = read(fd, buf, 8);
05978 } else {
05979 cond = (*object)->rd((*object)->userCtx, buf, 8, &nBytes);
05980 }
05981 if (nBytes != 8)
05982 return COND_PushCondition(DCM_FILEACCESSERROR,
05983 DCM_Message(DCM_FILEACCESSERROR), name,
05984 "readFile");
05985 ptr = buf;
05986 }
05987 if (size != (long) DCM_UNSPECIFIEDLENGTH)
05988 size -= 8;
05989 fileOffset += (off_t) 8;
05990 if (scannedLength != NULL)
05991 (*scannedLength) += 8;
05992 (*object)->objectSize += 8;
05993 if (localLength != DCM_UNSPECIFIEDLENGTH)
05994 localLength -= 8;
05995
05996 if (byteOrder == BYTEORDER_SAME) {
05997 GET_SHORT_SAME_ORDER(ptr, tagGroup);
05998 GET_SHORT_SAME_ORDER(ptr + 2, tagElement);
05999 tagE.tag = DCM_MAKETAG(tagGroup, tagElement);
06000 GET_LONG_SAME_ORDER(ptr + 4, tagE.length);
06001 } else {
06002 GET_SHORT_REVERSE_ORDER(ptr, tagGroup);
06003 GET_SHORT_REVERSE_ORDER(ptr + 2, tagElement);
06004 tagE.tag = DCM_MAKETAG(tagGroup, tagElement);
06005 GET_LONG_REVERSE_ORDER(ptr + 4, tagE.length);
06006 }
06007 ptr += 8;
06008 if (debug)
06009 fprintf(stderr, "Sequence item: %4x %4x %d (%x)\n",
06010 tagGroup, tagElement, tagE.length, tagE.length);
06011 if (tagE.tag == DCM_DLMITEM) {
06012 /* if (size != DCM_UNSPECIFIEDLENGTH)
06013 size -= 8;
06014 */
06015 /* fileOffset += 8;
06016 */
06017 cond = readFile(name,
06018 (fileFlag) ? NULL : ptr,
06019 fd, tagE.length,
06020 fileOffset, recursionLevel + 1, opt,
06021 &sequenceObject, &sequenceLength,
06022 remainOpenFlag, ctx, rd, sk);
06023 if (cond == DCM_NORMAL) {
06024 sequenceItem = CTN_MALLOC(sizeof(*sequenceItem));
06025 if (sequenceItem == NULL)
06026 return COND_PushCondition(DCM_MALLOCFAILURE,
06027 DCM_Message(DCM_MALLOCFAILURE),
06028 sizeof(*sequenceItem), "readFile");
06029
06030 sequenceItem->object = sequenceObject;
06031 cond = LST_Enqueue(&elementItem->element.d.sq,
06032 (void *)sequenceItem);
06033 if (cond != LST_NORMAL)
06034 return COND_PushCondition(DCM_LISTFAILURE,
06035 DCM_Message(DCM_LISTFAILURE), "readFile");
06036 if (size != (long) DCM_UNSPECIFIEDLENGTH)
06037 size -= sequenceLength;
06038 fileOffset += (off_t) sequenceLength;
06039 if (scannedLength != NULL)
06040 *scannedLength += sequenceLength;
06041 (*object)->objectSize += sequenceLength;
06042 if (localLength != DCM_UNSPECIFIEDLENGTH)
06043 localLength -= sequenceLength;
06044 ptr += sequenceLength;
06045 } else
06046 return cond;
06047 } else {
06048 sequenceDone = TRUE;
06049 }
06050 if (localLength == 0)
06051 sequenceDone = TRUE;
06052 }
06053 } else {
06054 pixelFlag = (e.tag == DCM_PXLPIXELDATA);
06055 cond = newElementItem(&e, (pixelFlag == FALSE), &elementItem);
06056 if (cond != DCM_NORMAL) {
06057 (void) DCM_CloseObject(callerObject);
06058 return cond;
06059 }
06060 if (pixelFlag) {
06061 if (fileFlag)
06062 *remainOpenFlag = TRUE;
06063 elementItem->byteOrder = byteOrder;
06064 elementItem->dataOffset = fileOffset;
06065 elementItem->currentOffset = 0;
06066 if (fileFlag)
06067 elementItem->element.d.ot = NULL;
06068 else
06069 elementItem->element.d.ot = (void *) ptr;
06070 if ((*object)->pixelBitsAllocated == 8)
06071 elementItem->element.representation = DCM_OB;
06072 else
06073 elementItem->element.representation = DCM_OW;
06074 if (fileFlag) {
06075 if (fd != -1) {
06076 (void) lseek(fd, (off_t) elementItem->element.length, SEEK_CUR);
06077 } else {
06078 (*object)->sk((*object)->userCtx,
06079 elementItem->element.length, SEEK_CUR);
06080 }
06081 (*object)->fd = fd;
06082 }
06083 } else {
06084 if (fileFlag) {
06085 if (fd != -1) {
06086 nBytes = read(fd, elementItem->element.d.ot,
06087 (int) elementItem->element.length);
06088 } else {
06089 cond = (*object)->rd((*object)->userCtx,
06090 elementItem->element.d.ot,
06091 (long) elementItem->element.length, &nBytes);
06092 }
06093 if (nBytes != (int) elementItem->element.length) {
06094 (void) DCM_CloseObject(callerObject);
06095 return COND_PushCondition(DCM_FILEACCESSERROR,
06096 DCM_Message(DCM_FILEACCESSERROR), name, "readFile");
06097 }
06098 } else {
06099 (void) memcpy(elementItem->element.d.ot, ptr,
06100 elementItem->element.length);
06101 ptr += elementItem->originalDataLength;
06102 }
06103
06104 if( LITTLE_ENDIAN_ARCHITECTURE ){
06105 if (elementItem->element.representation == DCM_AT)
06106 swapATGroupElement(&elementItem->element);
06107 }
06108 if (byteOrder != BYTEORDER_SAME)
06109 swapInPlace(object, &elementItem->element);
06110 if (convertFlag) {
06111 cond = verifyFormat(elementItem);
06112 if (cond != DCM_NORMAL)
06113 return cond;
06114 }
06115 }
06116 if (size != (long) DCM_UNSPECIFIEDLENGTH)
06117 size -= elementItem->originalDataLength;
06118 fileOffset += (off_t) elementItem->originalDataLength;
06119 if (scannedLength != NULL)
06120 (*scannedLength) += elementItem->originalDataLength;
06121
06122 elementItem->paddedDataLength = elementItem->element.length;
06123 if (elementItem->paddedDataLength & 1)
06124 elementItem->paddedDataLength += 1;
06125 (*object)->objectSize += elementItem->paddedDataLength;
06126 }
06127
06128 computeVM(object, &elementItem->element);
06129
06130 if ((long) DCM_TAG_GROUP(e.tag) == lastGroup) {
06131 if ((long) DCM_TAG_ELEMENT(e.tag) <= lastElement)
06132 return COND_PushCondition(DCM_ELEMENTOUTOFORDER,
06133 DCM_Message(DCM_ELEMENTOUTOFORDER),
06134 group, element, "readFile");
06135 } else if ((long) DCM_TAG_GROUP(e.tag) > lastGroup) {
06136 } else {
06137 return COND_PushCondition(DCM_ELEMENTOUTOFORDER,
06138 DCM_Message(DCM_ELEMENTOUTOFORDER), group, element,
06139 "readFile");
06140 }
06141 lastGroup = (long) group;
06142 lastElement = (long) element;
06143
06144 if (groupItem == NULL)
06145 createGroupFlag = TRUE;
06146 else if (groupItem->group != group)
06147 createGroupFlag = TRUE;
06148 else
06149 createGroupFlag = FALSE;
06150
06151 if (createGroupFlag == TRUE) {
06152 groupItem = CTN_MALLOC(sizeof(*groupItem));
06153 if (groupItem == NULL) {
06154 (void) DCM_CloseObject(callerObject);
06155 return COND_PushCondition(DCM_ELEMENTCREATEFAILED,
06156 DCM_Message(DCM_ELEMENTCREATEFAILED),
06157 "readFile",
06158 group, 0xffff, sizeof(*groupItem));
06159 }
06160 groupItem->group = group;
06161 groupItem->baseLength = 0;
06162 groupItem->longVRAttributes = 0;
06163 groupItem->elementList = LST_Create();
06164 if (groupItem->elementList == NULL) {
06165 (void) DCM_CloseObject(callerObject);
06166 return COND_PushCondition(DCM_LISTFAILURE,
06167 DCM_Message(DCM_LISTFAILURE),
06168 "readFile");
06169 }
06170 if (LST_Enqueue(&(*object)->groupList, (void *)groupItem) != LST_NORMAL) {
06171 (void) DCM_CloseObject(callerObject);
06172 return COND_PushCondition(DCM_LISTFAILURE,
06173 DCM_Message(DCM_LISTFAILURE),
06174 "readFile");
06175 }
06176 }
06177 if (element != 0x0000)
06178 groupItem->baseLength += 8 + elementItem->paddedDataLength;
06179 if ((element == 0x0000) && ((*object)->groupLengthFlag == FALSE)) {
06180 CTN_FREE(elementItem);
06181 } else {
06182 cond = LST_Enqueue(&groupItem->elementList, (void *)elementItem);
06183 if (cond != LST_NORMAL) {
06184 (void) DCM_CloseObject(callerObject);
06185 return COND_PushCondition(DCM_LISTFAILURE,
06186 DCM_Message(DCM_LISTFAILURE),
06187 "readFile");
06188 }
06189 cond = updateObjectType(object, &elementItem->element); /* repair */
06190
06191 cond = updateSpecialElements(object, elementItem); /* repair */
06192 }
06193
06194 if (size == 0)
06195 done = TRUE;
06196
06197 #ifdef DEBUG
06198 if (debug) {
06199 /*lint -e644 */
06200 (void) fprintf(stderr, "Address: %px Group %2x, element %2x, length %ld ",
06201 elementItem,
06202 DCM_TAG_GROUP(elementItem->element.tag),
06203 DCM_TAG_ELEMENT(elementItem->element.tag),
06204 elementItem->element.length);
06205 /*lint +e644 */
06206 (void) fprintf(stderr, "Object size: %d\n", (*object)->objectSize);
06207 }
06208 #endif
06209 }
06210
06211 groupItem = (void *)LST_Head(&(*object)->groupList);
06212 if (groupItem != NULL) {
06213 (void) LST_Position(&(*object)->groupList, (void *)groupItem);
06214 while (groupItem != NULL) {
06215 elementItem = (void *)LST_Head(&groupItem->elementList);
06216 if (elementItem != NULL) {
06217 if (DCM_TAG_ELEMENT(elementItem->element.tag) == 0x0000) {
06218 *elementItem->element.d.ul = groupItem->baseLength;
06219 }
06220 }
06221 groupItem = (void *)LST_Next(&(*object)->groupList);
06222 }
06223 }
06224 return DCM_NORMAL;
06225 }
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Definition at line 6930 of file mri_dicom_hdr.c. References PRV_GROUP_ITEM::baseLength, BIG_ORDER, checkAttributeOrder(), computeVM(), COND_PushCondition(), CONDITION, CTN_FREE, CTNBOOLEAN, DCM_ELEMENT::d, DCM_ACCEPTVRMISMATCH, DCM_ALLOWREPEATELEMENTS, DCM_CloseObject(), DCM_CONVERTMASK, DCM_CreateObject(), DCM_DELETEMASK, DCM_DELETEONCLOSE, DCM_DLMITEMDELIMITATIONITEM, DCM_DLMSEQUENCEDELIMITATIONITEM, DCM_EFILM, DCM_EXPLICITBIGENDIAN, DCM_EXPLICITLITTLEENDIAN, DCM_FILEFORMATMASK, DCM_FORMATCONVERSION, DCM_LISTFAILURE, DCM_MAKETAG, DCM_Message(), DCM_NORMAL, DCM_OB, DCM_OBJECT, DCM_ORDERBIGENDIAN, DCM_ORDERLITTLEENDIAN, DCM_ORDERMASK, DCM_ORDERNATIVE, DCM_OW, DCM_PART10FILE, DCM_PREAMBLELENGTH, DCM_REPEATEDELEMENT, DCM_REPEATELEMENTSMASK, DCM_SPECIALFORMATMASK, DCM_SQ, DCM_STREAMCOMPLETE, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UN, DCM_UNSPECIFIEDLENGTH, DCM_VRMASK, PRV_ELEMENT_ITEM::element, PRV_GROUP_ITEM::elementList, ENTRY, fd, handleGroupItem(), DCM_ELEMENT::length, LITTLE_ORDER, PRV_GROUP_ITEM::longVRAttributes, LST_Enqueue(), LST_Head(), LST_Next(), LST_NORMAL, LST_Position(), name, NATIVE_ORDER, object, offset, PRV_ELEMENT_ITEM::paddedDataLength, readData(), readGroupElement(), readPreamble(), readSequence(), readVRLength(), DCM_ELEMENT::representation, RETURN, STATUS, DCM_ELEMENT::tag, U32, updateObjectType(), and updateSpecialElements().
06938 {
06939 CONDITION
06940 cond;
06941 int
06942 byteOrder;
06943 long
06944 lastGroup = -1,
06945 lastElement = -1;
06946 U32
06947 sequenceLength,
06948 scannedSequenceLength;
06949 PRIVATE_OBJECT
06950 ** object;
06951 PRV_GROUP_ITEM
06952 * groupItem = NULL;
06953 DCM_ELEMENT
06954 e;
06955 CTNBOOLEAN
06956 convertFlag = FALSE,
06957 done = FALSE,
06958 knownLength = TRUE,
06959 explicitVR = FALSE,
06960 acceptVRMismatch = FALSE,
06961 part10Flag = FALSE;
06962 unsigned char
06963 *ptr = NULL;
06964 PRV_ELEMENT_ITEM
06965 * elementItem = NULL;
06966 CTNBOOLEAN
06967 fileFlag = TRUE;
06968 CONDITION flag;
06969 CTNBOOLEAN allowRepeatElements = FALSE;
06970
06971 ENTRY("readFile1") ;
06972
06973 ptr = callerBuf;
06974 if (ptr != NULL)
06975 fileFlag = FALSE;
06976
06977 if ((opt & DCM_FILEFORMATMASK) == DCM_PART10FILE) {
06978 part10Flag = TRUE;
06979 opt &= ~DCM_ORDERMASK;
06980 opt &= ~DCM_FILEFORMATMASK;
06981 opt |= DCM_EXPLICITLITTLEENDIAN;
06982 }
06983 if ((opt & DCM_SPECIALFORMATMASK) == DCM_EFILM) {
06984 part10Flag = TRUE;
06985 opt &= ~DCM_ORDERMASK;
06986 opt &= ~DCM_FILEFORMATMASK;
06987 opt |= DCM_ORDERLITTLEENDIAN;
06988 }
06989 if ((opt & DCM_REPEATELEMENTSMASK) == DCM_ALLOWREPEATELEMENTS) {
06990 allowRepeatElements = TRUE;
06991 }
06992
06993 switch (opt & DCM_ORDERMASK) {
06994 case DCM_ORDERNATIVE:
06995 byteOrder = NATIVE_ORDER;
06996 break;
06997 case DCM_ORDERLITTLEENDIAN:
06998 byteOrder = LITTLE_ORDER;
06999 break;
07000 case DCM_EXPLICITLITTLEENDIAN:
07001 byteOrder = LITTLE_ORDER;
07002 explicitVR = TRUE;
07003 break;
07004 case DCM_ORDERBIGENDIAN:
07005 byteOrder = BIG_ORDER;
07006 break;
07007 case DCM_EXPLICITBIGENDIAN:
07008 byteOrder = BIG_ORDER;
07009 explicitVR = TRUE;
07010 break;
07011 default:
07012 byteOrder = NATIVE_ORDER;
07013 break;
07014 }
07015 if ((opt & DCM_CONVERTMASK) == DCM_FORMATCONVERSION)
07016 convertFlag = TRUE;
07017 if ((opt & DCM_VRMASK) == DCM_ACCEPTVRMISMATCH)
07018 acceptVRMismatch = TRUE;
07019
07020 if (scannedLength != NULL)
07021 *scannedLength = 0;
07022
07023 cond = DCM_CreateObject(callerObject, opt);
07024 if (cond != DCM_NORMAL)
07025 RETURN( cond ) ;
07026
07027 object = (PRIVATE_OBJECT **) callerObject;
07028 if (fileFlag)
07029 strcpy((*object)->fileName, name);
07030
07031 (*object)->fd = -1;
07032 (*object)->rd = rd;
07033 (*object)->sk = sk;
07034 (*object)->userCtx = ctx;
07035 (*object)->dataOptions = 0;
07036 if (size == (long) DCM_UNSPECIFIEDLENGTH)
07037 knownLength = FALSE;
07038
07039 if ((fileFlag) && ((opt & DCM_DELETEMASK) == DCM_DELETEONCLOSE) && (recursionLevel == 0))
07040 (*object)->deleteFlag = TRUE;
07041
07042 if (parentObject != NULL)
07043 (*object)->pixelRepresentation = (*parentObject)->pixelRepresentation;
07044
07045 if (recursionLevel == 0 && part10Flag) {
07046 flag = readPreamble(name, &ptr, fd, &size, fileOffset, knownLength,
07047 object, scannedLength);
07048 if (flag != DCM_NORMAL)
07049 { STATUS("readPreamble fails"); goto abort; }
07050 }
07051 while (!done) {
07052 flag = readGroupElement(name, &ptr, fd, &size, fileOffset, knownLength,
07053 byteOrder, explicitVR, acceptVRMismatch, object,
07054 scannedLength, &e);
07055 if (flag == DCM_STREAMCOMPLETE)
07056 break;
07057 else if (flag != DCM_NORMAL)
07058 { STATUS("readGroupElement fails"); goto abort; }
07059 #if 0
07060 if (e.tag == DCM_MAKETAG(0x003a, 0x1000)) {
07061 fprintf(stderr, "Found waveform\n");
07062 }
07063 #endif
07064 flag = readVRLength(name, &ptr, fd, &size, fileOffset, knownLength,
07065 byteOrder, explicitVR, acceptVRMismatch, object,
07066 scannedLength, &e);
07067 if (flag != DCM_NORMAL)
07068 { STATUS("readVRLength fails"); goto abort; }
07069
07070 if ((e.representation == DCM_UN) &&
07071 (e.length == DCM_UNSPECIFIEDLENGTH)) {
07072 e.representation = DCM_SQ;
07073 }
07074 #ifndef SMM
07075 if ((e.tag == DCM_DLMITEMDELIMITATIONITEM) ||
07076 (e.tag == DCM_DLMSEQUENCEDELIMITATIONITEM)) {
07077 RETURN( DCM_NORMAL) ;
07078 }
07079 #else
07080 if (e.tag == DCM_DLMITEMDELIMITATIONITEM) {
07081 (*object)->objectSize -= 8;
07082 RETURN( DCM_NORMAL );
07083 }
07084 if (e.tag == DCM_DLMSEQUENCEDELIMITATIONITEM)
07085 RETURN( DCM_NORMAL );
07086 #endif
07087
07088 if (e.representation == DCM_SQ) {
07089 sequenceLength = e.length;
07090 scannedSequenceLength = 0;
07091 flag = readSequence(name, &ptr, fd, &sequenceLength,
07092 fileOffset, recursionLevel, opt,
07093 byteOrder, explicitVR, acceptVRMismatch,
07094 fileFlag, remainOpenFlag,
07095 convertFlag, object, &scannedSequenceLength,
07096 &e, &elementItem);
07097 if (flag != DCM_NORMAL)
07098 { STATUS("readSequence fails"); goto abort; }
07099 if (size != (long) DCM_UNSPECIFIEDLENGTH)
07100 size -= scannedSequenceLength;
07101 if (scannedLength != NULL)
07102 *scannedLength += scannedSequenceLength;
07103
07104 } else {
07105
07106 flag = readData(name, &ptr, fd, &size, fileOffset, knownLength,
07107 byteOrder, explicitVR, acceptVRMismatch, fileFlag,
07108 remainOpenFlag, convertFlag,
07109 object, scannedLength, &e, &elementItem);
07110 if (flag != DCM_NORMAL)
07111 { STATUS("readData fails"); goto abort; }
07112 }
07113 computeVM(object, &elementItem->element);
07114
07115 cond = checkAttributeOrder(&e, &lastGroup, &lastElement, allowRepeatElements);
07116 if (cond != DCM_NORMAL) {
07117 if (cond == DCM_REPEATEDELEMENT) {
07118 CTN_FREE(elementItem);
07119 continue;
07120 } else {
07121 CTN_FREE(elementItem); /* 22 June 2005 [rickr] */
07122 RETURN( cond ) ;
07123 }
07124 }
07125
07126 cond = handleGroupItem(object, &groupItem, DCM_TAG_GROUP(e.tag));
07127 if (cond != DCM_NORMAL)
07128 /* goto abort; ASG */ RETURN( cond );
07129
07130 if (DCM_TAG_ELEMENT(e.tag) != 0x0000) {
07131 groupItem->baseLength += 8 + elementItem->paddedDataLength;
07132 if (elementItem->element.representation == DCM_OB ||
07133 elementItem->element.representation == DCM_OW ||
07134 elementItem->element.representation == DCM_SQ) {
07135 groupItem->longVRAttributes++;
07136 (*object)->longVRAttributes++;
07137 }
07138 }
07139 if ((DCM_TAG_ELEMENT(e.tag) == 0x0000) && ((*object)->groupLengthFlag == FALSE)) {
07140 CTN_FREE(elementItem);
07141 } else {
07142 cond = LST_Enqueue(&groupItem->elementList, (void *)elementItem);
07143 if (cond != LST_NORMAL) {
07144 (void) DCM_CloseObject(callerObject);
07145 RETURN( COND_PushCondition(DCM_LISTFAILURE,
07146 DCM_Message(DCM_LISTFAILURE),
07147 "readFile") );
07148 }
07149 cond = updateObjectType(object, &elementItem->element); /* repair */
07150
07151 cond = updateSpecialElements(object, elementItem); /* repair */
07152 }
07153
07154 if (size == 0)
07155 done = TRUE;
07156
07157 if (part10Flag) {
07158 if ((*object)->objectSize == (DCM_PREAMBLELENGTH + 4 + 12 + (*object)->metaHeaderLength)) {
07159 opt &= ~DCM_ORDERMASK;
07160 opt |= (*object)->dataOptions & DCM_ORDERMASK;
07161 explicitVR = FALSE;
07162 switch (opt & DCM_ORDERMASK) {
07163 case DCM_ORDERNATIVE:
07164 byteOrder = NATIVE_ORDER;
07165 break;
07166 case DCM_ORDERLITTLEENDIAN:
07167 byteOrder = LITTLE_ORDER;
07168 break;
07169 case DCM_EXPLICITLITTLEENDIAN:
07170 byteOrder = LITTLE_ORDER;
07171 explicitVR = TRUE;
07172 break;
07173 case DCM_ORDERBIGENDIAN:
07174 byteOrder = BIG_ORDER;
07175 break;
07176 case DCM_EXPLICITBIGENDIAN:
07177 byteOrder = BIG_ORDER;
07178 explicitVR = TRUE;
07179 break;
07180 default:
07181 byteOrder = LITTLE_ORDER;
07182 explicitVR = TRUE;
07183 break;
07184 }
07185 }
07186 }
07187 }
07188
07189 #ifdef SMM
07190 #endif
07191
07192 groupItem = (void *)LST_Head(&(*object)->groupList);
07193 if (groupItem != NULL) {
07194 (void) LST_Position(&(*object)->groupList, (void *)groupItem);
07195 while (groupItem != NULL) {
07196 elementItem = (void *)LST_Head(&groupItem->elementList);
07197 if (elementItem != NULL) {
07198 if (DCM_TAG_ELEMENT(elementItem->element.tag) == 0x0000) {
07199 *elementItem->element.d.ul = groupItem->baseLength;
07200 }
07201 }
07202 groupItem = (void *)LST_Next(&(*object)->groupList);
07203 }
07204 }
07205 RETURN( DCM_NORMAL );
07206
07207 abort:
07208 RETURN (flag);
07209 }
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Definition at line 6285 of file mri_dicom_hdr.c. References BYTEORDER_SAME, COND_PopCondition(), COND_PushCondition(), CONDITION, CTNBOOLEAN, ctxSensitiveLookup(), DCM_CloseObject(), DCM_CTX, DCM_DumpElements(), DCM_FILEACCESSERROR, DCM_ILLEGALSTREAMLENGTH, DCM_LookupElement(), DCM_MAKETAG, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_STREAMCOMPLETE, fd, GET_SHORT_REVERSE_ORDER, GET_SHORT_SAME_ORDER, name, object, read(), DCM_ELEMENT::representation, DCM_ELEMENT::tag, and U32.
06290 {
06291 unsigned char *localPtr;
06292 unsigned char buf[4];
06293 int nBytes;
06294 CONDITION cond;
06295 unsigned short group,
06296 element;
06297
06298 if (*size == 0)
06299 return DCM_STREAMCOMPLETE;
06300
06301 if ((*size < 4) && knownLength) {
06302 if (debug)
06303 (void) DCM_DumpElements((DCM_OBJECT **) object, 0);
06304 (void) DCM_CloseObject((DCM_OBJECT **) object);
06305 return COND_PushCondition(DCM_ILLEGALSTREAMLENGTH,
06306 DCM_Message(DCM_ILLEGALSTREAMLENGTH), *size,
06307 "readFile");
06308 }
06309 if (*ptr == NULL) {
06310 if (fd != -1) {
06311 nBytes = read(fd, buf, 4);
06312 } else {
06313 cond = (*object)->rd((*object)->userCtx, buf, 4, &nBytes);
06314 }
06315
06316 if (nBytes != 4)
06317 return COND_PushCondition(DCM_FILEACCESSERROR,
06318 DCM_Message(DCM_FILEACCESSERROR), name,
06319 "readGroupElement");
06320 localPtr = buf;
06321 } else {
06322 localPtr = *ptr;
06323 }
06324
06325 if (knownLength)
06326 *size -= 4;
06327 *fileOffset += (off_t) 4;
06328 if (scannedLength != NULL)
06329 (*scannedLength) += 4;
06330 (*object)->objectSize += 4;
06331
06332 if (byteOrder == BYTEORDER_SAME) {
06333 GET_SHORT_SAME_ORDER(localPtr, group);
06334 GET_SHORT_SAME_ORDER(localPtr + 2, element);
06335 e->tag = DCM_MAKETAG(group, element);
06336 } else {
06337 GET_SHORT_REVERSE_ORDER(localPtr, group);
06338 GET_SHORT_REVERSE_ORDER(localPtr + 2, element);
06339 e->tag = DCM_MAKETAG(group, element);
06340 }
06341 if (*ptr != NULL)
06342 *ptr += 4;
06343
06344 if (debug)
06345 fprintf(stderr, "%04x %04x ", group, element);
06346
06347 cond = DCM_LookupElement(e);
06348 if (cond != DCM_NORMAL)
06349 (void) COND_PopCondition(0);
06350 if (e->representation == DCM_CTX)
06351 ctxSensitiveLookup(object, e);
06352
06353 return DCM_NORMAL;
06354 }
|
|
||||||||||||||||||||
|
Definition at line 7455 of file mri_dicom_hdr.c. References COND_PushCondition(), CONDITION, DCM_ELEMENT::d, DCM_CloseObject(), DCM_FILEACCESSERROR, DCM_GetElementValue(), DCM_ImportStream(), DCM_MAKETAG, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_UL, fd, fileName, read(), and U32.
07457 {
07458 unsigned char buf[24];
07459 DCM_OBJECT *obj;
07460 CONDITION cond;
07461 DCM_ELEMENT e = {DCM_MAKETAG(0x0008, 0x0001), DCM_UL, "", 1, 4, NULL};
07462 void *ctx = NULL;
07463 U32 rtnLength = 0;
07464
07465 if (read(fd, buf, 24) != 24)
07466 return COND_PushCondition(DCM_FILEACCESSERROR,
07467 DCM_Message(DCM_FILEACCESSERROR), fileName,
07468 "(DCM)readLengthToEnd");
07469
07470 cond = DCM_ImportStream(buf, 24, opt, &obj);
07471 if (cond != DCM_NORMAL)
07472 return cond;
07473
07474 e.d.ul = lengthToEnd;
07475 cond = DCM_GetElementValue(&obj, &e, &rtnLength, &ctx);
07476
07477 (void) DCM_CloseObject(&obj);
07478
07479 return cond;
07480 }
|
|
||||||||||||||||||||||||||||||||||||
|
Definition at line 6228 of file mri_dicom_hdr.c. References COND_PushCondition(), CONDITION, CTNBOOLEAN, DCM_CloseObject(), DCM_DumpElements(), DCM_FILEACCESSERROR, DCM_ILLEGALSTREAMLENGTH, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_PREAMBLELENGTH, DCM_STREAMCOMPLETE, fd, name, object, read(), and U32.
06231 {
06232 int nBytes,
06233 tmp;
06234 CONDITION cond;
06235 char label[4];
06236
06237 if (*size == 0)
06238 return DCM_STREAMCOMPLETE;
06239
06240 if ((*size < DCM_PREAMBLELENGTH + 4) && knownLength) {
06241 if (debug)
06242 (void) DCM_DumpElements((DCM_OBJECT **) object, 0);
06243 (void) DCM_CloseObject((DCM_OBJECT **) object);
06244 return COND_PushCondition(DCM_ILLEGALSTREAMLENGTH,
06245 DCM_Message(DCM_ILLEGALSTREAMLENGTH), *size,
06246 "readPreamble");
06247 }
06248 if (*ptr == NULL) {
06249 if (fd != -1) {
06250 nBytes = read(fd, (*object)->preamble, DCM_PREAMBLELENGTH);
06251 nBytes += read(fd, label, sizeof(label));
06252 } else {
06253 cond = (*object)->rd((*object)->userCtx, (*object)->preamble,
06254 DCM_PREAMBLELENGTH, &nBytes);
06255 cond = (*object)->rd((*object)->userCtx, label,
06256 sizeof(label), &tmp);
06257 nBytes += tmp;
06258 }
06259
06260 if (nBytes != DCM_PREAMBLELENGTH + sizeof(label))
06261 return COND_PushCondition(DCM_FILEACCESSERROR,
06262 DCM_Message(DCM_FILEACCESSERROR), name,
06263 "readPreamble");
06264 } else {
06265 (void) memcpy((*object)->preamble, *ptr, DCM_PREAMBLELENGTH);
06266 (void) memcpy(label, (*ptr) + DCM_PREAMBLELENGTH, sizeof(label));
06267 }
06268
06269 if (knownLength)
06270 *size -= DCM_PREAMBLELENGTH + sizeof(label);
06271 *fileOffset += (off_t) DCM_PREAMBLELENGTH + sizeof(label);
06272 if (*ptr != NULL)
06273 *ptr += DCM_PREAMBLELENGTH + sizeof(label);
06274 (*object)->objectSize += DCM_PREAMBLELENGTH + sizeof(label);
06275
06276 if (strncmp(label, "DICM", 4) != 0)
06277 return 0;
06278
06279 (*object)->preambleFlag = TRUE;
06280 return DCM_NORMAL;
06281 }
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Definition at line 6546 of file mri_dicom_hdr.c. References COND_PushCondition(), CONDITION, CTN_MALLOC, CTNBOOLEAN, DCM_DLMITEM, DCM_LISTFAILURE, DCM_MALLOCFAILURE, DCM_Message(), DCM_NORMAL, DCM_OBJECT, DCM_STREAMCOMPLETE, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UNSPECIFIEDLENGTH, fd, DCM_ELEMENT::length, LST_Create(), LST_Enqueue(), LST_NORMAL, name, newElementItem(), DCM_SEQUENCE_ITEM::object, object, readFile1(), readGroupElement(), readVRLength(), DCM_ELEMENT::tag, U32, and PRIVATE_OBJECT::userCtx.
06553 {
06554 CTNBOOLEAN knownLength = TRUE;
06555 CONDITION cond;
06556 U32 sequenceLength;
06557
06558 U32 localLength;
06559 CTNBOOLEAN sequenceDone;
06560 DCM_ELEMENT tagE;
06561 DCM_OBJECT
06562 * sequenceObject;
06563 DCM_SEQUENCE_ITEM *sequenceItem;
06564 CONDITION flag;
06565 unsigned char *localPtr;
06566 off_t itemTagOffset;
06567
06568 if (*size == (long) DCM_UNSPECIFIEDLENGTH)
06569 knownLength = FALSE;
06570
06571 cond = newElementItem(e, FALSE, elementItem);
06572 if (cond != DCM_NORMAL)
06573 return cond;
06574 (*elementItem)->element.d.sq = LST_Create();
06575 if ((*elementItem)->element.d.sq == NULL)
06576 return COND_PushCondition(DCM_LISTFAILURE,
06577 DCM_Message(DCM_LISTFAILURE), "readSequence");
06578
06579 localLength = (*elementItem)->element.length;
06580 sequenceDone = (localLength == 0);
06581
06582 while (!sequenceDone) {
06583 if (debug)
06584 fprintf(stderr, "Sequence Length: %d %x\n", localLength,
06585 localLength);
06586
06587 sequenceLength = 0;
06588 itemTagOffset = *fileOffset;
06589
06590 flag = readGroupElement(name, ptr, fd, &localLength, fileOffset, knownLength,
06591 byteOrder, explicitVR, acceptVRMismatch, object, &sequenceLength, &tagE);
06592 if (flag == DCM_STREAMCOMPLETE)
06593 break;
06594 else if (flag != DCM_NORMAL)
06595 return flag;
06596
06597 flag = readVRLength(name, ptr, fd, &localLength, fileOffset, knownLength,
06598 byteOrder, explicitVR, acceptVRMismatch, object,
06599 &sequenceLength, &tagE);
06600 if (flag != DCM_NORMAL)
06601 return flag;
06602
06603 if (*size != (long) DCM_UNSPECIFIEDLENGTH)
06604 *size -= sequenceLength;
06605 if (scannedLength != NULL)
06606 *scannedLength += sequenceLength;
06607
06608 sequenceLength = 0;
06609
06610
06611 if (debug)
06612 fprintf(stderr, "Sequence item: %4x %4x %d (%x)\n",
06613 DCM_TAG_GROUP(tagE.tag),
06614 DCM_TAG_ELEMENT(tagE.tag), tagE.length, tagE.length);
06615 if (tagE.tag == DCM_DLMITEM) {
06616 localPtr = *ptr;
06617 cond = readFile1(name,
06618 localPtr,
06619 fd, tagE.length,
06620 fileOffset, recursionLevel + 1, opt,
06621 object, &sequenceObject, &sequenceLength,
06622 remainOpenFlag, (*object)->userCtx, (*object)->rd,
06623 (*object)->sk);
06624 *ptr = localPtr;
06625 if (cond == DCM_NORMAL) {
06626 sequenceItem = CTN_MALLOC(sizeof(*sequenceItem));
06627 if (sequenceItem == NULL)
06628 return COND_PushCondition(DCM_MALLOCFAILURE,
06629 DCM_Message(DCM_MALLOCFAILURE),
06630 sizeof(*sequenceItem), "readFile");
06631
06632 ((PRIVATE_OBJECT *) sequenceObject)->offset = itemTagOffset;
06633 sequenceItem->object = sequenceObject;
06634 cond = LST_Enqueue(&(*elementItem)->element.d.sq,
06635 (void *)sequenceItem);
06636 if (cond != LST_NORMAL)
06637 return COND_PushCondition(DCM_LISTFAILURE,
06638 DCM_Message(DCM_LISTFAILURE), "readFile");
06639 if (*size != (long) DCM_UNSPECIFIEDLENGTH)
06640 *size -= sequenceLength;
06641 if (scannedLength != NULL)
06642 *scannedLength += sequenceLength;
06643 (*object)->objectSize += sequenceLength;
06644 if (localLength != DCM_UNSPECIFIEDLENGTH)
06645 localLength -= sequenceLength;
06646 } else
06647 return cond;
06648 } else {
06649 sequenceDone = TRUE;
06650 }
06651 if (localLength == 0)
06652 sequenceDone = TRUE;
06653 }
06654 return DCM_NORMAL;
06655 }
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Definition at line 6357 of file mri_dicom_hdr.c. References BYTEORDER_SAME, COND_PushCondition(), CONDITION, CTNBOOLEAN, DCM_CloseObject(), DCM_CTX, DCM_DLM, DCM_DumpElements(), DCM_ELEMENTLENGTHERROR, DCM_FILEACCESSERROR, DCM_ILLEGALSTREAMLENGTH, DCM_Message(), DCM_NORMAL, DCM_OB, DCM_OBJECT, DCM_OW, DCM_PXLPIXELDATA, DCM_RET, DCM_SQ, DCM_STREAMCOMPLETE, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UN, DCM_UNEVENELEMENTLENGTH, DCM_UNRECOGNIZEDVRCODE, DCM_UNSPECIFIEDLENGTH, DCM_UT, DCM_VRMISMATCH, DCM_ELEMENT::description, ENTRY, fd, GET_LONG_REVERSE_ORDER, GET_LONG_SAME_ORDER, GET_SHORT_REVERSE_ORDER, GET_SHORT_SAME_ORDER, DCM_ELEMENT::length, lookupVRCode(), mapVRtoASCII(), name, object, read(), VRMAP::representation, DCM_ELEMENT::representation, RETURN, rwc_err, STATUS, DCM_ELEMENT::tag, and U32.
06362 {
06363 unsigned char *localPtr;
06364 unsigned char buf[4];
06365 char vrCode[3];
06366 VRMAP *vrPtr;
06367 int nBytes;
06368 CONDITION cond;
06369 CTNBOOLEAN calculatedLength = FALSE;
06370
06371 ENTRY("readVRLength") ;
06372
06373 if (*size == 0)
06374 RETURN( DCM_STREAMCOMPLETE );
06375
06376 if ((*size < 4) && knownLength) {
06377 if (debug)
06378 (void) DCM_DumpElements((DCM_OBJECT **) object, 0);
06379 (void) DCM_CloseObject((DCM_OBJECT **) object);
06380 RETURN( COND_PushCondition(DCM_ILLEGALSTREAMLENGTH,
06381 DCM_Message(DCM_ILLEGALSTREAMLENGTH), *size,
06382 "readVRLength") );
06383 }
06384 if (*ptr == NULL) {
06385 if (fd != -1) {
06386 nBytes = read(fd, buf, 4);
06387 } else {
06388 cond = (*object)->rd((*object)->userCtx, buf, 4, &nBytes);
06389 }
06390
06391 if (nBytes != 4)
06392 RETURN( COND_PushCondition(DCM_FILEACCESSERROR,
06393 DCM_Message(DCM_FILEACCESSERROR), name,
06394 "readVRLength") ) ;
06395 localPtr = buf;
06396 } else
06397 localPtr = *ptr;
06398
06399 if (knownLength)
06400 *size -= 4;
06401 *fileOffset += (off_t) 4;
06402 if (scannedLength != NULL)
06403 (*scannedLength) += 4;
06404 (*object)->objectSize += 4;
06405
06406 e->length = 0;
06407 if (e->representation == DCM_DLM) {
06408 explicitVR = FALSE; /* Special rule for delimitors */
06409 }
06410 if (explicitVR) {
06411 vrCode[0] = buf[0];
06412 vrCode[1] = buf[1];
06413 vrCode[2] = '\0';
06414 vrPtr = lookupVRCode(vrCode);
06415 if (vrPtr == NULL){
06416 if( rwc_err ){
06417 fprintf(stderr,"** DICOM ERROR: unknown VR code %s in element (%04x,%04x)\n", /* RWC */
06418 vrCode,DCM_TAG_GROUP(e->tag), DCM_TAG_ELEMENT(e->tag) ) ; rwc_err-- ;
06419 }
06420 RETURN( COND_PushCondition(DCM_UNRECOGNIZEDVRCODE,
06421 DCM_Message(DCM_UNRECOGNIZEDVRCODE), vrCode,
06422 "readVRLength") );
06423 }
06424
06425 if (vrPtr->representation != e->representation) {
06426 if (vrPtr->representation == DCM_OB) {
06427 /* This is probably from the waveform supplement where they */
06428 /* transmit as OB and expect us to pull it out later */
06429 /* We will just keep our VR which was based on context in */
06430 /* the object */
06431 e->representation = vrPtr->representation;
06432 } else if (e->representation == DCM_UN ||
06433 e->representation == DCM_CTX ||
06434 e->representation == DCM_RET ||
06435 vrPtr->representation == DCM_OW ||
06436 acceptVRMismatch) { /* Believe input */
06437 e->representation = vrPtr->representation;
06438 } else {
06439 #if 0
06440 if (e->tag != DCM_PXLPIXELDATA){
06441 STATUS("VR mismatch") ;
06442 RETURN( COND_PushCondition(DCM_VRMISMATCH,
06443 DCM_Message(DCM_VRMISMATCH), vrCode, e->tag));
06444 }
06445 #else
06446 if( rwc_err ){
06447 fprintf(stderr,"++ DICOM WARNING: VR mismatch in element (%04x,%04x)\n", /* RWC */
06448 DCM_TAG_GROUP(e->tag), DCM_TAG_ELEMENT(e->tag) ) ; rwc_err-- ;
06449 }
06450 e->representation = vrPtr->representation;
06451 #endif
06452 }
06453 }
06454 if (vrPtr->representation != DCM_OW &&
06455 vrPtr->representation != DCM_OB &&
06456 vrPtr->representation != DCM_UN &&
06457 vrPtr->representation != DCM_UT &&
06458 vrPtr->representation != DCM_SQ) {
06459 unsigned short shortLength;
06460 if (byteOrder == BYTEORDER_SAME) {
06461 GET_SHORT_SAME_ORDER(localPtr + 2, shortLength);
06462 } else {
06463 GET_SHORT_REVERSE_ORDER(localPtr + 2, shortLength);
06464 }
06465 e->length = shortLength;
06466 if (*ptr != NULL)
06467 *ptr += 4;
06468 calculatedLength = TRUE;
06469 } else {
06470 if ((*size < 4) && knownLength) {
06471 if (debug)
06472 (void) DCM_DumpElements((DCM_OBJECT **) object, 0);
06473 (void) DCM_CloseObject((DCM_OBJECT **) object);
06474 RETURN( COND_PushCondition(DCM_ILLEGALSTREAMLENGTH,
06475 DCM_Message(DCM_ILLEGALSTREAMLENGTH), *size,
06476 "readVRLength"));
06477 }
06478 if (*ptr == NULL) {
06479 if (fd != -1) {
06480 nBytes = read(fd, buf, 4);
06481 } else {
06482 cond = (*object)->rd((*object)->userCtx, buf, 4, &nBytes);
06483 }
06484
06485 if (nBytes != 4)
06486 RETURN( COND_PushCondition(DCM_FILEACCESSERROR,
06487 DCM_Message(DCM_FILEACCESSERROR), name,
06488 "readVRLength"));
06489 localPtr = buf;
06490 } else
06491 localPtr = *ptr;
06492
06493 if (knownLength)
06494 *size -= 4;
06495 *fileOffset += (off_t) 4;
06496 if (scannedLength != NULL)
06497 (*scannedLength) += 4;
06498 (*object)->objectSize += 4;
06499 }
06500 }
06501 if (!calculatedLength) {
06502 if (byteOrder == BYTEORDER_SAME) {
06503 GET_LONG_SAME_ORDER(localPtr, e->length);
06504 } else {
06505 GET_LONG_REVERSE_ORDER(localPtr, e->length);
06506 }
06507 if (*ptr != NULL)
06508 *ptr += 4;
06509 }
06510 if (debug) {
06511 char localVR[10];
06512 mapVRtoASCII(e->representation, localVR);
06513 fprintf(stderr, "%2s %6d %06x %s\n", localVR, e->length,
06514 (unsigned int)*fileOffset, e->description);
06515 }
06516 if (((e->length & 1) != 0) && (e->length != DCM_UNSPECIFIEDLENGTH)) {
06517 if (debug)
06518 (void) DCM_DumpElements((DCM_OBJECT **) object, 0);
06519 (void) DCM_CloseObject((DCM_OBJECT **) object);
06520 if( rwc_err ){
06521 fprintf(stderr,"** DICOM ERROR: illegal odd length=%d in element (%04x,%04x)\n", /* RWC */
06522 e->length,DCM_TAG_GROUP(e->tag), DCM_TAG_ELEMENT(e->tag) ) ; rwc_err-- ;
06523 }
06524 RETURN( COND_PushCondition(DCM_UNEVENELEMENTLENGTH,
06525 DCM_Message(DCM_UNEVENELEMENTLENGTH),
06526 DCM_TAG_GROUP(e->tag), DCM_TAG_ELEMENT(e->tag),
06527 e->length, "readFile"));
06528 }
06529 if ((e->length != (U32) DCM_UNSPECIFIEDLENGTH) && (e->length > (U32) (*size))) {
06530 if (debug)
06531 (void) DCM_DumpElements((DCM_OBJECT **) object, 0);
06532 (void) DCM_CloseObject((DCM_OBJECT **) object);
06533 if( rwc_err ){
06534 fprintf(stderr,"** DICOM ERROR: oversize length=%d in element (%04x,%04x)\n", /* RWC */
06535 e->length,DCM_TAG_GROUP(e->tag), DCM_TAG_ELEMENT(e->tag) ) ; rwc_err-- ;
06536 }
06537 RETURN( COND_PushCondition(DCM_ELEMENTLENGTHERROR,
06538 DCM_Message(DCM_ELEMENTLENGTHERROR),
06539 DCM_TAG_GROUP(e->tag), DCM_TAG_ELEMENT(e->tag),
06540 e->length, *size, "readFile"));
06541 }
06542 RETURN( DCM_NORMAL);
06543 }
|
|
||||||||||||
|
Definition at line 7640 of file mri_dicom_hdr.c.
|
|
|
Definition at line 114 of file mri_dicom_hdr.c. References free, npbuf, and pbuf. Referenced by mri_dicom_header().
|
|
||||||||||||
|
Definition at line 119 of file mri_dicom_hdr.c. References AFMALL, AFREALL, npbuf, NPBUF, and pbuf.
00120 {
00121 static char *sbuf = NULL ;
00122 int nsbuf , nn , lpbuf ;
00123 va_list vararg_ptr ;
00124
00125 va_start( vararg_ptr , fmt ) ;
00126
00127 if( sbuf == NULL ) sbuf = AFMALL( char, NPBUF) ; /* 1st time in */
00128
00129 sbuf[0] = '\0' ;
00130 nn = vsprintf( sbuf , fmt , vararg_ptr ) ;
00131 va_end( vararg_ptr ) ;
00132 nsbuf = strlen(sbuf) ;
00133 if( nsbuf == 0 ) return(0);
00134
00135 if( npbuf == 0 ){
00136 pbuf = AFMALL(char,NPBUF) ; npbuf = NPBUF ; pbuf[0] = '\0' ;
00137 }
00138
00139 lpbuf = strlen(pbuf) ;
00140 if( lpbuf+nsbuf+8 > npbuf ){
00141 npbuf += NPBUF; pbuf = AFREALL( pbuf, char, npbuf);
00142 }
00143
00144 strcat(pbuf,sbuf) ;
00145 return(nn);
00146 }
|
|
|
Definition at line 86 of file mri_dicom_hdr.c. References BIG_ORDER, BYTEORDER_REVERSE, BYTEORDER_SAME, LITTLE_ENDIAN_ARCHITECTURE, and LITTLE_ORDER. Referenced by mri_dicom_header(), and mri_read_dicom().
00087 {
00088 union { unsigned char bb[2] ;
00089 short ss ; } fred ;
00090
00091 if( LITTLE_ENDIAN_ARCHITECTURE < 0 ){
00092 fred.bb[0] = 1 ; fred.bb[1] = 0 ;
00093
00094 LITTLE_ENDIAN_ARCHITECTURE = (fred.ss == 1) ;
00095
00096 if( LITTLE_ENDIAN_ARCHITECTURE ){
00097 LITTLE_ORDER = BYTEORDER_SAME ;
00098 BIG_ORDER = BYTEORDER_REVERSE ;
00099 } else {
00100 BIG_ORDER = BYTEORDER_SAME ;
00101 LITTLE_ORDER = BYTEORDER_REVERSE ;
00102 }
00103 }
00104 }
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Definition at line 6658 of file mri_dicom_hdr.c. References CONDITION, CTNBOOLEAN, DCM_DLMITEM, DCM_NORMAL, DCM_STREAMCOMPLETE, DCM_TAG_ELEMENT, DCM_TAG_GROUP, DCM_UNSPECIFIEDLENGTH, fd, DCM_ELEMENT::length, name, object, readGroupElement(), readVRLength(), DCM_ELEMENT::tag, and U32.
06666 {
06667 CTNBOOLEAN knownLength = TRUE;
06668 U32 sequenceLength;
06669 U32 scannedBytes = 0;
06670
06671 U32 localLength;
06672 CTNBOOLEAN sequenceDone;
06673 DCM_ELEMENT tagE;
06674 CONDITION flag;
06675 unsigned char *localPtr;
06676
06677 if (*size == (long) DCM_UNSPECIFIEDLENGTH)
06678 knownLength = FALSE;
06679
06680 localLength = (*elementItem)->element.length;
06681 sequenceDone = (localLength == 0);
06682
06683 while (!sequenceDone) {
06684 sequenceLength = 0;
06685 flag = readGroupElement(name, ptr, fd, &localLength, fileOffset,
06686 FALSE, byteOrder, explicitVR, acceptVRMismatch,
06687 object, &sequenceLength, &tagE);
06688 if (flag == DCM_STREAMCOMPLETE)
06689 break;
06690 else if (flag != DCM_NORMAL)
06691 return flag;
06692
06693 flag = readVRLength(name, ptr, fd, &localLength, fileOffset, knownLength,
06694 byteOrder, explicitVR, acceptVRMismatch, object,
06695 &sequenceLength, &tagE);
06696 if (flag != DCM_NORMAL)
06697 return flag;
06698
06699 if (*size != (long) DCM_UNSPECIFIEDLENGTH)
06700 *size -= sequenceLength;
06701 if (scannedLength != NULL)
06702 *scannedLength += sequenceLength;
06703 scannedBytes += sequenceLength;
06704
06705 if (debug)
06706 fprintf(stderr, "Sequence item: %4x %4x %d (%x)\n",
06707 DCM_TAG_GROUP(tagE.tag),
06708 DCM_TAG_ELEMENT(tagE.tag), tagE.length, tagE.length);
06709 if (tagE.tag == DCM_DLMITEM) {
06710 localPtr = *ptr;
06711 if (tagE.length != 0) {
06712 lseek(fd, tagE.length, SEEK_CUR);
06713 *fileOffset += tagE.length;
06714 if (*size != (long) DCM_UNSPECIFIEDLENGTH)
06715 *size -= tagE.length;
06716 if (scannedLength != NULL)
06717 *scannedLength += tagE.length;
06718 }
06719 } else {
06720 sequenceDone = TRUE;
06721 }
06722 if (localLength == 0)
06723 sequenceDone = TRUE;
06724
06725 if (debug)
06726 fprintf(stderr, "Scanned Bytes: %d\n", scannedBytes);
06727 }
06728 if ((scannedBytes & 1) != 0) {
06729 lseek(fd, 1, SEEK_CUR);
06730 *fileOffset += 1;
06731 if (*size != (long) DCM_UNSPECIFIEDLENGTH)
06732 *size -= 1;
06733 }
06734 return DCM_NORMAL;
06735 }
|
|
||||||||||||
|
Definition at line 5059 of file mri_dicom_hdr.c. References CONDITION, DCM_ELEMENT::d, DCM_ENCAPSULATEDPIXELS, DCM_EXPLICITBIGENDIAN, DCM_EXPLICITLITTLEENDIAN, DCM_METATRANSFERSYNTAX, DCM_NORMAL, DCM_OBJECT, DCM_ORDERLITTLEENDIAN, DCM_ParseObject(), DCM_UI, DICOM_TRANSFERBIGENDIANEXPLICIT, DICOM_TRANSFERLITTLEENDIAN, DICOM_TRANSFERLITTLEENDIANEXPLICIT, and DICOM_UI_LENGTH.
05060 {
05061 CONDITION cond;
05062 char xferSyntax[DICOM_UI_LENGTH + 1];
05063 DCM_ELEMENT e = {DCM_METATRANSFERSYNTAX, DCM_UI, "", 1, sizeof(xferSyntax),
05064 NULL};
05065
05066 e.d.string = xferSyntax;
05067 cond = DCM_ParseObject(obj, &e, 1, NULL, 0, NULL);
05068 if (cond != DCM_NORMAL)
05069 return cond;
05070
05071 *opt = 0;
05072 if (strcmp(xferSyntax, DICOM_TRANSFERLITTLEENDIAN) == 0) {
05073 *opt = DCM_ORDERLITTLEENDIAN;
05074 } else if (strcmp(xferSyntax, DICOM_TRANSFERLITTLEENDIANEXPLICIT) == 0) {
05075 *opt = DCM_EXPLICITLITTLEENDIAN;
05076 } else if (strcmp(xferSyntax, DICOM_TRANSFERBIGENDIANEXPLICIT) == 0) {
05077 *opt = DCM_EXPLICITBIGENDIAN;
05078 } else { /* Must be an encapsulated xfer syntax */
05079 *opt = DCM_ENCAPSULATEDPIXELS;
05080 }
05081
05082 return DCM_NORMAL;
05083 }
|
|
|
Definition at line 7483 of file mri_dicom_hdr.c. References DCM_ELEMENT::d, DCM_ELEMENT::length, and U32.
|
|
||||||||||||
|
Definition at line 4924 of file mri_dicom_hdr.c. References DCM_ELEMENT::d, DCM_AT, DCM_OW, DCM_PXLPIXELDATA, DCM_SL, DCM_SS, DCM_UL, DCM_US, DCM_ELEMENT::length, object, DCM_ELEMENT::representation, DCM_ELEMENT::tag, and U32.
04925 {
04926 U32
04927 length;
04928 unsigned char
04929 tmp,
04930 *p1;
04931
04932 length = e->length;
04933 p1 = e->d.ot;
04934 if (e->representation == DCM_US || e->representation == DCM_SS ||
04935 e->representation == DCM_OW || e->representation == DCM_AT) {
04936 if (e->tag == DCM_PXLPIXELDATA &&
04937 (*object)->pixelBitsAllocated != 16)
04938 return;
04939
04940 while (length > 0) {
04941 tmp = p1[0];
04942 p1[0] = p1[1];
04943 p1[1] = tmp;
04944 p1 += 2;
04945 length -= 2;
04946 }
04947 } else if (e->representation == DCM_UL || e->representation == DCM_SL) {
04948 while (length > 0) {
04949 tmp = p1[0];
04950 p1[0] = p1[3];
04951 p1[3] = tmp;
04952 tmp = p1[1];
04953 p1[1] = p1[2];
04954 p1[2] = tmp;
04955 length -= 4;
04956 p1 += 4;
04957 }
04958 }
04959 }
|
|
||||||||||||
|
Definition at line 4040 of file mri_dicom_hdr.c. References DCM_GROUPCOMMAND, DCM_NORMAL, DCM_OBJECTCOMMAND, DCM_OBJECTELEMENTLIST, DCM_OBJECTIMAGE, DCM_OBJECTUNKNOWN, DCM_TAG_GROUP, object, and DCM_ELEMENT::tag.
04041 {
04042 switch ((*object)->objectType) {
04043 case DCM_OBJECTUNKNOWN:
04044 if (DCM_TAG_GROUP(element->tag) == DCM_GROUPCOMMAND)
04045 (*object)->objectType = DCM_OBJECTCOMMAND;
04046 else
04047 (*object)->objectType = DCM_OBJECTELEMENTLIST;
04048 break;
04049 case DCM_OBJECTCOMMAND:
04050 if (DCM_TAG_GROUP(element->tag) != DCM_GROUPCOMMAND)
04051 (*object)->objectType = DCM_OBJECTELEMENTLIST;
04052 break;
04053 case DCM_OBJECTELEMENTLIST:
04054 case DCM_OBJECTIMAGE:
04055 break;
04056 default:
04057 break;
04058 }
04059 return DCM_NORMAL;
04060 }
|
|
||||||||||||
|
Definition at line 4083 of file mri_dicom_hdr.c. References DCM_ELEMENT::d, DCM_EXPLICITBIGENDIAN, DCM_EXPLICITLITTLEENDIAN, DCM_IMGBITSALLOCATED, DCM_IMGPIXELREPRESENTATION, DCM_MAKETAG, DCM_METAGROUPLENGTH, DCM_METATRANSFERSYNTAX, DCM_NORMAL, DCM_ORDERLITTLEENDIAN, DICOM_TRANSFERBIGENDIANEXPLICIT, DICOM_TRANSFERLITTLEENDIAN, DICOM_TRANSFERLITTLEENDIANEXPLICIT, PRV_ELEMENT_ITEM::element, idx, DCM_ELEMENT::length, object, and DCM_ELEMENT::tag.
04085 {
04086 int idx;
04087
04088 switch (item->element.tag) {
04089 case DCM_IMGBITSALLOCATED:
04090 (*object)->pixelBitsAllocated = *item->element.d.us;
04091 break;
04092 case DCM_IMGPIXELREPRESENTATION:
04093 (*object)->pixelRepresentation = *item->element.d.us;
04094 break;
04095 case DCM_METAGROUPLENGTH:
04096 (*object)->metaHeaderLength = *item->element.d.ul;
04097 break;
04098 case DCM_METATRANSFERSYNTAX:
04099 if (strcmp(item->element.d.string, DICOM_TRANSFERLITTLEENDIAN) == 0) {
04100 (*object)->dataOptions = DCM_ORDERLITTLEENDIAN;
04101 } else if (strcmp(item->element.d.string, DICOM_TRANSFERLITTLEENDIANEXPLICIT) == 0) {
04102 (*object)->dataOptions = DCM_EXPLICITLITTLEENDIAN;
04103 } else if (strcmp(item->element.d.string, DICOM_TRANSFERBIGENDIANEXPLICIT) == 0) {
04104 (*object)->dataOptions = DCM_EXPLICITBIGENDIAN;
04105 } else { /* Must be an encapsulated transfer syntax */
04106 (*object)->dataOptions = DCM_EXPLICITLITTLEENDIAN;
04107 }
04108 break;
04109 case DCM_MAKETAG(0x003a, 0x0103):
04110 strncpy((*object)->waveformDataVR, item->element.d.string,
04111 item->element.length);
04112 (*object)->waveformDataVR[item->element.length] = '\0';
04113 idx = item->element.length - 1;
04114 while (idx >= 0 && (*object)->waveformDataVR[idx] == ' ') {
04115 (*object)->waveformDataVR[idx] = '\0';
04116 idx--;
04117 }
04118 break;
04119 default:
04120 break;
04121 }
04122 return DCM_NORMAL;
04123 }
|
|
|
Definition at line 11482 of file mri_dicom_hdr.c.
11483 {
11484
11485 char
11486 year[5],
11487 month[3],
11488 day[3];
11489
11490 strncpy(year, date, 4);
11491 year[4] = '\000';
11492 strncpy(month, date + 4, 2);
11493 month[2] = '\000';
11494 strncpy(day, date + 6, 2);
11495 day[2] = '\000';
11496
11497 return ((atol(year) * 10000) + (atol(month) * 100) + atol(day));
11498 }
|
|
||||||||||||
|
Definition at line 11607 of file mri_dicom_hdr.c. References dt.
11608 {
11609 int
11610 hour,
11611 minute,
11612 second,
11613 fracsec;
11614
11615 hour = (int) (dt / 3600.0);
11616 dt -= (hour * 3600);
11617
11618 minute = (int) (dt / 60.);
11619 dt -= (minute * 60);
11620
11621 second = (int) dt;
11622 dt -= second;
11623
11624 fracsec = (int) ((dt * 1000000) + 0.5);
11625
11626 sprintf(time, "%02d%02d%02d.%06d", hour, minute, second, fracsec);
11627
11628 return;
11629 }
|
|
||||||||||||
|
Definition at line 11504 of file mri_dicom_hdr.c.
11505 {
11506
11507 int
11508 year,
11509 month,
11510 day;
11511
11512 year = ld / 10000;
11513 ld -= (year * 10000);
11514 month = ld / 100;
11515 ld -= (month * 100);
11516 day = ld;
11517
11518 sprintf(date, "%04d%02d%02d", year, month, day);
11519
11520 return;
11521 }
|
|
|
Definition at line 11527 of file mri_dicom_hdr.c.
11528 {
11529
11530 size_t
11531 i;
11532 char
11533 hour[3],
11534 minute[3],
11535 second[3],
11536 fracsec[7];
11537 const char *p;
11538 double
11539 divisor,
11540 hh,
11541 mm,
11542 ss,
11543 fs;
11544
11545 hh = mm = ss = fs = 0.0;
11546 hour[0] = minute[0] = second[0] = fracsec[0] = '\000';
11547
11548 p = time;
11549 /*
11550 * Just a brute force way to tear down a Dicom time...not very pretty,
11551 * but it works... We are not guaranteed to have every field present as
11552 * we are in the date...
11553 */
11554 hour[0] = *p++;
11555 hour[1] = *p++;
11556 hour[2] = '\000';
11557 if (isdigit(*p)) {
11558 minute[0] = *p++;
11559 minute[1] = *p++;
11560 minute[2] = '\000';
11561 if (isdigit(*p)) {
11562 second[0] = *p++;
11563 second[1] = *p++;
11564 second[2] = '\000';
11565 if (*p == '.') {
11566 p++;
11567 fracsec[0] = *p++;
11568 if ((*p != '\000') && (isdigit(*p))) {
11569 fracsec[1] = *p++;
11570 if ((*p != '\000') && (isdigit(*p))) {
11571 fracsec[2] = *p++;
11572 if ((*p != '\000') && (isdigit(*p))) {
11573 fracsec[3] = *p++;
11574 if ((*p != '\000') && (isdigit(*p))) {
11575 fracsec[4] = *p++;
11576 if ((*p != '\000') && (isdigit(*p))) {
11577 fracsec[5] = *p++;
11578 fracsec[6] = '\000';
11579 } else
11580 fracsec[5] = '\000';
11581 } else
11582 fracsec[4] = '\000';
11583 } else
11584 fracsec[3] = '\000';
11585 } else
11586 fracsec[2] = '\000';
11587 } else
11588 fracsec[1] = '\000';
11589 }
11590 }
11591 }
11592 hh = atof(hour);
11593 mm = atof(minute);
11594 ss = atof(second);
11595 divisor = 1;
11596 for (i = 0; i < strlen(fracsec); i++)
11597 divisor *= 10;
11598 fs = atof(fracsec) / divisor;
11599
11600 return ((hh * 3600.0) + (mm * 60.0) + ss + fs);
11601 }
|
|
||||||||||||
|
Definition at line 11659 of file mri_dicom_hdr.c. References free, malloc, UTL_ConvertDatetoLong(), and UTL_SqueezeBlanks().
11660 {
11661
11662 int
11663 match;
11664 char
11665 *ndate;
11666 long
11667 start_date,
11668 end_date,
11669 date_in_question;
11670
11671 if ((ndate = (char *) malloc(strlen(datestring) + 1)) == (char *) NULL)
11672 return (UTL_NOMATCH);
11673
11674 strcpy(ndate, datestring);
11675 UTL_SqueezeBlanks(ndate);
11676 UTL_SqueezeBlanks(stm);
11677
11678 match = 0;
11679 if (strchr(ndate, (int) '-') == (char *) NULL) {
11680 if (strcmp(ndate, stm) == 0)
11681 match = 1;
11682 } else {
11683 date_in_question = UTL_ConvertDatetoLong(stm);
11684 if (ndate[0] == '-') {
11685 end_date = UTL_ConvertDatetoLong(ndate + 1);
11686 if (date_in_question <= end_date)
11687 match = 1;
11688 } else if (ndate[strlen(ndate) - 1] == '-') {
11689 start_date = UTL_ConvertDatetoLong(ndate);
11690 if (date_in_question >= start_date)
11691 match = 1;
11692 } else {
11693 start_date = UTL_ConvertDatetoLong(ndate);
11694 end_date = UTL_ConvertDatetoLong(strchr(ndate, (int) '-') + 1);
11695 if ((date_in_question >= start_date) &&
11696 (date_in_question <= end_date))
11697 match = 1;
11698 }
11699 }
11700 free(ndate);
11701 if (match)
11702 return (UTL_MATCH);
11703 else
11704 return (UTL_NOMATCH);
11705 }
|
|
|
Definition at line 11826 of file mri_dicom_hdr.c.
11827 {
11828 struct timeval timeNow;
11829 UTL_TIMESTRUCTURE *t;
11830 double delta = 0.;
11831
11832 gettimeofday(&timeNow, NULL);
11833
11834 t = (UTL_TIMESTRUCTURE *) timeStamp;
11835 if (t == NULL)
11836 return -1.0;
11837
11838 if (strcmp(t->key, "UTL STAMP") != 0)
11839 return -1.0;
11840
11841 delta = timeNow.tv_sec - t->t.tv_sec;
11842 delta += (timeNow.tv_usec - t->t.tv_usec) / 1000000.;
11843
11844 return delta;
11845 }
|
|
|
Definition at line 11762 of file mri_dicom_hdr.c.
11763 {
11764
11765 struct tm
11766 *tf;
11767 time_t
11768 loctime;
11769
11770 loctime = time((time_t *) NULL);
11771 tf = localtime(&loctime);
11772
11773 sprintf(datestr, "%04d%02d%02d", (tf->tm_year) + 1900, (tf->tm_mon) + 1, tf->tm_mday);
11774 return;
11775
11776 }
|
|
|
Definition at line 11782 of file mri_dicom_hdr.c.
11783 {
11784
11785 struct tm
11786 *tf;
11787 time_t
11788 loctime;
11789
11790 loctime = time((time_t *) NULL);
11791 tf = localtime(&loctime);
11792
11793 sprintf(timestr, "%02d%02d%02d.%06d", (tf->tm_hour), (tf->tm_min), (tf->tm_sec), 0);
11794 return;
11795 }
|
|
|
Definition at line 11810 of file mri_dicom_hdr.c. References AFMALL, UTL_TIMESTRUCTURE::key, and UTL_TIMESTRUCTURE::t.
11811 {
11812 UTL_TIMESTRUCTURE *t;
11813
11814 t = AFMALL( UTL_TIMESTRUCTURE, sizeof(*t));
11815 if (t == NULL)
11816 return NULL;
11817
11818 strcpy(t->key, "UTL STAMP");
11819
11820 gettimeofday(&t->t, NULL);
11821
11822 return t;
11823 }
|
|
|
Definition at line 11953 of file mri_dicom_hdr.c. References CTNBOOLEAN, i, and S_ISDIR.
11954 {
11955 int i;
11956 #ifdef _MSC_VER
11957 struct _stat buf;
11958 #else
11959 struct stat buf;
11960 #endif
11961
11962 int flag = 0;
11963
11964 #ifdef _MSC_VER
11965 i = _stat(path, &buf);
11966 #else
11967 i = stat(path, &buf);
11968 #endif
11969
11970
11971 if (i == 0) {
11972 #ifdef _MSC_VER
11973 flag = ((buf.st_mode & _S_IFDIR) != 0);
11974 #else
11975 flag = (S_ISDIR(buf.st_mode));
11976 #endif
11977 if (flag)
11978 return TRUE;
11979 }
11980 return FALSE;
11981 }
|
|
|
Definition at line 11848 of file mri_dicom_hdr.c. References free, and UTL_TIMESTRUCTURE::key.
11849 {
11850 UTL_TIMESTRUCTURE *t;
11851
11852 t = (UTL_TIMESTRUCTURE *) timeStamp;
11853 if (t == NULL)
11854 return;
11855
11856 if (strcmp(t->key, "UTL STAMP") != 0)
11857 return;
11858
11859 free(timeStamp);
11860 }
|
|
|
Definition at line 11636 of file mri_dicom_hdr.c.
11637 {
11638
11639 char
11640 *t1,
11641 *t2;
11642
11643 t1 = t2 = s;
11644 while (*t2 != '\000') {
11645 if (*t2 != ' ') {
11646 *t1 = *t2;
11647 t1++;
11648 }
11649 t2++;
11650 }
11651 *t1 = '\000';
11652
11653 return;
11654 }
|
|
||||||||||||
|
Definition at line 11710 of file mri_dicom_hdr.c. References free, malloc, UTL_ConvertTimetoFloat(), and UTL_SqueezeBlanks().
11711 {
11712
11713 int
11714 match;
11715 char
11716 *ntime;
11717 double
11718 start_time,
11719 end_time,
11720 time_in_question;
11721
11722 if ((ntime = (char *) malloc(strlen(timestring) + 2)) == (char *) NULL)
11723 return (UTL_NOMATCH);
11724
11725 strcpy(ntime, timestring);
11726 UTL_SqueezeBlanks(ntime);
11727 UTL_SqueezeBlanks(stm);
11728
11729 match = 0;
11730 if (strchr(ntime, (int) '-') == (char *) NULL) {
11731 if (strcmp(ntime, stm) == 0)
11732 match = 1;
11733 } else {
11734 time_in_question = UTL_ConvertTimetoFloat(stm);
11735 if (ntime[0] == '-') {
11736 end_time = UTL_ConvertTimetoFloat(ntime + 1);
11737 if (time_in_question <= end_time)
11738 match = 1;
11739 } else if (ntime[strlen(ntime) - 1] == '-') {
11740 start_time = UTL_ConvertTimetoFloat(ntime);
11741 if (time_in_question >= start_time)
11742 match = 1;
11743 } else {
11744 start_time = UTL_ConvertTimetoFloat(ntime);
11745 end_time = UTL_ConvertTimetoFloat(strchr(ntime, (int) '-') + 1);
11746 if ((time_in_question >= start_time) &&
11747 (time_in_question <= end_time))
11748 match = 1;
11749 }
11750 }
11751 free(ntime);
11752 if (match)
11753 return (UTL_MATCH);
11754 else
11755 return (UTL_NOMATCH);
11756 }
|
|
|
Definition at line 11863 of file mri_dicom_hdr.c. References i, p, S_ISDIR, UTL_FILECREATEFAILED, UTL_NORMAL, and UTL_PATHNOTDIR.
11864 {
11865 int i;
11866 #ifdef _MSC_VER
11867 struct _stat buf;
11868 #else
11869 struct stat buf;
11870 #endif
11871 char
11872 *p,
11873 temp[1024];
11874 int flag = 0;
11875 static int statCount = 0;
11876
11877 #ifdef _MSC_VER
11878 statCount++;
11879 i = _stat(path, &buf);
11880 #else
11881 i = stat(path, &buf);
11882 #endif
11883
11884
11885 if (i == 0) {
11886 #ifdef _MSC_VER
11887 flag = ((buf.st_mode & _S_IFDIR) != 0);
11888 #else
11889 flag = (S_ISDIR(buf.st_mode));
11890 #endif
11891 if (flag)
11892 return UTL_NORMAL;
11893 else
11894 return UTL_PATHNOTDIR;
11895 }
11896 p = temp;
11897
11898 while (*path != '\0') {
11899 *p++ = *path++;
11900 while (*path != '/' && *path != '\\' && *path != '\0') {
11901 #ifdef _MSC_VER
11902 if (*path == ':') {
11903 *p++ = *path++;
11904 if (*path == '\0') /* We should not get C:\0, but test
11905 * it */
11906 break;
11907 }
11908 #endif
11909 *p++ = *path++;
11910 }
11911
11912 *p = '\0';
11913 #ifdef _MSC_VER
11914 statCount++;
11915 i = _stat(temp, &buf);
11916 #else
11917 i = stat(temp, &buf);
11918 #endif
11919
11920 if (i == 0) {
11921 #ifdef _MSC_VER
11922 flag = ((buf.st_mode & _S_IFDIR) != 0);
11923 #else
11924 flag = (S_ISDIR(buf.st_mode));
11925 #endif
11926 if (!flag)
11927 return UTL_PATHNOTDIR;
11928 } else {
11929 #ifdef _MSC_VER
11930 int e1;
11931 e1 = errno;
11932 memset(&buf, 0, sizeof(buf));
11933 /*fprintf(stderr, "Stat Count = %d\n", statCount);*/
11934 statCount++;
11935 i = _stat(temp, &buf);
11936 e1 = errno;
11937 i = _mkdir(temp);
11938 #else
11939 i = mkdir(temp, 0777);
11940 #endif
11941 if (i != 0) {
11942 int e1;
11943 e1 = errno;
11944 fprintf(stderr, "Stat Count = %d\n", statCount);
11945 perror(temp);
11946 return UTL_FILECREATEFAILED;
11947 }
11948 }
11949 }
11950 return UTL_NORMAL;
11951 }
|
|
|
Definition at line 5528 of file mri_dicom_hdr.c. References CTNBOOLEAN, DCM_ELEMENT::d, DCM_AS, DCM_CS, DCM_DA, DCM_DS, DCM_IS, DCM_LO, DCM_LT, DCM_NORMAL, DCM_PN, DCM_SH, DCM_ST, DCM_TM, DCM_UI, DCM_UT, PRV_ELEMENT_ITEM::element, i, l, DCM_ELEMENT::length, p, PRV_ELEMENT_ITEM::paddedDataLength, and DCM_ELEMENT::representation.
05529 {
05530 int
05531 i,
05532 l;
05533 char
05534 *src,
05535 *dst,
05536 *p;
05537 DCM_ELEMENT
05538 * element;
05539 CTNBOOLEAN
05540 stopFlag = FALSE;
05541
05542 element = &item->element;
05543 if (element->length > 0) {
05544 switch (element->representation) {
05545 case DCM_DA:
05546 src = dst = element->d.string;
05547 l = (int) element->length;
05548 for (i = 0; i < l; i++) {
05549 if (isdigit(*src) || (*src == '-') || (*src == '\\')) {
05550 *dst++ = *src++;
05551 } else {
05552 src++;
05553 element->length--;
05554 }
05555 }
05556 item->paddedDataLength = element->length;
05557 if (element->length & 1) {
05558 *dst = ' ';
05559 item->paddedDataLength++;
05560 }
05561 break;
05562 case DCM_TM:
05563 l = (int) element->length;
05564 src = dst = element->d.string;
05565 for (i = 0; i < l; i++) {
05566 if (isdigit(*src) || (*src == '.') || (*src == '-') || (*src == '\\')) {
05567 *dst++ = *src++;
05568 } else {
05569 src++;
05570 element->length--;
05571 }
05572 }
05573 item->paddedDataLength = element->length;
05574 if (element->length & 1) {
05575 *dst = ' ';
05576 item->paddedDataLength++;
05577 }
05578 break;
05579 /*
05580 * Both the leading and trailing spaces are non-significant.
05581 */
05582 case DCM_CS:
05583 case DCM_AS:
05584 case DCM_DS:
05585 case DCM_IS:
05586 case DCM_LO:
05587 case DCM_SH:
05588 case DCM_UT:
05589 l = (int) element->length;
05590 src = dst = element->d.string;
05591 for (i = 0; i < l; i++) {
05592 if ((*src == ' ') && !stopFlag) {
05593 src++;
05594 element->length--;
05595 } else {
05596 stopFlag = TRUE;
05597 *dst++ = *src++;
05598 }
05599 }
05600 /*
05601 * Right now, dst points to the char follows the last char in the
05602 * string.
05603 */
05604 stopFlag = FALSE;
05605 l = (int) element->length;
05606 p = dst - 1;
05607 for (i = l; (i > 0) && !stopFlag; i--) {
05608 if ((*p == ' ') && !stopFlag) {
05609 p--;
05610 dst--;
05611 element->length--;
05612 } else
05613 stopFlag = TRUE;
05614 }
05615 item->paddedDataLength = element->length;
05616 if (element->length & 1) {
05617 *dst = ' ';
05618 item->paddedDataLength++;
05619 }
05620 break;
05621 /*
05622 * The trailing spaces are non-significant.
05623 */
05624 case DCM_LT:
05625 case DCM_ST:
05626 l = (int) element->length;
05627 src = element->d.string + l - 1;
05628 for (i = l; (i > 0) && !stopFlag; i--) {
05629 if ((*src == ' ') && !stopFlag) {
05630 src--;
05631 element->length--;
05632 } else
05633 stopFlag = TRUE;
05634 }
05635 item->paddedDataLength = element->length;
05636 if (element->length & 1) {
05637 *++src = ' ';
05638 item->paddedDataLength++;
05639 }
05640 break;
05641 case DCM_PN:
05642 /*
05643 * Strip off the trailing spaces.
05644 */
05645 l = (int) element->length;
05646 src = element->d.string + l - 1;
05647 for (i = l; (i > 0) && !stopFlag; i--) {
05648 if ((*src == ' ') && !stopFlag) {
05649 src--;
05650 element->length--;
05651 } else
05652 stopFlag = TRUE;
05653 }
05654 /*
05655 * Convert the name to the standard V3 format.
05656 */
05657 src = dst = element->d.string;
05658 l = element->length;
05659 for (i = 0; i < l;) {
05660 if ((src[i] == ',') || (src[i] == '^')) {
05661 *dst++ = '^';
05662 i++;
05663 while ((i < l) && (src[i] == ' ')) {
05664 element->length--;
05665 i++;
05666 }
05667 } else {
05668 *dst++ = src[i++];
05669 }
05670 }
05671
05672 item->paddedDataLength = element->length;
05673 if (element->length & 1) {
05674 *dst = ' ';
05675 item->paddedDataLength++;
05676 }
05677 break;
05678 case DCM_UI:
05679 if (element->d.string[element->length - 1] == '\0')
05680 element->length--;
05681 if (element->d.string[element->length - 1] == ' ') {
05682 element->d.string[element->length - 1] = '\0';
05683 element->length--;
05684 }
05685 break;
05686 default:
05687 break;
05688 }
05689 }
05690 return DCM_NORMAL;
05691 }
|
|
||||||||||||||||||||
|
Definition at line 5027 of file mri_dicom_hdr.c. References COND_PushCondition(), DCM_FILEIOERROR, DCM_Message(), DCM_NORMAL, fd, strerror(), U32, and write(). Referenced by DCM_WriteFile().
05029 {
05030 int
05031 bytesWritten;
05032 int *fd;
05033
05034 fd = (int *) fdPtr;
05035
05036 bytesWritten = write(*fd, buffer, (int) length);
05037 if (bytesWritten != (int) length)
05038 return COND_PushCondition(DCM_FILEIOERROR,
05039 DCM_Message(DCM_FILEIOERROR), "", strerror(errno),
05040 "writeFile");
05041 else
05042 return DCM_NORMAL;
05043 }
|
Variable Documentation
|
|
Definition at line 8658 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_BABGROUPLENGTH, DCM_UL, "BAB Group Length"},
{DCM_BABANNOTATIONPOSITION, DCM_US, "BAB posn of the annot. box in parent film box"},
{DCM_BABTEXTSTRING, DCM_LO, "BAB text string"}
}Definition at line 9685 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_DIRFILESETID, DCM_CS, "DIR File-set ID"},
{DCM_DIRFILESETDESCRFILEID, DCM_CS, "DIR File-set descriptor ID"},
{DCM_DIRSPECIFICCHARACTER, DCM_CS, "DIR Specific character set"},
{DCM_DIRFIRSTOFFSET, DCM_UL, "DIR Offset of the first dir of root dir entity"},
{DCM_DIRLASTOFFSET, DCM_UL, "DIR Offset of the last dir of root dir entity"},
{DCM_DIRFILESETCONSISTENCY, DCM_US, "DIR File-set consistency flag"},
{DCM_DIRRECORDSEQUENCE, DCM_SQ, "DIR Directory record sequence"},
{DCM_DIRNEXTRECORDOFFSET, DCM_UL, "DIR Offset of next directory record"},
{DCM_DIRRECORDINUSE, DCM_US, "DIR Record in use flag"},
{DCM_DIRLOWERLEVELOFFSET, DCM_UL, "DIR Offset of referenced lower-level dir entity"},
{DCM_DIRRECORDTYPE, DCM_CS, "DIR Directory Record Type"},
{DCM_DIRPRIVATERECORDUID, DCM_UI, "DIR Private Record UID"},
{DCM_DIRREFERENCEDFILEID, DCM_CS, "DIR Referenced File ID"},
{DCM_DIRMRDRRECORDOFFSET, DCM_UL, "DIR Directory Record Offset"},
{DCM_DIRREFSOPCLASSUID, DCM_UI, "DIR Referenced SOP Class UID in File"},
{DCM_DIRREFSOPINSTANCEUID, DCM_UI, "DIR Referenced SOP Instance UID in File"},
{DCM_DIRREFTRANSFERSYNTAXUID, DCM_UI, "DIR Referenced Transfer Syntax in File"},
{DCM_DIRNUMREFERENCES, DCM_UL, "DIR Number of References"}
}Definition at line 8470 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_BFBGROUPLENGTH, DCM_UL, "BFB Group Length"},
{DCM_BFBIMAGEDISPLAYFORMAT, DCM_ST, "BFB Type of image display format"},
{DCM_BFBANNOTATIONDISPLAYFORMAT, DCM_CS, "BFB Id of annotation display format"},
{DCM_BFBFILMORIENTATION, DCM_CS, "BFB Film orientation"},
{DCM_BFBFILMSIZEID, DCM_CS, "BFB Film size identification"},
{DCM_BFBMAGNIFICATIONTYPE, DCM_CS, "BFB Interpol. type by which printer mag image"},
{DCM_BFBSMOOTHINGTYPE, DCM_CS, "BFB Specifies type of interpolation function"},
{DCM_BFBBORDERDENSITY, DCM_CS, "BFB density of film areas around/between images"},
{DCM_BFBEMPTYIMAGEDENSITY, DCM_CS, "BFB density of image box area having no image"},
{DCM_BFBMINDENSITY, DCM_US, "BFB Minimum density of images on the film"},
{DCM_BFBMAXDENSITY, DCM_US, "BFB Maximum density of images on the film"},
{DCM_BFBTRIM, DCM_CS, "BFB specifies whether to trim or not"},
{DCM_BFBCONFIGURATIONINFO, DCM_ST, "BFB ID of configuration table"},
{DCM_BFBREFBASICFILMSESSIONSEQ, DCM_SQ, "BFB seq. of film session instance"},
{DCM_BFBREFBASICIMAGEBOXSEQ, DCM_SQ, "BFB seq. of basic image box SOP instance"},
{DCM_BFBREFBASICANNOTBOXSEQ, DCM_SQ, "BFB seq. of basic annotation box SOP instance"},
}Definition at line 9651 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_BFSGROUPLENGTH, DCM_UL, "BFS Group Length"},
{DCM_BFSCOPIES, DCM_IS, "BFS Number of copies printed for each film"},
{DCM_BFSPRINTPRIORITY, DCM_CS, "BFS Specifies priority of print job"},
{DCM_BFSMEDIUMTYPE, DCM_CS, "BFS Medium on which page will be printed"},
{DCM_BFSFILMDESTINATION, DCM_CS, "BFS Film destination"},
{DCM_BFSFILMSESSIONLABEL, DCM_LO, "BFS Human readable label to identify film"},
{DCM_BFSMEMORYALLOCATION, DCM_IS, "BFS Amount of mem allocated for film session"},
{DCM_BFSREFERENCEDFILMBOXSEQ, DCM_SQ, "BFS seq of UIDs of diff FILMBOX instances"}
}Definition at line 9638 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_BIBGROUPLENGTH, DCM_UL, "BIB Group Length"},
{DCM_BIBIMAGEPOSITION, DCM_US, "BIB Specifies position of the image in the film"},
{DCM_BIBPOLARITY, DCM_CS, "BIB Specifies image polarity"},
{DCM_BIBREQUESTEDIMAGESIZE, DCM_DS, "BIB Requested image size"},
{DCM_BIBPREFORMATGREYSCALEIMAGESEQ, DCM_SQ, "BIB Preformatted Greyscale image"},
{DCM_BIBPREFORMATCOLORIMAGESEQ, DCM_SQ, "BIB Preformatted Color image"},
{DCM_BIBREFIMAGEOVERLAYBOXSEQ, DCM_SQ, "BIB Referenced Image Overlay Box seq"},
{DCM_BIBREFVOILUTSEQ, DCM_SQ, "BIB Referenced VOI LUT seq."}
}Definition at line 9672 of file mri_dicom_hdr.c. |
|
|
Definition at line 83 of file mri_dicom_hdr.c. Referenced by DCM_GetCompressedValue(), exportStream(), extractFileOptions(), readFile(), readFile1(), and RWC_set_endianosity(). |
|
|
Definition at line 4436 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_CMDGROUPLENGTH, DCM_UL, "CMD Group Length"},
{DCM_CMDAFFECTEDCLASSUID, DCM_UI, "CMD Affected SOP Class UID"},
{DCM_CMDREQUESTEDCLASSUID, DCM_UI, "CMD Requested SOP Class UID"},
{DCM_CMDCOMMANDFIELD, DCM_US, "CMD Command Field"},
{DCM_CMDMSGID, DCM_US, "CMD Message ID"},
{DCM_CMDMSGIDRESPOND, DCM_US, "CMD Message ID Responded to"},
{DCM_CMDMOVEDESTINATION, DCM_AE, "CMD Move Destination"},
{DCM_CMDPRIORITY, DCM_US, "CMD Priority"},
{DCM_CMDDATASETTYPE, DCM_US, "CMD Data Set Type"},
{DCM_CMDSTATUS, DCM_US, "CMD Status"},
{DCM_CMDOFFENDINGELEMENT, DCM_AT, "CMD Offending Element"},
{DCM_CMDERRORCOMMENT, DCM_LO, "CMD Error Comment"},
{DCM_CMDERRORID, DCM_US, "CMD Error ID"},
{DCM_CMDREQUESTEDINSTANCEUID, DCM_UI, "CMD SOP Requested Instance UID"},
{DCM_CMDAFFECTEDINSTANCEUID, DCM_UI, "CMD SOP Affected Instance UID"},
{DCM_CMDEVENTTYPEID, DCM_US, "CMD Event Type ID"},
{DCM_CMDACTIONTYPEID, DCM_US, "CMD Action Type ID"},
{DCM_CMDREMAININGSUBOPERATIONS, DCM_US, "CMD Remaining Suboperations"},
{DCM_CMDCOMPLETEDSUBOPERATIONS, DCM_US, "CMD Completed Suboperations"},
{DCM_CMDFAILEDSUBOPERATIONS, DCM_US, "CMD Failed Suboperations"},
{DCM_CMDWARNINGSUBOPERATIONS, DCM_US, "CMD Warning Suboperations"},
{DCM_CMDMOVEAETITLE, DCM_AE, "CMD AE Title"},
{DCM_CMDMOVEMESSAGEID, DCM_US, "CMD Message ID"},
{DCM_CMDATTRIBUTEIDLIST, DCM_AT, "CMD Attribute Identifier List"},
}Definition at line 8424 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_CURVEGROUPLENGTH, DCM_UL, "CRV Group Length"},
{DCM_CURVEDIMENSIONS, DCM_US, "CRV Curve Dimensions"},
{DCM_CURVENUMBEROFPOINTS, DCM_US, "CRV Number of points"},
{DCM_CURVETYPEOFDATA, DCM_CS, "CRV Type of Data"},
{DCM_CURVEDESCRIPTION, DCM_LO, "CRV Curve Description"},
{DCM_CURVEAXISUNITS, DCM_SH, "CRV Axis Units"},
{DCM_CURVEAXISLABELS, DCM_SH, "CRV Axis Labels"},
{DCM_CURVEDATAVALUEREPRESENTATION, DCM_US, "CRV Data Value Representation"},
{DCM_CURVEMINCOORDINATEVALUE, DCM_US, "CRV Minimum Coordinate Value"},
{DCM_CURVEMAXCOORDINATEVALUE, DCM_US, "CRV Maximum Coordinate Value"},
{DCM_CURVERANGE, DCM_SH, "CRV Curve Range"},
{DCM_CURVEDATADESCRIPTOR, DCM_US, "CRV Data Descriptor"},
{DCM_CURVECOORDINATESTARTVALUE, DCM_US, "CRV Coordinate Start Value"},
{DCM_CURVECOORDINATESTEPVALUE, DCM_US, "CRV Coordinate Step Value"},
{DCM_CURVEAUDIOTYPE, DCM_US, "CRV Audio Type"},
{DCM_CURVEAUDIOSAMPLEFORMAT, DCM_US, "CRV Audio Sample Format"},
{DCM_CURVENUMBEROFCHANNELS, DCM_US, "CRV Number of Channels"},
{DCM_CURVENUMBEROFSAMPLES, DCM_UL, "CRV Number of Samples"},
{DCM_CURVESAMPLERATE, DCM_UL, "CRV Sample Rate"},
{DCM_CURVETOTALTIME, DCM_UL, "CRV Total Time"},
{DCM_CURVEAUDIOSAMPLEDATA, DCM_OW, "CRV Audio Sample Data"},
{DCM_CURVEAUDIOCOMMENTS, DCM_LT, "CRV Audio Comments"},
{DCM_CURVELABEL, DCM_LO, "CRV Curve Label"},
{DCM_CURVEREFOVERLAYSEQUENCE, DCM_SQ, "CRV Referenced Overlay Sequence"},
{DCM_CURVEREFOVERLAYGROUP, DCM_US, "CRV Referenced Overlay Group"},
{DCM_CURVEDATA, DCM_OW, "CRV Curve Data"}
}Definition at line 9438 of file mri_dicom_hdr.c. |
|
|
Definition at line 864 of file mri_dicom_hdr.c. Referenced by DCM_Debug(). |
|
|
Initial value: {
{DCM_DEVCALIBRATIONOBJECT, DCM_CS, "DEV Calibration Object"},
{DCM_DEVDEVICESEQUENCE, DCM_SQ, "DEV Device Sequence"},
{DCM_DEVDEVICELENGTH, DCM_DS, "DEV Device Length"},
{DCM_DEVDEVICEDIAMETER, DCM_DS, "DEV Device Diameter"},
{DCM_DEVDEVICEDIAMETERUNITS, DCM_CS, "DEV Device Diameter Units"},
{DCM_DEVDEVICEVOLUME, DCM_DS, "DEV Device Volume"},
{DCM_DEVINTERMARKERDISTANCE, DCM_DS, "DEV Inter-Marker Distance"},
{DCM_DEVDEVICEDESCRIPTION, DCM_LO, "DEV Device Description"},
}Definition at line 9393 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_DLMITEM, DCM_DLM, "DELIMITER Item"},
{DCM_DLMITEMDELIMITATIONITEM, DCM_DLM, "DELIMITER Item Delimitation Item"},
{DCM_DLMSEQUENCEDELIMITATIONITEM, DCM_DLM, "DELIMITER Sequence Delimitation Item"}
}Definition at line 10128 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_MAKETAG(0x3004, 0x0000), DCM_UL, "DVH Group Length"},
{DCM_MAKETAG(0x3004, 0x0001), DCM_CS, "DVH Type"},
{DCM_MAKETAG(0x3004, 0x0002), DCM_CS, "DVH Dose Units"},
{DCM_MAKETAG(0x3004, 0x0004), DCM_CS, "DVH Dose Type"},
{DCM_MAKETAG(0x3004, 0x0006), DCM_LO, "DVH Dose Comment"},
{DCM_MAKETAG(0x3004, 0x0008), DCM_DS, "DVH Normalization Point"},
{DCM_MAKETAG(0x3004, 0x000a), DCM_CS, "DVH Dose Summation Type"},
{DCM_MAKETAG(0x3004, 0x000c), DCM_DS, "DVH Grid Frame Offset Vector"},
{DCM_MAKETAG(0x3004, 0x000e), DCM_DS, "DVH Dose Grid Scaling"},
{DCM_MAKETAG(0x3004, 0x0010), DCM_SQ, "DVH RT Dose ROI Sequence"},
{DCM_MAKETAG(0x3004, 0x0012), DCM_DS, "DVH Dose Value"},
{DCM_MAKETAG(0x3004, 0x0040), DCM_DS, "DVH Normalization Point"},
{DCM_MAKETAG(0x3004, 0x0042), DCM_DS, "DVH Normalization Dose Value"},
{DCM_MAKETAG(0x3004, 0x0050), DCM_SQ, "DVH Sequence"},
{DCM_MAKETAG(0x3004, 0x0052), DCM_DS, "DVH Dose Scaling"},
{DCM_MAKETAG(0x3004, 0x0054), DCM_CS, "DVH Volume Units"},
{DCM_MAKETAG(0x3004, 0x0056), DCM_IS, "DVH Number of Bins"},
{DCM_MAKETAG(0x3004, 0x0058), DCM_DS, "DVH Data"},
{DCM_MAKETAG(0x3004, 0x0060), DCM_SQ, "DVH Referenced ROI Sequence"},
{DCM_MAKETAG(0x3004, 0x0062), DCM_CS, "DVH ROI Contribution Type"},
{DCM_MAKETAG(0x3004, 0x0070), DCM_DS, "DVH Minimum Dose"},
{DCM_MAKETAG(0x3004, 0x0072), DCM_DS, "DVH Maximum Dose"},
{DCM_MAKETAG(0x3004, 0x0074), DCM_DS, "DVH Mean Dose"}
}Definition at line 9762 of file mri_dicom_hdr.c. |
|
|
Definition at line 355 of file mri_dicom_hdr.c. |
|
|
Definition at line 356 of file mri_dicom_hdr.c. Referenced by COND_EstablishCallback(), and COND_PushCondition(). |
|
|
Initial value: {
{DCM_MAKETAG(0x3002, 0x0000), DCM_UL, "RT Group Length"},
{DCM_MAKETAG(0x3002, 0x0002), DCM_SH, "RT Image Label"},
{DCM_MAKETAG(0x3002, 0x0003), DCM_LO, "RT Image Name"},
{DCM_MAKETAG(0x3002, 0x0004), DCM_ST, "RT Image Description"},
{DCM_MAKETAG(0x3002, 0x000a), DCM_CS, "RT Reported Values Origin"},
{DCM_MAKETAG(0x3002, 0x000c), DCM_CS, "RT Image Plane"},
{DCM_MAKETAG(0x3002, 0x000e), DCM_DS, "RT X-Ray Image Receptor Angle"},
{DCM_MAKETAG(0x3002, 0x0010), DCM_DS, "RT Image Orientation"},
{DCM_MAKETAG(0x3002, 0x0011), DCM_DS, "RT Image Plane Pixel Spacing"},
{DCM_MAKETAG(0x3002, 0x0012), DCM_DS, "RT Image Position"},
{DCM_MAKETAG(0x3002, 0x0020), DCM_SH, "RT Radiation Machine Name"},
{DCM_MAKETAG(0x3002, 0x0022), DCM_DS, "RT Radiation Machine SAD"},
{DCM_MAKETAG(0x3002, 0x0024), DCM_DS, "RT Radiation Machine SSD"},
{DCM_MAKETAG(0x3002, 0x0026), DCM_DS, "RT Image SID"},
{DCM_MAKETAG(0x3002, 0x0028), DCM_DS, "RT Source to Reference Object Distance"},
{DCM_MAKETAG(0x3002, 0x0029), DCM_IS, "RT Fraction Number"},
{DCM_MAKETAG(0x3002, 0x0030), DCM_SQ, "RT Exposure Sequence"},
{DCM_MAKETAG(0x3002, 0x0032), DCM_DS, "RT Meterset Exposure"}
}Definition at line 9738 of file mri_dicom_hdr.c. |
|
|
Definition at line 9841 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_MAKETAG(0x300c, 0x0000), DCM_UL, " Group Length"},
{DCM_MAKETAG(0x300c, 0x0002), DCM_SQ, " Referenced RT Plan Sequence"},
{DCM_MAKETAG(0x300c, 0x0004), DCM_SQ, " Referenced Beam Sequence"},
{DCM_MAKETAG(0x300c, 0x0006), DCM_IS, " Referenced Beam Number"},
{DCM_MAKETAG(0x300c, 0x0007), DCM_IS, " Referenced Reference Image Number"},
{DCM_MAKETAG(0x300c, 0x0008), DCM_DS, " Start Cumulative Meterset Weight"},
{DCM_MAKETAG(0x300c, 0x0009), DCM_DS, " End Cumulative Meterset Weight"},
{DCM_MAKETAG(0x300c, 0x000a), DCM_SQ, " Referenced Brachy Application Setup Seq"},
{DCM_MAKETAG(0x300c, 0x000c), DCM_IS, " Referenced Brachy Application Setup Number"},
{DCM_MAKETAG(0x300c, 0x000e), DCM_IS, " Referenced Source Number"},
{DCM_MAKETAG(0x300c, 0x0020), DCM_SQ, " Referenced Fraction Group Sequence"},
{DCM_MAKETAG(0x300c, 0x0022), DCM_IS, " Referenced Fraction Group Number"},
{DCM_MAKETAG(0x300c, 0x0040), DCM_SQ, " Referenced Verification Image Sequence"},
{DCM_MAKETAG(0x300c, 0x0042), DCM_SQ, " Referenced Reference Image Sequence"},
{DCM_MAKETAG(0x300c, 0x0050), DCM_SQ, " Referenced Dose Reference Sequence"},
{DCM_MAKETAG(0x300c, 0x0051), DCM_IS, " Referenced Dose Reference Numer"},
{DCM_MAKETAG(0x300c, 0x0055), DCM_SQ, " Brachy Referenced Dose Reference Sequence"},
{DCM_MAKETAG(0x300c, 0x0060), DCM_SQ, " Referenced Structure Set Sequence"},
{DCM_MAKETAG(0x300c, 0x006a), DCM_IS, " Referenced Patient Setup Number"},
{DCM_MAKETAG(0x300c, 0x0080), DCM_SQ, " Referenced Dose Sequence"},
{DCM_MAKETAG(0x300c, 0x00a0), DCM_IS, " Referenced Tolerance Table Number"},
{DCM_MAKETAG(0x300c, 0x00b0), DCM_SQ, " Referenced Bolus Sequence"},
{DCM_MAKETAG(0x300c, 0x00c0), DCM_IS, " Referenced Wedge Number"},
{DCM_MAKETAG(0x300c, 0x00d0), DCM_IS, " Referenced Compensator Number"},
{DCM_MAKETAG(0x300c, 0x00e0), DCM_IS, " Referenced Block Number"},
{DCM_MAKETAG(0x300c, 0x00f0), DCM_IS, " Referenced Control Point Index"}
}Definition at line 10071 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_MAKETAG(0x300e, 0x0000), DCM_UL, " Group Length"},
{DCM_MAKETAG(0x300e, 0x0002), DCM_CS, " Approval Status"},
{DCM_MAKETAG(0x300e, 0x0004), DCM_DA, " Review Date"},
{DCM_MAKETAG(0x300e, 0x0005), DCM_TM, " Review Time"},
{DCM_MAKETAG(0x300e, 0x0008), DCM_PN, " Reviewer Name"}
}Definition at line 10103 of file mri_dicom_hdr.c. |
|
|
Definition at line 10138 of file mri_dicom_hdr.c. |
|
|
Referenced by exportData(). |
|
|
Definition at line 10315 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_MAKETAG(0x0070, 0x0000), DCM_UL, "GRP Group Length"},
{DCM_MAKETAG(0x0070, 0x0022), DCM_FL, "GRP Graphic Data"},
{DCM_MAKETAG(0x0070, 0x0023), DCM_CS, "GRP Graphic Type"},
{DCM_MAKETAG(0x0070, 0x0024), DCM_CS, "GRP Graphic Filled"},
{DCM_MAKETAG(0x0070, 0x0041), DCM_CS, "GRP Image Horizontal Flip"},
{DCM_MAKETAG(0x0070, 0x0042), DCM_US, "GRP Image Rotation"},
{DCM_MAKETAG(0x0070, 0x0052), DCM_SL, "GRP Displayed Area Top LH Corner"},
{DCM_MAKETAG(0x0070, 0x0053), DCM_SL, "GRP Displayed Area Bottom RH Corner"},
{DCM_MAKETAG(0x0070, 0x005a), DCM_SQ, "GRP Display Area Selection Seq"},
{DCM_MAKETAG(0x0070, 0x0060), DCM_SQ, "GRP Graphic Layer Sequence"},
{DCM_MAKETAG(0x0070, 0x0062), DCM_IS, "GRP Graphic Layer Order"},
{DCM_MAKETAG(0x0070, 0x0066), DCM_US, "GRP Graphic Layer Rec Disp GS Val"},
{DCM_MAKETAG(0x0070, 0x0067), DCM_US, "GRP Graphic Layer Rec Disp RGB Val"},
{DCM_MAKETAG(0x0070, 0x0068), DCM_LO, "GRP Graphic Layer Description"},
{DCM_MAKETAG(0x0070, 0x0080), DCM_CS, "GRP Presentation Label"},
{DCM_MAKETAG(0x0070, 0x0081), DCM_LO, "GRP Presentation Description"},
{DCM_MAKETAG(0x0070, 0x0082), DCM_DA, "GRP Presentation Creation Date"},
{DCM_MAKETAG(0x0070, 0x0083), DCM_TM, "GRP Presentation Creation Time"},
{DCM_MAKETAG(0x0070, 0x0084), DCM_PN, "GRP Presentation Creators Name"},
{DCM_MAKETAG(0x0070, 0x0100), DCM_CS, "GRP Presentation Size Mode"},
{DCM_MAKETAG(0x0070, 0x0101), DCM_DS, "GRP Presentation Pixel Spacing"},
{DCM_MAKETAG(0x0070, 0x0102), DCM_IS, "GRP Presentation Pixel Aspect Ratio"},
{DCM_MAKETAG(0x0070, 0x0103), DCM_FL, "GRP Presentation Pixel Magnification Ratio"},
}Definition at line 9556 of file mri_dicom_hdr.c. |
|
|
Definition at line 8493 of file mri_dicom_hdr.c. |
|
|
Definition at line 9015 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_IOBGROUPLENGTH, DCM_UL, "IOB Group Length"},
{DCM_IOBREFOVERLAYPLANESEQ, DCM_SQ, "IOB Ref Overlay Plane Sequence"},
{DCM_IOBREFOVERLAYPLANEGROUPS, DCM_US, "IOB Ref Overlay Plane Groups"},
{DCM_IOBOVERLAYMAGNIFICATIONTYPE, DCM_CS, "IOB Overlay Magnification Type"},
{DCM_IOBOVERLAYSMOOTHINGTYPE, DCM_CS, "IOB Overlay Smoothing Type"},
{DCM_IOBOVERLAYFOREGROUNDDENSITY, DCM_CS, "IOB Overlay Foreground Density"},
{DCM_IOBOVERLAYMODE, DCM_CS, "IOB Overlay Mode"},
{DCM_IOBTHRESHOLDDENSITY, DCM_CS, "IOB Threshold Density"},
{DCM_IOBREFIMAGEBOXSEQUENCE, DCM_SQ, "IOB Ref Image Box Sequence (RET)"}
}Definition at line 9693 of file mri_dicom_hdr.c. |
|
|
Definition at line 84 of file mri_dicom_hdr.c. Referenced by RWC_set_endianosity(). |
|
|
Definition at line 82 of file mri_dicom_hdr.c. Referenced by DCM_GetCompressedValue(), exportEncapsulatedPixels(), exportStream(), extractFileOptions(), readFile(), readFile1(), and RWC_set_endianosity(). |
|
|
Initial value: {
{DCM_MEDIAGROUPLENGTH, DCM_UL, "MED Media Group Length "},
{DCM_MEDIASTORAGEFILESETID, DCM_SH, "MED Storage Media File-set ID"},
{DCM_MEDIASTORAGEFILESETUID, DCM_UI, "MED Storage Media File-setUID"},
{DCM_MEDIAICONIMAGE, DCM_SQ, "MED Icon Image Sequence"},
{DCM_MEDIATOPICTITLE, DCM_LO, "MED Topic Title"},
{DCM_MEDIATOPICSUBJECT, DCM_ST, "MED Topic Subject"},
{DCM_MEDIATOPICAUTHOR, DCM_LO, "MED Topic Author"},
{DCM_MEDIATOPICKEYWORD, DCM_LO, "MED Topic Keywords"}
}Definition at line 9625 of file mri_dicom_hdr.c. |
|
|
Definition at line 8243 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_METAGROUPLENGTH, DCM_UL, "META Group Length"},
{DCM_METAINFORMATIONVERSION, DCM_OB, "META File Meta Information Version"},
{DCM_METAMEDIASTORAGESOPCLASS, DCM_UI, "META Media Stored SOP Class UID"},
{DCM_METAMEDIASTORAGESOPINSTANCE, DCM_UI, "META Media Stored SOP Instance UID"},
{DCM_METATRANSFERSYNTAX, DCM_UI, "META Transfer Syntax UID"},
{DCM_METAIMPLEMENTATIONCLASS, DCM_UI, "META Implementation Class UID"},
{DCM_METAIMPLEMENTATIONVERSION, DCM_SH, "META Implementation Version Name"},
{DCM_METASOURCEAETITLE, DCM_AE, "META Source Application Entity Title"},
{DCM_METAPRIVATEINFORMATIONCREATOR, DCM_UI, "META Private Information Creator"},
{DCM_METAPRIVATEINFORMATION, DCM_OB, "META Private Information"}
}Definition at line 8455 of file mri_dicom_hdr.c. |
|
|
Definition at line 9468 of file mri_dicom_hdr.c. |
|
|
Definition at line 110 of file mri_dicom_hdr.c. Referenced by RWC_clear_pbuf(), and RWC_printf(). |
|
|
Definition at line 9584 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_PADITEM, DCM_OB, "Pad item"}
}Definition at line 10121 of file mri_dicom_hdr.c. |
|
|
Definition at line 8619 of file mri_dicom_hdr.c. |
|
|
Definition at line 109 of file mri_dicom_hdr.c. Referenced by mri_dicom_header(), RWC_clear_pbuf(), and RWC_printf(). |
|
|
Initial value: {
{DCM_PJGROUPLENGTH, DCM_UL, "PJ Group Length"},
{DCM_PJEXECUTIONSTATUS, DCM_CS, "PJ execution status of print job"},
{DCM_PJEXECUTIONSTATUSINFO, DCM_CS, "PJ additional information"},
{DCM_PJCREATIONDATE, DCM_DA, "PJ date of print job creation"},
{DCM_PJCREATIONTIME, DCM_TM, "PJ time of print job creation"},
{DCM_PJORIGINATOR, DCM_AE, "PJ Appln entity title that issued the print opn"},
{DCM_PJREFPRINTJOBSEQ, DCM_SQ, "PJ Referenced print job seq."}
}Definition at line 9716 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_MAKETAG(0x2050, 0x0000), DCM_UL, "PLUT Group Length"},
{DCM_MAKETAG(0x2050, 0x0010), DCM_SQ, "PLUT Presentation LUT Sequence"},
{DCM_MAKETAG(0x2050, 0x0020), DCM_CS, "PLUT Presentation LUT Shape"},
{DCM_MAKETAG(0x2050, 0x0500), DCM_SQ, "PLUT Referenced Presentation LUT Sequence"}
}Definition at line 9707 of file mri_dicom_hdr.c. |
|
|
Definition at line 9205 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_PRINTERGROUPLENGTH, DCM_UL, "PRINTER Group Length"},
{DCM_PRINTERSTATUS, DCM_CS, "PRINTER printer device status"},
{DCM_PRINTERSTATUSINFO, DCM_CS, "PRINTER additional information"},
{DCM_PRINTERNAME, DCM_LO, "PRINTER printer name"},
{DCM_PRINTERQUEUEID, DCM_SH, "Printer Queue ID"}
}Definition at line 9728 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_PXLGROUPLENGTH, DCM_UL, "PXL Group Length"},
{DCM_PXLPIXELDATA, DCM_OT, "PXL Pixel Data"}
}Definition at line 9619 of file mri_dicom_hdr.c. |
|
|
Definition at line 151 of file mri_dicom_hdr.c. Referenced by mri_dicom_header(), mri_dicom_pxlarr(), and readData(). |
|
|
Definition at line 150 of file mri_dicom_hdr.c. Referenced by mri_dicom_header(), mri_dicom_pxlarr(), and readData(). |
|
|
Definition at line 8952 of file mri_dicom_hdr.c. |
|
|
Initial value: {
{DCM_RESGROUPLENGTH, DCM_UL, "RES Group Length"},
{DCM_RESID, DCM_SH, "RES Results ID"},
{DCM_RESIDISSUER, DCM_LO, "RES Results ID Issuer"},
{DCM_RESREFERENCEDINTERPSEQ, DCM_SQ, "RES Referenced Interpretation Sequence"},
{DCM_RESINTERPRECORDEDDATE, DCM_DA, "RES Interpretation Recorded Date"},
{DCM_RESINTERPRECORDEDTIME, DCM_TM, "RES Interpretation Recorded Time"},
{DCM_RESINTERPRECORDER, DCM_PN, "RES Interpretation Recorder"},
{DCM_RESREFERENCETORECORDEDSOUND, DCM_LO, "RES Reference to Recorded Sound"},
{DCM_RESINTERPTRANSCRIPTIONDATE, DCM_DA, "RES Interpretation Transcription Date"},
{DCM_RESINTERPTRANSCRIPTIONTIME, DCM_TM, "RES Interpretation Transcription Time"},
{DCM_RESINTERPTRANSCRIBER, DCM_PN, "RES Interpretation Transcriber"},
{DCM_RESINTERPTEXT, DCM_ST, "RES Interpretation Text"},
{DCM_RESINTERPAUTHOR, DCM_PN, "RES Interpretation Author"},
{DCM_RESINTERPAPPROVERSEQUENCE, DCM_SQ, "RES Interpretation Approver Sequence"},
{DCM_RESINTERPAPPROVALDATE, DCM_DA, "RES Interpretation Approval Date"},
{DCM_RESINTERPAPPROVALTIME, DCM_TM, "RES Interpretation Approval Time"},
{DCM_RESPHYSICIANAPPROVINGINTERP, DCM_PN, "RES Physician Approving Interpretation"},
{DCM_RESDIAGNOSIS, DCM_LT, "RES Diagnosis"},
{DCM_RESDIAGNOSISCODESEQ, DCM_SQ, "RES Diagnosis Code Sequence"},
{DCM_RESDISTRIBUTIIONLISTSEQUENCE, DCM_SQ, "RES Results Distribution List Sequence"},
{DCM_RESDISTRIBUTIONNAME, DCM_PN, "RES Distribution Name"},
{DCM_RESDISTRIBUTIONADDRESS, DCM_LO, "RES Distribution Address"},
{DCM_RESINTERPID, DCM_SH, "RES Interpretation ID"},
{DCM_RESINTERPIDISSUER, DCM_LO, "RES Interpretation ID Issuer"},
{DCM_RESINTERPTYPEID, DCM_CS, "RES Interpretation Type ID"},
{DCM_RESINTERPSTATUSID, DCM_CS, "RES Interpretation Status ID"},
{DCM_RESIMPRESSIONS, DCM_ST, "RES Impressions"},
{DCM_RESCOMMENTS, DCM_ST, "RES Comments"}
}Definition at line 9406 of file mri_dicom_hdr.c. |
|
|
Definition at line 192 of file mri_dicom_hdr.c. Referenced by mri_dicom_seterr(), and readVRLength(). |
|
|
Definition at line 201 of file mri_dicom_hdr.c. Referenced by DCM_OpenFile(), and mri_dicom_header(). |
|
|
Definition at line 160 of file mri_dicom_hdr.c. Referenced by DCM_DumpElements(), mri_dicom_nohex(), and mri_dicom_noname(). |
|
|
Definition at line 183 of file mri_dicom_hdr.c. Referenced by DCM_DumpElements(), mri_dicom_header(), and mri_dicom_setvm(). |
|
|
Initial value: {
{DCM_SDYGROUPLENGTH, DCM_UL, "SDY Study Group length"},
{DCM_SDYSTATUSID, DCM_CS, "SDY Study Status ID"},
{DCM_SDYPRIORITYID, DCM_CS, "SDY Study Priority ID"},
{DCM_SDYIDISSUER, DCM_LO, "SDY Study ID Issuer"},
{DCM_SDYVERIFIEDDATE, DCM_DA, "SDY Study Verified Date"},
{DCM_SDYVERIFIEDTIME, DCM_TM, "SDY Study Verified Time"},
{DCM_SDYREADDATE, DCM_DA, "SDY Study Read Date"},
{DCM_SDYREADTIME, DCM_TM, "SDY Study Read Time"},
{DCM_SDYSCHEDULEDSTARTDATE, DCM_DA, "SDY Scheduled Study Start Date"},
{DCM_SDYSCHEDULEDSTARTTIME, DCM_TM, "SDY Scheduled Study Start Time"},
{DCM_SDYSCHEDULEDSTOPDATE, DCM_DA, "SDY Scheduled Study Stop Date"},
{DCM_SDYSCHEDULEDSTOPTIME, DCM_TM, "SDY Scheduled Study Stop Time"},
{DCM_SDYSCHEDULEDLOCATION, DCM_LO, "SDY Scheduled Study Location"},
{DCM_SDYSCHEDULEDLOCATIONAETITLE, DCM_AE,
"SDY Scheduled Study Location AE Title(s)"},
{DCM_SDYREASON, DCM_LO, "SDY Study Reason"},
{DCM_SDYREQUESTINGPHYSICIAN, DCM_PN, "SDY Requesting Physician "},
{DCM_SDYREQUESTINGSERVICE, DCM_LO, "SDY Requesting Service"},
{DCM_SDYARRIVALDATE, DCM_DA, "SDY Study Arrival Date"},
{DCM_SDYARRIVALTIME, DCM_TM, "SDY Study Arrival Time"},
{DCM_SDYCOMPLETIONDATE, DCM_DA, "SDY Study Completion Date"},
{DCM_SDYCOMPLETIONTIME, DCM_TM, "SDY Study Completion Time"},
{DCM_SDYSTUDYCOMPONENTSTATUSID, DCM_CS, "SDY Study Component Status ID"},
{DCM_SDYREQUESTEDPRODESCRIPTION, DCM_LO, "SDY Requested Procedure Description"},
{DCM_SDYREQUESTEDPROCODESEQ, DCM_SQ, "SDY Requested Procedure Code Seq"},
{DCM_SDYREQUESTEDCONTRASTAGENT, DCM_LO, "SDY Requested Contrast Agent"},
{DCM_SDYCOMMENTS, DCM_LT, "SDY Comments"}
}Definition at line 9110 of file mri_dicom_hdr.c. |
|
|
Definition at line 4435 of file mri_dicom_hdr.c. |
|
|
Definition at line 9791 of file mri_dicom_hdr.c. |
|
|
Definition at line 354 of file mri_dicom_hdr.c. Referenced by COND_CopyText(), COND_DumpConditions(), COND_ExtractConditions(), COND_PopCondition(), COND_PushCondition(), COND_TopCondition(), COND_WriteConditions(), and dumpstack(). |
|
|
Initial value: {
{DCM_VISGROUPLENGTH, DCM_UL, "VIS Group Length"},
{DCM_VISREFERENCEDPATALIASSEQ, DCM_SQ, "VIS Referenced Patient Alias Sequence"},
{DCM_VISSTATUSID, DCM_CS, "VIS Visit Status ID"},
{DCM_VISADMISSIONID, DCM_LO, "VIS Admission ID"},
{DCM_VISISSUEROFADMISSIONID, DCM_LO, "VIS Issuer of Admission ID"},
{DCM_VISROUTEOFADMISSION, DCM_LO, "VIS Route of Admission"},
{DCM_VISSCHEDULEDADMISSIONDATE, DCM_DA, "VIS Scheduled Admission Date"},
{DCM_VISSCHEDULEDADMISSIONTIME, DCM_TM, "VIS Scheduled Admission Time"},
{DCM_VISSCHEDULEDDISCHARGEDATE, DCM_DA, "VIS Scheduled Discharge Date"},
{DCM_VISSCHEDULEDDISCHARGETIME, DCM_TM, "VIS Scheduled Discharge Time"},
{DCM_VISSCHEDULEDPATINSTRESIDENCE, DCM_LO, "VIS Scheduled Patient Institution Residence"},
{DCM_VISADMITTINGDATE, DCM_DA, "VIS Admitting Date"},
{DCM_VISADMITTINGTIME, DCM_TM, "VIS Admitting Time"},
{DCM_VISDISCHARGEDATE, DCM_DA, "VIS Discharge Date"},
{DCM_VISDISCHARGETIME, DCM_TM, "VIS Discharge Time"},
{DCM_VISDISCHARGEDIAGDESCRIPTION, DCM_LO, "VIS Discharge Diagnosis Description"},
{DCM_VISDISCHARGEDIAGNOSISCODESEQ, DCM_SQ, "VIS Discharge Diagnosis Code Sequence"},
{DCM_VISSPECIALNEEDS, DCM_LO, "VIS Special Needs"},
{DCM_VISCURRENTPATIENTLOCATION, DCM_LO, "VIS Current Patient Location"},
{DCM_VISPATIENTSINSTRESIDENCE, DCM_LO, "VIS Patient's Institution Residence"},
{DCM_VISPATIENTSTATE, DCM_LO, "VIS Patient State"},
{DCM_VISCOMMENTS, DCM_LT, "VIS Comments"}
}Definition at line 9142 of file mri_dicom_hdr.c. |
|
|
Definition at line 4130 of file mri_dicom_hdr.c. |
|
|
Definition at line 9169 of file mri_dicom_hdr.c. |
