Ignore missing metadata group length field

parse.go

@@ -207,10 +207,11 @@ type ParseOption func(*parseOptSet)
 
 // parseOptSet represents the flattened option set after all ParseOptions have been applied.
 type parseOptSet struct {
-	skipMetadataReadOnNewParserInit bool
-	allowMismatchPixelDataLength    bool
-	skipPixelData                   bool
-	skipProcessingPixelDataValue    bool
+	skipMetadataReadOnNewParserInit  bool
+	allowMismatchPixelDataLength     bool
+	skipPixelData                    bool
+	skipProcessingPixelDataValue     bool
+	allowErrorMetaElementGroupLength bool
 }
 
 func toParseOptSet(opts ...ParseOption) parseOptSet {
@@ -228,6 +229,14 @@ func AllowMismatchPixelDataLength() ParseOption {
 	}
 }
 
+// AllowErrorMetaElementGroupLength allows parser to work around missing metaelement group length tag (0x0002,0x0000) by reading elements only
+// in group 2
+func AllowErrorMetaElementGroupLength() ParseOption {
+	return func(set *parseOptSet) {
+		set.allowErrorMetaElementGroupLength = true
+	}
+}
+
 // SkipMetadataReadOnNewParserInit makes NewParser skip trying to parse metadata. This will make the Parser default to implicit little endian byte order.
 // Any metatata tags found in the dataset will still be available when parsing.
 func SkipMetadataReadOnNewParserInit() ParseOption {

read.go

@@ -159,28 +159,58 @@ func (r *reader) readHeader() ([]*Element, error) {
 		return nil, err
 	}
 
+	metaElems := []*Element{maybeMetaLen} // TODO: maybe set capacity to a reasonable initial size
+	metaElementGroupLengthDefined := true
 	if maybeMetaLen.Tag != tag.FileMetaInformationGroupLength || maybeMetaLen.Value.ValueType() != Ints {
-		return nil, ErrorMetaElementGroupLength
+		if !r.opts.allowErrorMetaElementGroupLength {
+			return nil, ErrorMetaElementGroupLength
+		}
+		metaElementGroupLengthDefined = false
+		metaElems = append(metaElems, maybeMetaLen)
 	}
 
-	metaLen := maybeMetaLen.Value.GetValue().([]int)[0]
-
-	metaElems := []*Element{maybeMetaLen} // TODO: maybe set capacity to a reasonable initial size
+	if metaElementGroupLengthDefined {
+		metaLen := maybeMetaLen.Value.GetValue().([]int)[0]
 
-	// Read the metadata elements
-	err = r.rawReader.PushLimit(int64(metaLen))
-	if err != nil {
-		return nil, err
-	}
-	defer r.rawReader.PopLimit()
-	for !r.rawReader.IsLimitExhausted() {
-		elem, err := r.readElement(nil, nil)
+		// Read the metadata elements
+		err = r.rawReader.PushLimit(int64(metaLen))
 		if err != nil {
-			// TODO: see if we can skip over malformed elements somehow
 			return nil, err
 		}
-		// log.Printf("Metadata Element: %s\n", elem)
-		metaElems = append(metaElems, elem)
+		defer r.rawReader.PopLimit()
+		for !r.rawReader.IsLimitExhausted() {
+			elem, err := r.readElement(nil, nil)
+			if err != nil {
+				// TODO: see if we can skip over malformed elements somehow
+				return nil, err
+			}
+			// log.Printf("Metadata Element: %s\n", elem)
+			metaElems = append(metaElems, elem)
+		}
+	} else if r.opts.allowErrorMetaElementGroupLength {
+		// We cannot use the limit functionality
+		debug.Log("Proceeding without metadata group length")
+		for {
+			// Lets peek into the tag field until we get to end-of-header
+			tag_bytes, err := r.rawReader.Peek(4)
+			if err != nil {
+				return nil, ErrorMetaElementGroupLength
+			}
+			tg := tag.Tag{}
+			buff := bytes.NewBuffer(tag_bytes)
+			binary.Read(buff, binary.LittleEndian, &tg)
+			debug.Logf("header-tag: %v", tg)
+			// Only read group 2 data
+			if tg.Group != 0x0002 {
+				break
+			}
+			elem, err := r.readElement(nil, nil)
+			if err != nil {
+				// TODO: see if we can skip over malformed elements somehow
+				return nil, err
+			}
+			metaElems = append(metaElems, elem)
+		}
 	}
 	return metaElems, nil
 }