dsdiff-info.py

#!/usr/bin/env python

# dsdiff-check-all-chunks.py
# Test DSDIFF DSD files (.dff) loop through all chunks
# prints out all DSDIFF chunk data structure info
# Standalone version, does not use dsdlib.py
# (c) 2014 Jurgen Kramer
# License: GPLv2
#
# version 0.1 9-sep-14 Jurgen Kramer
# First initial version
# v0.2 13-Sept-14 Jurgen Kramer
# Now loops through all main chunks
# TODO: handle sub chunks
# v0.3 15-Sept-14 Jurgen Kramer
# Handle local property ('PROP') chunks, FVER version check
# v0.4 05-Oct-14 Jurgen Kramer
# Accept 0x1040000 as a valid version for DSDIFF (minimum version should be 0x1050000)
# v0.5 11-Mar-16 Jurgen Kramer
# Add check if file could hang MPD at the end of the file (sample data size not dividable by 4 bug)
# Adjust print statements to new style
# Additional compression info
# v0.6 23-Jun-16 Jurgen Kramer
# - Uses spaces for indentation instead of tabs
# - Use dictionary for rate to text conversion
# v0.7 24-Feb-24 Jurgen Kramer
# - Update for Python3

import struct
import sys

# Form DSD Chunk
struct_frm8_fmt = '>4s1Q4s'
struct_frm8_len = struct.calcsize(struct_frm8_fmt)
struct_unpack_frm8 = struct.Struct(struct_frm8_fmt).unpack_from

# Format Version Chunk
struct_fver_fmt = '>1L'
struct_fver_len = struct.calcsize(struct_fver_fmt)
struct_unpack_fver = struct.Struct(struct_fver_fmt).unpack_from

# Property Chunk
struct_prop_fmt = '>4s'
struct_prop_len = struct.calcsize(struct_prop_fmt)
struct_unpack_prop = struct.Struct(struct_prop_fmt).unpack_from

# Sample Rate Chunk
struct_rate_fmt = '>1L'
struct_rate_len = struct.calcsize(struct_rate_fmt)
struct_unpack_rate = struct.Struct(struct_rate_fmt).unpack_from

# Channels Chunk
struct_chan_fmt = '>1H'
struct_chan_len = struct.calcsize(struct_chan_fmt)
struct_unpack_chan = struct.Struct(struct_chan_fmt).unpack_from

# Channel descriptions
struct_chandes_fmt = '>4s'
struct_chandes_len = struct.calcsize(struct_chandes_fmt)
struct_unpack_chandes = struct.Struct(struct_chandes_fmt).unpack_from

# Compression Type Chunk
struct_cmp_fmt = '>4s1B'
struct_cmp_len = struct.calcsize(struct_cmp_fmt)
struct_unpack_cmp = struct.Struct(struct_cmp_fmt).unpack_from

# Compression name
struct_cmpstr_fmt = '>1s'
struct_cmpstr_len = struct.calcsize(struct_cmpstr_fmt)
struct_unpack_cmpstr = struct.Struct(struct_cmpstr_fmt).unpack_from

# Absolute Start Time Chunk
struct_abbs_fmt = '>1H1B1B1L'
struct_abbs_len = struct.calcsize(struct_abbs_fmt)
struct_unpack_abbs = struct.Struct(struct_abbs_fmt).unpack_from

# Loudspeaker Configuration Chunk
struct_spkr_fmt = '>1H'
struct_spkr_len = struct.calcsize(struct_spkr_fmt)
struct_unpack_spkr = struct.Struct(struct_spkr_fmt).unpack_from

# DSD Sound Data Chunk
struct_dsd_fmt = '>4s1Q'
struct_dsd_len = struct.calcsize(struct_dsd_fmt)
struct_unpack_dsd = struct.Struct(struct_dsd_fmt).unpack_from

