Match mappings order with traceheader order

Note that we have no information that files like that do exist, but
specification does not prevent them from existing and code seemed
incomplete without this check.

Author: achaikou

lib/include/segyio/segy.h

@@ -503,6 +503,9 @@ int segy_samples( const char* binheader );
  */
 int segy_traceheaders( const char* binheader, int* traceheader_count );
 
+/* Reads into allocated memory traceheader names from first trace. */
+int segy_traceheader_names( segy_datasource* ds, char (*names)[8] );
+
 /*
  * calculate delay recording time for the first trace.
  */

lib/src/segy.c

@@ -1891,6 +1891,32 @@ int segy_traceheaders(
     return SEGY_OK;
 }
 
+int segy_traceheader_names(
+    segy_datasource* ds,
+    char ( *names )[8]
+) {
+    memcpy( names[0], "SEG00000", 8 );
+
+    for( int i = 1; i < ds->metadata.traceheader_count; ++i ) {
+        int err = seek_traceheader_offset( ds, 0, i, 232 );
+        if( err != SEGY_OK ) return err;
+
+        err = ds->read( ds, names[i], 8 );
+        if( err != 0 ) return SEGY_DS_READ_ERROR;
+
+        // it is unclear how to interpret specification "May be ASCII or EBCDIC
+        // text." For proprietary headers we don't know the expected name, so
+        // have to assume that header name is encoded the same way as main text
+        // header. We however can guess the encoding in files that have only
+        // predefined headers to prevent 'open' from breaking.
+        bool is_ascii_seg_header = memcmp( names[i], "SEG", 3 ) == 0;
+        if( ds->metadata.encoding == SEGY_EBCDIC && !is_ascii_seg_header ) {
+            encode( names[i], names[i], e2a, 8 );
+        }
+    }
+
+    return SEGY_OK;
+}
 
 static int bswap_th(
     const segy_datasource* ds,

lib/src/segy.def

@@ -9,6 +9,7 @@ segy_binheader_size
 segy_binheader
 segy_write_binheader
 segy_samples
+segy_traceheader_names
 segy_delay_recoding_time
 segy_sample_interval
 segy_format

python/segyio/segyio.cpp

@@ -13,6 +13,7 @@
 #include <segyio/segy.h>
 
 #include <algorithm>
+#include <array>
 #include <cstdint>
 #include <cstring>
 #include <memory>
@@ -689,33 +690,54 @@ PyObject* segyopen( segyfd* self, PyObject* args, PyObject* kwargs ) {
         self->stanzas.empty() ? 0 : self->stanzas.back().end_index();
 
     err = segy_collect_metadata( ds, endianness, encoding, ext_textheader_count );
-    if( err == SEGY_OK ) {
-        self->format = ds->metadata.format;
-        self->elemsize = ds->metadata.elemsize;
-        self->trace0 = ds->metadata.trace0;
-        self->samplecount = ds->metadata.samplecount;
-        self->trace_bsize = ds->metadata.trace_bsize;
-        self->traceheader_count = ds->metadata.traceheader_count;
-        self->tracecount = ds->metadata.tracecount;
+    if( err != SEGY_OK ) {
+        std::ostringstream msg;
+        msg << "unable to gather basic metadata from the file, error " << segy_errstr( err )
+            << ". Intermediate state:\n"
+            << "  endianness=" << ds->metadata.endianness << "\n"
+            << "  encoding=" << ds->metadata.encoding << "\n"
+            << "  format=" << ds->metadata.format << "\n"
+            << "  elemsize=" << ds->metadata.elemsize << "\n"
+            << "  ext_textheader_count=" << ds->metadata.ext_textheader_count << "\n"
+            << "  trace0=" << ds->metadata.trace0 << "\n"
+            << "  samplecount=" << ds->metadata.samplecount << "\n"
+            << "  trace_bsize=" << ds->metadata.trace_bsize << "\n"
+            << "  traceheader_count=" << ds->metadata.traceheader_count << "\n"
+            << "  tracecount=" << ds->metadata.tracecount;
+        return RuntimeError( msg.str().c_str() );
+    }
+
+    self->format = ds->metadata.format;
+    self->elemsize = ds->metadata.elemsize;
+    self->trace0 = ds->metadata.trace0;
+    self->samplecount = ds->metadata.samplecount;
+    self->trace_bsize = ds->metadata.trace_bsize;
+    self->traceheader_count = ds->metadata.traceheader_count;
+    self->tracecount = ds->metadata.tracecount;
 
-        Py_INCREF( self );
-        return (PyObject*)self;
+
+    std::vector<std::array<char, 8>> traceheader_names(self->traceheader_count);
+    err = segy_traceheader_names(ds, reinterpret_cast<char(*)[8]>(traceheader_names.data()));
+    if( err ) return Error( err );
+
+    std::vector<segy_header_mapping> ordered_mappings;
+    for (const auto& header_name : traceheader_names) {
+        bool found = false;
+        for (const auto& mapping : self->traceheader_mappings) {
+            if (std::strncmp(mapping.name, header_name.data(), 8) == 0) {
+                ordered_mappings.push_back(mapping);
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            return KeyError("traceheader mapping for '%8.8s' not found", header_name.data());
+        }
     }
+    self->traceheader_mappings = std::move(ordered_mappings);
 
-    std::ostringstream msg;
-    msg << "unable to gather basic metadata from the file, error " << segy_errstr( err )
-        << ". Intermediate state:\n"
-        << "  endianness=" << ds->metadata.endianness << "\n"
-        << "  encoding=" << ds->metadata.encoding << "\n"
-        << "  format=" << ds->metadata.format << "\n"
-        << "  elemsize=" << ds->metadata.elemsize << "\n"
-        << "  ext_textheader_count=" << ds->metadata.ext_textheader_count << "\n"
-        << "  trace0=" << ds->metadata.trace0 << "\n"
-        << "  samplecount=" << ds->metadata.samplecount << "\n"
-        << "  trace_bsize=" << ds->metadata.trace_bsize << "\n"
-        << "  traceheader_count=" << ds->metadata.traceheader_count << "\n"
-        << "  tracecount=" << ds->metadata.tracecount;
-    return RuntimeError( msg.str().c_str() );
+    Py_INCREF( self );
+    return (PyObject*)self;
 }
 
 PyObject* segycreate( segyfd* self, PyObject* args, PyObject* kwargs ) {

python/test/segy.py

@@ -2430,6 +2430,18 @@ def test_open_with_custom_mapping():
     with pytest.raises(ValueError, match=r"invalid field datatype*"):
         segyio.open(testdata / 'mapping-unsupported-type.sgy')
 
+    with segyio.open(testdata / 'mapping-mixed-order.sgy') as f:
+        assert f.tracefield.names() == ["SEG00000", "SEG00001", "PRIVATE1", "PRIVATE2"]
+
+    with segyio.open(testdata / 'mapping-no-extension1.sgy') as f:
+        assert f.tracefield.names() == ["SEG00000", "PRIVATE1"]
+
+    with segyio.open(testdata / 'mapping-encoding-ext1.sgy') as f:
+        assert f.tracefield.names() == ["SEG00000", "SEG00001"]
+
+    with pytest.raises(KeyError, match=r"traceheader mapping for .* not found"):
+        segyio.open(testdata / 'mapping-encoding-private.sgy')
+
 
 def test_tracefields():
     with segyio.open(testdata / 'trace-header-extensions.sgy') as f:

test-data/README.md

@@ -101,11 +101,15 @@ Files are created manually.
 | mapping-all-types-lsb.sgy      | `flip-endianness.py mapping-all-types.sgy out.sgy`            |
 | mapping-default.sgy            | XML corresponds exactly to the default SEG-Y rev 2.1 mapping. |
 | mapping-empty.sgy              | Root does not have minimal number of required fields.         |
+| mapping-encoding-ext1.sgy      | SEG00001 name encoding does not match text header encoding.   |
+| mapping-encoding-private.sgy   | Proprietary header name encoding != text header encoding.     |
 | mapping-invalid-attribute.sgy  | Last entry does not have 'byte' attribute.                    |
 | mapping-invalid-root.sgy       | Root does not define standard header layout.                  |
 | mapping-invalid-value.sgy      | Last standard header entry byte is out of range.              |
 | mapping-minimal.sgy            | File with minimal number of defined fields segyio can open.   |
+| mapping-mixed-order.sgy        | XML layouts are in different order than headers in file.      |
 | mapping-multiple-stanzas.sgy   | Other stanzas are present before and after layout stanza.     |
+| mapping-no-extension1.sgy      | Only standard and proprietary trace headers are present.      |
 | mapping-shifted.sgy            | Default mapping with all offsets shifted by 1 byte.           |
 | mapping-unparsable.sgy         | XML is unparsable.                                            |
 | mapping-unsupported-type.sgy   | One axis value is of type segyio doesn't allow in that field. |