HQSYN16

#!/usr/bin/python2

import argparse

import wave

import struct

import subprocess

import os

import os.path

import shutil

import numpy as np

import matplotlib.pyplot as plt

# ----------

frame_shift_sec = 0.005

frame_len_sec = 0.025

fft_len = 512

sp_len = fft_len/2 + 1

band1_beg_hz = 350

band1_end_hz = 1100

band2_beg_hz = 2300

band2_end_hz = 5500

# ----------

def read_data( file_name ):

    f = open( file_name, "rb" )

    data = f.read()

    f.close()

    return data

# ----------

def write_data( file_name, data ):

    f = open( file_name, "wb" )

    f.write( data )

    f.close()

# ----------

def get_files( base_dir, file_ext ):

    return [ fileName[:-1-len( file_ext )] for fileName in os.listdir( base_dir ) if fileName.endswith( file_ext ) and not fileName.startswith( "." ) ]

# ----------

def main():

    sptk_dir = "/home/zhanzlic/tools/SPTK/bin"

    ext_audio = "wav"

    ext_slope = "slope.asf"

    parser = argparse.ArgumentParser( description="Test reand and write MMF file." )

    parser.add_argument( type=str, metavar="DIR_SRC", dest="dir_src", help="directory with source audio files" )

    parser.add_argument( type=str, metavar="DIR_OUT", dest="dir_out", help="output directory for new audio files" )

    args = parser.parse_args()

    if not os.path.exists( args.dir_out ):

        os.makedirs( args.dir_out )

    temp_dir = args.dir_out + "/tmp"

    if not os.path.exists( temp_dir ):

        os.makedirs( temp_dir )

    files = get_files( args.dir_src, ext_audio )

    nfiles = len( files )

    for fileName in sorted( files ):

        file_wav = "{}/{}.{}".format( args.dir_src, fileName, ext_audio )

        file_samples = "{}/samples".format( temp_dir )

        file_frames = "{}/frames".format( temp_dir )

        file_sp = "{}/sp".format( temp_dir )

        file_slope = "{}/{}.{}".format( args.dir_out, fileName, ext_slope )

        if os.path.exists( file_slope ):

            continue

        print "Processing", fileName, "..."

        # ----- wave to samples

        w = wave.open( file_wav )

        freq_samp = w.getframerate()

        frame_num = w.getnframes()

        samp_width = w.getsampwidth()

        if samp_width == 1:

            samples = struct.unpack( "b"*frame_num, w.readframes( frame_num ) )

        elif samp_width == 2:

            samples = struct.unpack( "h"*frame_num, w.readframes( frame_num ) )

        w.close()

        frame_shift = frame_shift_sec * freq_samp

        frame_len = frame_len_sec * freq_samp

        write_data( file_samples, struct.pack( "f"*frame_num, *samples ) )

        # ----- samples to frames

        os.system( "{sptk_dir}/frame -l {len} -p {shift} {samples} | {sptk_dir}/window -l {len} -L {fft_len} -w 2 -n 1 > {frames}".format(

            sptk_dir=sptk_dir, len=frame_len, shift=frame_shift, fft_len=fft_len, samples=file_samples, frames=file_frames ) )

        # ----- frames to spectra

        os.system( "{}/fftr -l {} -A -H {} > {}".format( sptk_dir, fft_len, file_frames, file_sp ) )

        data = read_data( file_sp )

        data_len = len( data )/4

        sp = struct.unpack( "f"*data_len, data )

        sp_num = data_len / sp_len

        times = [ frame_shift_sec*x for x in range( sp_num ) ]

        # ----- spectra to slope

        band1_beg = band1_beg_hz * sp_len / ( freq_samp / 2 )

        band1_end = band1_end_hz * sp_len / ( freq_samp / 2 )

        band2_beg = band2_beg_hz * sp_len / ( freq_samp / 2 )

        band2_end = band2_end_hz * sp_len / ( freq_samp / 2 )

        width = ( band2_end_hz + band2_beg_hz ) / 2 - ( band1_end_hz + band1_beg_hz ) / 2

        data = read_data( file_sp )

        data_len = len( data )/4

        sp = struct.unpack( "f"*data_len, data )

        sp_num = data_len / sp_len

        slopes = [ 0.0 ] * sp_num

        band1  = [ 0.0 ] * sp_num

        band2  = [ 0.0 ] * sp_num

        for idx in range( sp_num ):

            spec = sp[ idx*sp_len : (idx+1)*sp_len ]

            band1[ idx ] = np.mean( spec[ band1_beg:band1_end ] )

            band2[ idx ] = np.mean( spec[ band2_beg:band2_end ] )

            slopes[ idx ] = ( band2[ idx ] - band1[ idx ] ) / width

            f = open( file_slope, "wt" )

            f.write( "#!ASF!#\n" )

            f.write( "\n" )

            f.write( "# band_1_avg, band_2_avg ... average amplitudes inside frequency bands\n" )

            f.write( "# width ... distance between centra of band 1 and band2 [Hz]\n" )

            f.write( "# slope = ( band_2_avg - band_1_avg ) / width \n" )

            f.write( "\n" )

            f.write( "<band_1_begin = {}>\n".format( band1_beg_hz ) )

            f.write( "<band_1_end   = {}>\n".format( band1_end_hz ) )

            f.write( "<band_2_begin = {}>\n".format( band2_beg_hz ) )

            f.write( "<band_2_end   = {}>\n".format( band2_end_hz ) )

            f.write( "\n" )

            f.write( "[ time    | band_1_avg | band_2_avg | slope    ]\n" )

            f.write( "\n" )

            for idx in range( len( times ) ):

                f.write( "| {:7.3f} | {:10.3f} | {:10.3f} | {:8.5f} |\n".format( times[idx], band1[ idx ], band2[ idx ], slopes[idx] ) )

            f.close()

        #plt.plot( slopes )

        #plt.show()

        #break

# ----------

if ( __name__ == "__main__" ):

    main()