# Basis chunk, ID + chunk_size only
struct_dsd_chunk = '>4s1Q'
struct_dsd_chunk_len = struct.calcsize(struct_dsd_chunk)
struct_unpack_dsd_chunk = struct.Struct(struct_dsd_chunk).unpack_from

dsd_rate_to_text = {
    2822400 : "DSD64",
    5644800 : "DSD128",
    11289600 : "DSD256",
    22579200 : "DSD512",
    3072000 : "DSD64,",
    6144000 : "DSD128",
    12288000 : "DSD256",
    24576000 : "DSD512"
    }


#-- Functions
def wrongfile(marker):
    print("Not a DSDIFF file! Error at '%s' marker" % marker)
    sys.exit(1)

# Handle local chunks of property chunk
def handle_prop_local_chunks(size):
    ret = 0
    curpos = f.tell()
    maxpos = curpos + size
    #print "Property local chunks, total size is %d , cur pos = %d" % (size, curpos)
    props = []
    propdata = f.read(struct_prop_len)
    s = struct_unpack_prop(propdata)
    props.append(s)
    chunk_id = props[0][0].decode("UTF-8")  # Should be 'SND '
    if chunk_id == 'SND ':

        while curpos < maxpos:
            # Read next chunk ID + chunk size
            propdata = f.read(struct_dsd_len)
            s = struct_unpack_dsd_chunk(propdata)
            props.append(s)

            chunk_id = props[1][0].decode("UTF-8")
            chunk_size = props[1][1]

            # Sample Rate Chunk
            if chunk_id == 'FS  ':
                print("Sample Rate Chunk")
                props = []
                propdata = f.read(struct_rate_len)
                s = struct_unpack_rate(propdata)
                props.append(s)
                rate = props[0][0]
                if rate in dsd_rate_to_text:
                    print("Sample rate: %s Hz [%s]" %(rate,dsd_rate_to_text[rate]))
                else:
                    print("Sample rate: %d Hz" % rate)
                ret += 1
                curpos = f.tell()
                continue

            # Channels Chunk
            if chunk_id == 'CHNL':
                print("Channels Chunk")
                props = []
                propdata = f.read(struct_chan_len)
                s = struct_unpack_chan(propdata)
                props.append(s)
                channels = props[0][0]
                print( "File has %d channels" % channels)
                for i in range(0, channels):
                    props = []
                    propdata = f.read(struct_chandes_len)
                    s = struct_unpack_chandes(propdata)
                    props.append(s)
                    chandes = props[0][0]
                    print("Channel: %s" % chandes)
                ret += 1
                curpos = f.tell()
                continue

            # Compression Type Chunk
            if chunk_id == 'CMPR':
                print("Compression Type Chunk")
                props = []
                propdata = f.read(struct_cmp_len)
                s = struct_unpack_cmp(propdata)
                props.append(s)
                cmptype = props[0][0]
                cmplen = props[0][1]
                compressed = "Not compressed"
                if cmptype != 'DSD ':
                    compressed = " Compressed"
                print("Compression type: '%s' (%s)" % (cmptype, compressed))
                print("Compression string length: %d" % cmplen)
                for i in range(0, cmplen+1):
                    propdata = f.read(struct_cmpstr_len)
                    s = struct_unpack_cmpstr(propdata)
                    #print "%s" % s,

                ret += 1
                curpos = f.tell()
                #print "POS is %d" % curpos
                continue

            if chunk_id == 'ABSS':                # Optional
                print("Absolute Start Time Chunk")
                print("Size %d" % chunk_size)
                props = []
                propdata = f.read(struct_abbs_len)
                s = struct_unpack_abbs(propdata)
                props.append(s)
                hrs = props[0][0]
                mins = props[0][1]
                secs = props[0][2]
                samples = props[0][3]
                print("Offset: %d hrs, %d mins, %d secs and %d samples " %(hrs, mins, secs, samples))

                curpos = f.tell()
                continue

            if chunk_id == 'LSCO':                # Optional
                print("Loudspeaker Configuration Chunk")
                if chunk_size != 2:
                    print("Illegal chunk size %d" % chunk_size)
                    ret = -1
                    return ret

                props = []
                propdata = f.read(struct_spkr_len)
                s = struct_unpack_spkr(propdata)
                props.append(s)
                spkrcfg = props[0][0]
                print("Speaker config is: %d" % spkrcfg)
                curpos = f.tell()
                continue

        return ret

    else:
        ret = -1
        return ret


