1 """Routines to help recognizing sound files.

     2 

     3 Function whathdr() recognizes various types of sound file headers.

     4 It understands almost all headers that SOX can decode.

     5 

     6 The return tuple contains the following items, in this order:

     7 - file type (as SOX understands it)

     8 - sampling rate (0 if unknown or hard to decode)

     9 - number of channels (0 if unknown or hard to decode)

    10 - number of frames in the file (-1 if unknown or hard to decode)

    11 - number of bits/sample, or 'U' for U-LAW, or 'A' for A-LAW

    12 

    13 If the file doesn't have a recognizable type, it returns None.

    14 If the file can't be opened, IOError is raised.

    15 

    16 To compute the total time, divide the number of frames by the

    17 sampling rate (a frame contains a sample for each channel).

    18 

    19 Function what() calls whathdr().  (It used to also use some

    20 heuristics for raw data, but this doesn't work very well.)

    21 

    22 Finally, the function test() is a simple main program that calls

    23 what() for all files mentioned on the argument list.  For directory

    24 arguments it calls what() for all files in that directory.  Default

    25 argument is "." (testing all files in the current directory).  The

    26 option -r tells it to recurse down directories found inside

    27 explicitly given directories.

    28 """

    29 

    30 # The file structure is top-down except that the test program and its

    31 # subroutine come last.

    32 

    33 __all__ = ["what","whathdr"]

    34 

    35 def what(filename):

    36     """Guess the type of a sound file"""

    37     res = whathdr(filename)

    38     return res

    39 

    40 

    41 def whathdr(filename):

    42     """Recognize sound headers"""

    43     f = open(filename, 'rb')

    44     h = f.read(512)

    45     for tf in tests:

    46         res = tf(h, f)

    47         if res:

    48             return res

    49     return None

    50 

    51 

    52 #-----------------------------------#

    53 # Subroutines per sound header type #

    54 #-----------------------------------#

    55 

    56 tests = []

    57 

    58 def test_aifc(h, f):

    59     import aifc

    60     if h[:4] != 'FORM':

    61         return None

    62     if h[8:12] == 'AIFC':

    63         fmt = 'aifc'

    64     elif h[8:12] == 'AIFF':

    65         fmt = 'aiff'

    66     else:

    67         return None

    68     f.seek(0)

    69     try:

    70         a = aifc.openfp(f, 'r')

    71     except (EOFError, aifc.Error):

    72         return None

    73     return (fmt, a.getframerate(), a.getnchannels(), \

    74             a.getnframes(), 8*a.getsampwidth())

    75 

    76 tests.append(test_aifc)

    77 

    78 

    79 def test_au(h, f):

    80     if h[:4] == '.snd':

    81         f = get_long_be

    82     elif h[:4] in ('\0ds.', 'dns.'):

    83         f = get_long_le

    84     else:

    85         return None

    86     type = 'au'

    87     hdr_size = f(h[4:8])

    88     data_size = f(h[8:12])

    89     encoding = f(h[12:16])

    90     rate = f(h[16:20])

    91     nchannels = f(h[20:24])

    92     sample_size = 1 # default

    93     if encoding == 1:

    94         sample_bits = 'U'

    95     elif encoding == 2:

    96         sample_bits = 8

    97     elif encoding == 3:

    98         sample_bits = 16

    99         sample_size = 2

   100     else:

   101         sample_bits = '?'

   102     frame_size = sample_size * nchannels

   103     return type, rate, nchannels, data_size/frame_size, sample_bits

   104 

   105 tests.append(test_au)

   106 

   107 

   108 def test_hcom(h, f):

   109     if h[65:69] != 'FSSD' or h[128:132] != 'HCOM':

   110         return None

   111     divisor = get_long_be(h[128+16:128+20])

   112     return 'hcom', 22050/divisor, 1, -1, 8

   113 

   114 tests.append(test_hcom)

   115 

   116 

   117 def test_voc(h, f):

   118     if h[:20] != 'Creative Voice File\032':

   119         return None

   120     sbseek = get_short_le(h[20:22])

   121     rate = 0

   122     if 0 <= sbseek < 500 and h[sbseek] == '\1':

   123         ratecode = ord(h[sbseek+4])

   124         rate = int(1000000.0 / (256 - ratecode))

   125     return 'voc', rate, 1, -1, 8

   126 

   127 tests.append(test_voc)

   128 

   129 

   130 def test_wav(h, f):

   131     # 'RIFF' <len> 'WAVE' 'fmt ' <len>

   132     if h[:4] != 'RIFF' or h[8:12] != 'WAVE' or h[12:16] != 'fmt ':

   133         return None

   134     style = get_short_le(h[20:22])

   135     nchannels = get_short_le(h[22:24])

   136     rate = get_long_le(h[24:28])

   137     sample_bits = get_short_le(h[34:36])

   138     return 'wav', rate, nchannels, -1, sample_bits

   139 

   140 tests.append(test_wav)

   141 

   142 

   143 def test_8svx(h, f):

   144     if h[:4] != 'FORM' or h[8:12] != '8SVX':

   145         return None

   146     # Should decode it to get #channels -- assume always 1

   147     return '8svx', 0, 1, 0, 8

   148 

   149 tests.append(test_8svx)

   150 

   151 

   152 def test_sndt(h, f):

   153     if h[:5] == 'SOUND':

   154         nsamples = get_long_le(h[8:12])

   155         rate = get_short_le(h[20:22])

   156         return 'sndt', rate, 1, nsamples, 8

   157 

   158 tests.append(test_sndt)

   159 

   160 

   161 def test_sndr(h, f):

   162     if h[:2] == '\0\0':

   163         rate = get_short_le(h[2:4])

   164         if 4000 <= rate <= 25000:

   165             return 'sndr', rate, 1, -1, 8

   166 

   167 tests.append(test_sndr)

   168 

   169 

   170 #---------------------------------------------#

   171 # Subroutines to extract numbers from strings #

   172 #---------------------------------------------#

   173 

   174 def get_long_be(s):

   175     return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])

   176 

   177 def get_long_le(s):

   178     return (ord(s[3])<<24) | (ord(s[2])<<16) | (ord(s[1])<<8) | ord(s[0])

   179 

   180 def get_short_be(s):

   181     return (ord(s[0])<<8) | ord(s[1])

   182 

   183 def get_short_le(s):

   184     return (ord(s[1])<<8) | ord(s[0])

   185 

   186 

   187 #--------------------#

   188 # Small test program #

   189 #--------------------#

   190 

   191 def test():

   192     import sys

   193     recursive = 0

   194     if sys.argv[1:] and sys.argv[1] == '-r':

   195         del sys.argv[1:2]

   196         recursive = 1

   197     try:

   198         if sys.argv[1:]:

   199             testall(sys.argv[1:], recursive, 1)

   200         else:

   201             testall(['.'], recursive, 1)

   202     except KeyboardInterrupt:

   203         sys.stderr.write('\n[Interrupted]\n')

   204         sys.exit(1)

   205 

   206 def testall(list, recursive, toplevel):

   207     import sys

   208     import os

   209     for filename in list:

   210         if os.path.isdir(filename):

   211             print filename + '/:',

   212             if recursive or toplevel:

   213                 print 'recursing down:'

   214                 import glob

   215                 names = glob.glob(os.path.join(filename, '*'))

   216                 testall(names, recursive, 0)

   217             else:

   218                 print '*** directory (use -r) ***'

   219         else:

   220             print filename + ':',

   221             sys.stdout.flush()

   222             try:

   223                 print what(filename)

   224             except IOError:

   225                 print '*** not found ***'

   226 

   227 if __name__ == '__main__':

   228     test()