#-- Main
if __name__ == "__main__":
    # Check command line arguments
    if len(sys.argv) <= 1:
        print("Missing filename to test on")
        sys.exit(1)

    filename = sys.argv[1]

    print("\nResults for file\t: %s\n" % filename)

    results = []
    confedence = 0
    neededconf = 4
    id3tag = 0
    could_trigger_mpd_hang = False


    with open(filename, "rb") as f:

        # Read header of the file and check for the needed DSDIFF ID's
        data = f.read(struct_frm8_len)
        s = struct_unpack_frm8(data)
        results.append(s)
        chunk_id = results[0][0].decode("UTF-8")    # Should be 'FRM8'
        dsd_file_size = results[0][1]
        dsd_id = results[0][2].decode("UTF-8")      # Should be 'DSD '

        if chunk_id != 'FRM8':
            wrongfile('FRM8')

        if dsd_id != 'DSD ':
            wrongfile('DSD ')

        confedence += 1

        print("Found start chunk\t: '%s'" % chunk_id)
        print("Total file size\t\t: %d" % dsd_file_size)

        print("\nFile pos now at\t\t: %d" % f.tell())

        # Loop through all the remaining chunks
        while True:
            results = []
            data = f.read(struct_dsd_chunk_len)
            if not data: break
            s = struct_unpack_dsd_chunk(data)
            results.append(s)
            chunk_id = results[0][0].decode("UTF-8")
            chunk_size = results[0][1]

            print("Found chunk with id\t: '%s'" % chunk_id)
            print("Chunk size\t\t: %d" % chunk_size)

            if chunk_id == 'FVER':
                results = []
                data = f.read(struct_fver_len)
                s = struct_unpack_fver(data)
                results.append(s)
                version = results[0][0]
                #print "FVER: version 0x%06x " % version
                if version != 0x1050000 and version != 0x1040000:
                    print("Illegal/unsupported version 0x%06x" % version)
                    break
                confedence += 1

                pos = f.tell()
                seekpos = pos
                #print "POS is: %d" % pos
                continue

            if chunk_id == 'DSD ' or chunk_id == 'DST ':
                print("DSD sample data starts at: %d" % f.tell() )
                confedence += 1
                # Test if this file can trigger MPD hang bug
                if chunk_id == 'DSD ' and chunk_size % 4 != 0:
                    could_trigger_mpd_hang = True

            if chunk_id == 'PROP':
                ret = handle_prop_local_chunks(chunk_size)
                if ret == -1:
                    print("Problems with property chunk")
                    break
                if ret != 3:
                    print("Missing required local chunks in property chunk")
                    break

                confedence += 1
                pos = f.tell()
                seekpos = pos
            else:
                # Seek to next chunk
                pos = f.tell()
                seekpos = pos + chunk_size
                # Check if this was the last chunk
                if seekpos > dsd_file_size:
                    break
            f.seek(seekpos)
            print("\nFile pos now at\t\t: %d" % f.tell())


        f.close()
        print("\nConclusion\t\t: ", end='')
        if confedence < neededconf:
            print(">>This is not a properly DSDIFF formatted file<<")
            print("\t\t\t\tConfedence = %d, needs to be %d" % (confedence, neededconf))
        else:
            if id3tag == 0:
                print("This is a properly formatted DSDIFF file")
            else:
                print("This is a properly formatted DSDIFF file with unofficial ID3 tag")
            if could_trigger_mpd_hang:
                print("Warning\t\t\t: !!This file could hang MPD at the end of the song!!")

        print("")
        sys.exit(0)