change task, add data files

README.md

@@ -17,7 +17,7 @@ Demo Page: https://junzhejosephzhu.github.io/Multi-Decoder-DPRNN/
 Original research repo is at https://github.com/JunzheJosephZhu/MultiDecoder-DPRNN
 
 This model was trained by Joseph Zhu using the wsj0-mix-var/Multi-Decoder-DPRNN recipe in Asteroid. 
-It was trained on the `sep_clean` task of the Wsj0MixVar dataset.
+It was trained on the `sep_count` task of the Wsj0MixVar dataset.
  
 ## Training config:
 ```yaml
@@ -51,7 +51,7 @@ optim:
 data:
   train_dir: "data/{}speakers/wav8k/min/tr"
   valid_dir: "data/{}speakers/wav8k/min/cv"
-  task: sep_clean
+  task: sep_count
   sample_rate: 8000
   seglen: 4.0
   minlen: 2.0

create-speaker-mixtures-2345/create-speaker-mixtures-2345/activlev.m

@@ -0,0 +1,345 @@
+function [lev,af,fso,vad]=activlev(sp,fs,mode)
+%ACTIVLEV Measure active speech level as in ITU-T P.56 [LEV,AF,FSO]=(sp,FS,MODE)
+%
+%Usage: (1) lev=activlev(s,fs);     % speech level in units of power
+%       (2) db=activlev(s,fs,'d');  % speech level in dB
+%       (3) s=activlev(s,fs,'n');   % normalize active level to 0 dB
+%
+%Inputs: sp     is the speech signal (with better than 20dB SNR)
+%        FS     is the sample frequency in Hz (see also FSO below)
+%        MODE   is a combination of the following:
+%               0 - omit high pass filter completely (i.e. include DC)
+%               3 - high pass filter at 30 Hz instead of 200 Hz (but allows mains hum to pass)
+%               4 - high pass filter at 40 Hz instead of 200 Hz (but allows mains hum to pass)
+%               1 - use cheybyshev 1 filter
+%               2 - use chebyshev 2 filter (default)
+%               e - use elliptic filter
+%               h - omit low pass filter at 5.5, 12 or 18 kHz
+%               w - use wideband filter frequencies: 70 Hz to 12 kHz
+%               W - use ultra wideband filter frequencies: 30 Hz to 18 kHz
+%               d - give outputs in dB rather than power
+%               n - output a normalized speech signal as the first argument
+%               N - output a normalized filtered speech signal as the first argument
+%               l - give both active and long-term power levels
+%               a - include A-weighting filter
+%               i - include ITU-R-BS.468/ITU-T-J.16 weighting filter
+%               z - do NOT zero-pad the signal by 0.35 s
+%
+%Outputs:
+%    If the "n" option is specified, a speech signal normalized to 0dB will be given as
+%    the first output followed by the other outputs.
+%        LEV    gives the speech level in units of power (or dB if mode='d')
+%               if mode='l' is specified, LEV is a row vector with the "long term
+%               level" as its second element (this is just the mean power)
+%        AF     is the activity factor (or duty cycle) in the range 0 to 1
+%        FSO    is a column vector of intermediate information that allows
+%               you to process a speech signal in chunks. Thus:
+%                       fso=fs;
+%                       for i=1:inc:nsamp
+%                           [lev,af,fso]=activlev(sp(i:min(i+inc-1,nsamp)),fso,['z' mode]);
+%                       end
+%                       lev=activlev([],fso)
+%               is equivalent to:
+%                       lev=activlev(sp(1:nsamp),fs,mode)
+%               but is much slower. The two methods will not give identical results
+%               because they will use slightly different thresholds. Note you need
+%               the 'z' option for all calls except the last.
+%        VAD    is a boolean vector the same length as sp that acts as an approximate voice activity detector
+
+%For completeness we list here the contents of the FSO structure:
+%
+%   ffs : sample frequency
+%   fmd : mode string
+%    nh : hangover time in samples
+%    ae : smoothing filter coefs
+%    abl: HP filter numerator and denominator coefficient
+%    bh : LP filter numerator coefficient
+%    ah : LP filter denominator coefficients
+%    ze : smoothing filter state
+%    zl : HP filter state
+%    zh : LP filter state
+%    zx : hangover max filter state
+%  emax : maximum envelope exponent + 1
+%   ssq : signal sum of squares
+%    ns : number of signal samples
+%    ss : sum of speech samples (not actually used here)
+%    kc : cumulative occupancy counts
+%    aw : weighting filter denominator
+%    bw : weighting filter numerator
+%    zw : weighting filter state
+%
+% This routine implements "Method B" from [1],[2] to calculate the active
+% speech level which is defined to be the speech energy divided by the
+% duration of speech activity. Speech is designated as "active" based on an
+% adaptive threshold applied to the smoothed rectified speech signal. A
+% bandpass filter is first applied to the input speech whose -0.25 dB points
+% are at 200 Hz & 5.5 kHz by default but this can be changed to 70 Hz & 5.5 kHz
+% or to 30 Hz & 18 kHz by specifying the 'w' or 'W' options; these
+% correspond respectively to Annexes B and C in [2].
+%
+% References:
+% [1]	ITU-T. Objective measurement of active speech level. Recommendation P.56, Mar. 1993.
+% [2]	ITU-T. Objective measurement of active speech level. Recommendation P.56, Dec. 2011.
+
+%      Copyright (C) Mike Brookes 2008-2016
+%      Version: $Id: activlev.m 9407 2017-02-07 13:25:55Z dmb $
+%
+%   VOICEBOX is a MATLAB toolbox for speech processing.
+%   Home page: http://www.ee.ic.ac.uk/hp/staff/dmb/voicebox/voicebox.html
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%   This program is free software; you can redistribute it and/or modify
+%   it under the terms of the GNU General Public License as published by
+%   the Free Software Foundation; either version 2 of the License, or
+%   (at your option) any later version.
+%
+%   This program is distributed in the hope that it will be useful,
+%   but WITHOUT ANY WARRANTY; without even the implied warranty of
+%   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%   GNU General Public License for more details.
+%
+%   You can obtain a copy of the GNU General Public License from
+%   http://www.gnu.org/copyleft/gpl.html or by writing to
+%   Free Software Foundation, Inc.,675 Mass Ave, Cambridge, MA 02139, USA.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+persistent nbin thresh c25zp c15zp e5zp
+if isempty(nbin)
+    nbin=20;    % 60 dB range at 3dB per bin
+    thresh=15.9;    % threshold in dB
+    % High pass s-domain zeros and poles of filters with passband ripple<0.25dB, stopband<-50dB, w0=1
+    %    w0=fzero(@ch2,0.5); [c2z,c2p,k]=cheby2(5,50,w0,'high','s');
+    %    function v=ch2(w); [c2z,c2p,k]=cheby2(5,50,w,'high','s'); v= 20*log10(prod(abs(1i-c2z))/prod(abs(1i-c2p)))+0.25;
+    c25zp=[0.37843443673309i 0.23388534441447i; -0.20640255179496+0.73942185906851i -0.54036889596392+0.45698784092898i];
+    c25zp=[[0; -0.66793268833792] c25zp conj(c25zp)];
+    %       [c1z,c1p,c1k] = cheby1(5,0.25,1,'high','s');
+    c15zp=[-0.659002835294875+1.195798636925079i -0.123261821596263+0.947463030958881i];
+    c15zp=[zeros(1,5); -2.288586431066945 c15zp conj(c15zp)];
+    %      [ez,ep,ek] = ellip(5,0.25,50,1,'high','s')
+    e5zp=[0.406667680649209i 0.613849362744881i; -0.538736390607201+1.130245082677107i -0.092723126159100+0.958193646330194i];
+    e5zp=[[0; -1.964538608244084]  e5zp conj(e5zp)];
+    %    w=linspace(0.2,2,100);
+    %    figure(1); plot(w,20*log10(abs(freqs(real(poly(c15zp(1,:))),real(poly(c15zp(2,:))),w)))); title('Chebyshev 1');
+    %    figure(2); plot(w,20*log10(abs(freqs(real(poly(c25zp(1,:))),real(poly(c25zp(2,:))),w)))); title('Chebyshev 2');
+    %    figure(3); plot(w,20*log10(abs(freqs(real(poly(e5zp(1,:))),real(poly(e5zp(2,:))),w)))); title('Elliptic');
+end
+
+if ~isstruct(fs)                        % no state vector given
+    if nargin<3
+        mode=' ';
+    end
+    fso.ffs=fs;                       	% sample frequency
+    
+    ti=1/fs;
+    g=exp(-ti/0.03);                    % pole position for envelope filter
+    fso.ae=[1 -2*g g^2]/(1-g)^2;        % envelope filter coefficients (DC gain = 1)
+    fso.ze=zeros(2,1);
+    fso.nh=ceil(0.2/ti)+1;              % hangover time in samples
+    fso.zx=-Inf;                        % initial value for maxfilt()
+    fso.emax=-Inf;                      % maximum exponent
+    fso.ns=0;
+    fso.ssq=0;
+    fso.ss=0;
+    fso.kc=zeros(nbin,1);               % cumulative occupancy counts
+    % s-plane zeros and poles of high pass 5'th order filter -0.25dB at w=1 and -50dB stopband
+    if any(mode=='1')
+        szp=c15zp;              % Chebyshev 1
+    elseif any(mode=='e')
+        szp=e5zp;               % Elliptic
+    else
+        szp=c25zp;              % Chebyshev 2
+    end
+    flh=[200 5500];             % default frequency range +- 0.25 dB
+    if any(mode=='w')
+        flh=[70 12000];         % super-wideband (Annex B of [2])
+    elseif any(mode=='W')
+        flh=[30 18000];         % full band (Annex C of [2])
+    end
+    if any(mode=='3')
+        flh(1)=30;              % force a 30 Hz HPF cutoff
+    end
+    if any(mode=='4')
+        flh(1)=40;              % force a 40 Hz HPF cutoff
+    end
+    if any(mode=='r')          	% included for backward compatibility
+        mode=['0h' mode];    	% abolish both filters
+    elseif fs<flh(2)*2.2
+        mode=['h' mode];       	% abolish lowpass filter at low sample rates
+    end
+    fso.fmd=mode;            	% save mode flags
+    if all(mode~='0')           % implement the HPF as biquads to avoid rounding errors
+        zl=2./(1-szp*tan(flh(1)*pi/fs))-1;      % Transform s-domain poles/zeros with bilinear transform
+        abl=[ones(2,1) -zl(:,1) -2*real(zl(:,2:3))  abs(zl(:,2:3)).^2];     % biquad coefficients
+        hfg=(abl*[1 -1 0 0 0 0]').*(abl*[1 0 -1 0 1 0]').*(abl*[1 0 0 -1 0 1]');
+        abl=abl(:,[1 2 1 3 5 1 4 6]);               % reorder into biquads
+        abl(1,1:2)= abl(1,1:2)*hfg(2)/hfg(1);       % force Nyquist gain to equal 1
+        fso.abl=abl;
+        fso.zl=zeros(5,1);                          % space for HPF filter state
+    end
+    if all(mode~='h')
+        zh=2./(szp/tan(flh(2)*pi/fs)-1)+1;     % Transform s-domain poles/zeros with bilinear transform
+        ah=real(poly(zh(2,:)));
+        bh=real(poly(zh(1,:)));
+        fso.bh=bh*sum(ah)/sum(bh);
+        fso.ah=ah;
+        fso.zh=zeros(5,1);
+    end
+    if any(mode=='a')
+        [fso.bw,fso.aw]=stdspectrum(2,'z',fs);
+        fso.zw=zeros(length(fso.aw)-1,1);
+    elseif any(mode=='i')
+        [fso.bw,fso.aw]=stdspectrum(8,'z',fs);
+        fso.zw=zeros(length(fso.aw)-1,1);
+    end
+else
+    fso=fs;             % use existing structure
+end
+md=fso.fmd;
+if nargin<3
+    mode=fso.fmd;
+end
+nsp=length(sp); % original length of speech
+if all(mode~='z')
+    nz=ceil(0.35*fso.ffs); % number of zeros to append
+    sp=[sp(:);zeros(nz,1)];
+else
+    nz=0;
+end
+ns=length(sp);
+if ns                       % process this speech chunk
+    % apply the input filters to the speech
+    if all(md~='0')         % implement the HPF as biquads to avoid rounding errors
+        [sq,fso.zl(1)]=filter(fso.abl(1,1:2),fso.abl(2,1:2),sp(:),fso.zl(1));       % highpass filter: real pole/zero
+        [sq,fso.zl(2:3)]=filter(fso.abl(1,3:5),fso.abl(2,3:5),sq(:),fso.zl(2:3));  	% highpass filter: biquad 1
+        [sq,fso.zl(4:5)]=filter(fso.abl(1,6:8),fso.abl(2,6:8),sq(:),fso.zl(4:5));  	% highpass filter: biquad 2
+    else
+        sq=sp(:);
+    end
+    if all(md~='h')
+        [sq,fso.zh]=filter(fso.bh,fso.ah,sq(:),fso.zh);     % lowpass filter
+    end
+    if any(md=='a') || any(md=='i')
+        [sq,fso.zw]=filter(fso.bw,fso.aw,sq(:),fso.zw);     % weighting filter
+    end
+    fso.ns=fso.ns+ns;                               % count the number of speech samples
+    fso.ss=fso.ss+sum(sq);                          % sum of speech samples
+    fso.ssq=fso.ssq+sum(sq.*sq);                    % sum of squared speech samples
+    [s,fso.ze]=filter(1,fso.ae,abs(sq(:)),fso.ze); 	% envelope filter
+    [qf,qe]=log2(s.^2);                             % take efficient log2 function, 2^qe is upper limit of bin
+    qe(qf==0)=-Inf;                                 % fix zero values
+    [qe,qk,fso.zx]=maxfilt(qe,1,fso.nh,1,fso.zx);  	% apply the 0.2 second hangover
+    oemax=fso.emax;
+    fso.emax=max(oemax,max(qe)+1);
+    if fso.emax==-Inf
+        fso.kc(1)=fso.kc(1)+ns;
+    else
+        qe=min(fso.emax-qe,nbin);   % force in the range 1:nbin. Bin k has 2^(emax-k-1)<=s^2<=2^(emax-k)
+        wqe=ones(length(qe),1);
+        % below: could use kc=cumsum(accumarray(qe,wqe,nbin)) but unsure about backwards compatibility
+        kc=cumsum(full(sparse(qe,wqe,wqe,nbin,1)));     % cumulative occupancy counts
+        esh=fso.emax-oemax;                             % amount to shift down previous bin counts
+        if esh<nbin-1                                   % if any of the previous bins are worth keeping
+            kc(esh+1:nbin-1)=kc(esh+1:nbin-1)+fso.kc(1:nbin-esh-1);
+            kc(nbin)=kc(nbin)+sum(fso.kc(nbin-esh:nbin));
+        else
+            kc(nbin)=kc(nbin)+sum(fso.kc); % otherwise just add all old counts into the last (lowest) bin
+        end
+        fso.kc=kc;
+    end
+end
+if fso.ns                       % now calculate the output values
+    if fso.ssq>0
+        aj=10*log10(fso.ssq*(fso.kc).^(-1));
+        % equivalent to cj=20*log10(sqrt(2).^(fso.emax-(1:nbin)-1));
+        cj=10*log10(2)*(fso.emax-(1:nbin)-1);               % lower limit of bin j in dB
+        mj=aj'-cj-thresh;
+        %  jj=find(mj*sign(mj(1))<=0); % Find threshold
+        jj=find(mj(1:end-1)<0 &  mj(2:end)>=0,1);           % find +ve transition through threshold
+        if isempty(jj)                                      % if we never cross the threshold
+            if mj(end)<=0                                   % if we end up below if
+                jj=length(mj)-1;            % take the threshold to be the bottom of the last (lowest) bin
+                jf=1;
+            else                            % if we are always above it
+                jj=1;                       % take the threshold to be the bottom of the first (highest) bin
+                jf=0;
+            end
+        else
+            jf=1/(1-mj(jj+1)/mj(jj));       % fractional part of j using linear interpolation
+        end
+        lev=aj(jj)+jf*(aj(jj+1)-aj(jj));    % active level in decibels
+        lp=10.^(lev/10);                    % active level in power
+        if any(md=='d')                     % 'd' option -> output in dB
+            lev=[lev 10*log10(fso.ssq/fso.ns)];
+        else                                % ~'d' option -> output in power
+            lev=[lp fso.ssq/fso.ns];
+        end
+        af=fso.ssq/(fso.ns*lp);
+    else                        % if all samples are equal to zero
+        af=0;
+        if any(md=='d')         % 'd' option -> output in dB
+            lev=[-Inf -Inf];    % active level is 0 dB
+        else                    % ~'d' option -> output in power
+            lev=[0 0];          % active level is 0 power
+        end
+    end
+    if all(md~='l')
+        lev=lev(1);         % only output the first element of lev unless 'l' option
+    end
+end
+if nargout>3
+    vad=maxfilt(s(1:nsp),1,fso.nh,1);
+    vad=vad>(sqrt(lp)/10^(thresh/20));
+end
+if ~nargout
+    vad=maxfilt(s,1,fso.nh,1);
+    vad=vad>(sqrt(lp)/10^(thresh/20));
+    levdb=10*log10(lp);
+    clf;
+    subplot(2,2,[1 2]);
+    tax=(1:ns)/fso.ffs;
+    plot(tax,sp,'-y',tax,s,'-r',tax,(vad>0)*sqrt(lp),'-b');
+    xlabel('Time (s)');
+    title(sprintf('Active Level = %.2g dB, Activity = %.0f%% (ITU-T P.56)',levdb,100*af));
+    axisenlarge([-1 -1 -1.4 -1.05]);
+    if nz>0
+        hold on
+        ylim=get(gca,'ylim');
+        plot(tax(end-nz)*[1 1],ylim,':k');
+        hold off
+    end
+    ylabel('Amplitude');
+    legend('Signal','Smoothed envelope','VAD * Active-Level','Location','SouthEast');
+    subplot(2,2,4);
+    plot(cj,repmat(levdb,nbin,1),'k:',cj,aj(:),'-b',cj,cj,'-r',levdb-thresh*ones(1,2),[levdb-thresh levdb],'-r');
+    xlabel('Threshold (dB)');
+    ylabel('Active Level (dB)');
+    legend('Active Level','Speech>Thresh','Threshold','Location','NorthWest');
+    texthvc(levdb-thresh,levdb-0.5*thresh,sprintf('%.1f dB ',thresh),'rmr');
+    axisenlarge([-1 -1.05]);
+    ylim=get(gca,'ylim');
+    set(gca,'ylim',[levdb-1.2*thresh max(ylim(2),levdb+1.9*thresh)]);
+    kch=filter([1 -1],1,kc);
+    subplot(2,2,3);
+    bar(5*log10(2)+cj(end:-1:1),kch(end:-1:1)*100/kc(end));
+    set(gca,'xlim',[cj(end) cj(1)+10*log10(2)]);
+    ylim=get(gca,'ylim');
+    hold on
+    plot(lev([1 1]),ylim,'k:',lev([1 1])-thresh,ylim,'r:');
+    hold off
+    texthvc(lev(1),ylim(2),sprintf(' Act\n Lev'),'ltk');
+    texthvc(lev(1)-thresh,ylim(2),sprintf('Threshold '),'rtr');
+    xlabel('Frame power (dB)')
+    ylabel('% frames');
+elseif any(md=='n') || any(md=='N') % output normalized speech waveform
+    fsx=fso; % shift along other outputs
+    fso=af;
+    af=lev;
+    if any(md=='n')
+        sq=sp; % 'n' -> use unfiltered speech
+    end
+    if fsx.ns>0 && fsx.ssq>0 % if there has been any non-zero speech
+        lev=sq(1:nsp)/sqrt(lp);
+    else
+        lev=sq(1:nsp);
+    end
+end

create-speaker-mixtures-2345/create-speaker-mixtures-2345/create_wav_2speakers.m

@@ -0,0 +1,188 @@
+% create_wav_2_speakers.m
+%
+% Create 2-speaker mixtures
+% 
+% This script assumes that WSJ0's wv1 sphere files have already
+% been converted to wav files, using the original folder structure
+% under wsj0/, e.g., 
+% 11-1.1/wsj0/si_tr_s/01t/01to030v.wv1 is converted to wav and 
+% stored in YOUR_PATH/wsj0/si_tr_s/01t/01to030v.wav, and
+% 11-6.1/wsj0/si_dt_05/050/050a0501.wv1 is converted to wav and
+% stored in YOUR_PATH/wsj0/si_dt_05/050/050a0501.wav.
+% Relevant data from all disks are assumed merged under YOUR_PATH/wsj0/
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%   Copyright (C) 2016 Mitsubishi Electric Research Labs 
+%                          (Jonathan Le Roux, John R. Hershey, Zhuo Chen)
+%   Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0) 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+data_type = {'tr','cv','tt'};
+wsj0root = '/home/joseph/Desktop/WSJ0/'; % YOUR_PATH/, the folder containing wsj0/
+output_dir16k='/home/joseph/Desktop/WSJ0/dataset/2speakers/wav16k';
+output_dir8k='/home/joseph/Desktop/WSJ0/dataset/2speakers/wav8k';
+
+min_max = {'min'};
+
+useaudioread = 0;
+if exist('audioread','file')
+    useaudioread = 1;
+end
+
+for i_mm = 1:length(min_max)
+    for i_type = 1:length(data_type)
+        if ~exist([output_dir16k '/' min_max{i_mm} '/' data_type{i_type}],'dir')
+            mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type}]);
+        end
+        if ~exist([output_dir8k '/' min_max{i_mm} '/' data_type{i_type}],'dir')
+            mkdir([output_dir8k '/' min_max{i_mm} '/' data_type{i_type}]);
+        end
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s1/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s2/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/mix/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s1/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s2/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/mix/']);
+                
+        TaskFile = ['mix_2_spk_' data_type{i_type} '.txt'];
+        fid=fopen(TaskFile,'r');
+        C=textscan(fid,'%s %f %s %f');
+        
+        Source1File = ['mix_2_spk_' min_max{i_mm} '_' data_type{i_type} '_1'];
+        Source2File = ['mix_2_spk_' min_max{i_mm} '_' data_type{i_type} '_2'];
+        MixFile     = ['mix_2_spk_' min_max{i_mm} '_' data_type{i_type} '_mix'];
+        
+        fid_s1 = fopen(Source1File,'w');
+        fid_s2 = fopen(Source2File,'w');
+        fid_m  = fopen(MixFile,'w');
+        
+        num_files = length(C{1});
+        fs8k=8000;
+        
+        scaling_16k = zeros(num_files,2);
+        scaling_8k = zeros(num_files,2);
+        scaling16bit_16k = zeros(num_files,1);
+        scaling16bit_8k = zeros(num_files,1);
+        fprintf(1,'%s\n',[min_max{i_mm} '_' data_type{i_type}]);
+        for i = 1:num_files
+            [inwav1_dir,invwav1_name,inwav1_ext] = fileparts(C{1}{i});
+            [inwav2_dir,invwav2_name,inwav2_ext] = fileparts(C{3}{i});
+            fprintf(fid_s1,'%s\n',C{1}{i});
+            fprintf(fid_s2,'%s\n',C{3}{i});
+            inwav1_snr = C{2}(i);
+            inwav2_snr = C{4}(i);
+            mix_name = [invwav1_name,'_',num2str(inwav1_snr),'_',invwav2_name,'_',num2str(inwav2_snr)];
+            fprintf(fid_m,'%s\n',mix_name);
+                        
+            % get input wavs
+            if useaudioread
+                [s1, fs] = audioread([wsj0root C{1}{i}]);
+                s2       = audioread([wsj0root C{3}{i}]);
+            else                
+                [s1, fs] = wavread([wsj0root C{1}{i}]); %#ok<*DWVRD>
+                s2       = wavread([wsj0root C{3}{i}]);            
+            end
+            
+            % resample, normalize 8 kHz file, save scaling factor
+            s1_8k=resample(s1,fs8k,fs);
+            [s1_8k,lev1]=activlev(s1_8k,fs8k,'n'); % y_norm = y /sqrt(lev);
+            s2_8k=resample(s2,fs8k,fs);
+            [s2_8k,lev2]=activlev(s2_8k,fs8k,'n');
+                        
+            weight_1=10^(inwav1_snr/20);
+            weight_2=10^(inwav2_snr/20);
+            
+            s1_8k = weight_1 * s1_8k;
+            s2_8k = weight_2 * s2_8k;
+            
+            switch min_max{i_mm}
+                case 'max'
+                    mix_8k_length = max(length(s1_8k),length(s2_8k));
+                    s1_8k = cat(1,s1_8k,zeros(mix_8k_length - length(s1_8k),1));
+                    s2_8k = cat(1,s2_8k,zeros(mix_8k_length - length(s2_8k),1));
+                case 'min'
+                    mix_8k_length = min(length(s1_8k),length(s2_8k));
+                    s1_8k = s1_8k(1:mix_8k_length);
+                    s2_8k = s2_8k(1:mix_8k_length);
+            end
+            mix_8k = s1_8k + s2_8k;
+                    
+            max_amp_8k = max(cat(1,abs(mix_8k(:)),abs(s1_8k(:)),abs(s2_8k(:))));
+            mix_scaling_8k = 1/max_amp_8k*0.9;
+            s1_8k = mix_scaling_8k * s1_8k;
+            s2_8k = mix_scaling_8k * s2_8k;
+            mix_8k = mix_scaling_8k * mix_8k;
+            
+            % apply same gain to 16 kHz file
+            s1_16k = weight_1 * s1 / sqrt(lev1);
+            s2_16k = weight_2 * s2 / sqrt(lev2);
+            
+            switch min_max{i_mm}
+                case 'max'
+                    mix_16k_length = max(length(s1_16k),length(s2_16k));
+                    s1_16k = cat(1,s1_16k,zeros(mix_16k_length - length(s1_16k),1));
+                    s2_16k = cat(1,s2_16k,zeros(mix_16k_length - length(s2_16k),1));
+                case 'min'
+                    mix_16k_length = min(length(s1_16k),length(s2_16k));
+                    s1_16k = s1_16k(1:mix_16k_length);
+                    s2_16k = s2_16k(1:mix_16k_length);
+            end
+            mix_16k = s1_16k + s2_16k;
+            
+            max_amp_16k = max(cat(1,abs(mix_16k(:)),abs(s1_16k(:)),abs(s2_16k(:))));
+            mix_scaling_16k = 1/max_amp_16k*0.9;
+            s1_16k = mix_scaling_16k * s1_16k;
+            s2_16k = mix_scaling_16k * s2_16k;
+            mix_16k = mix_scaling_16k * mix_16k;            
+            
+            % save 8 kHz and 16 kHz mixtures, as well as
+            % necessary scaling factors
+            
+            scaling_16k(i,1) = weight_1 * mix_scaling_16k/ sqrt(lev1);
+            scaling_16k(i,2) = weight_2 * mix_scaling_16k/ sqrt(lev2);
+            scaling_8k(i,1) = weight_1 * mix_scaling_8k/ sqrt(lev1);
+            scaling_8k(i,2) = weight_2 * mix_scaling_8k/ sqrt(lev2);
+            
+            scaling16bit_16k(i) = mix_scaling_16k;
+            scaling16bit_8k(i)  = mix_scaling_8k;
+            
+            if useaudioread                          
+                s1_8k = int16(round((2^15)*s1_8k));
+                s2_8k = int16(round((2^15)*s2_8k));
+                mix_8k = int16(round((2^15)*mix_8k));
+                s1_16k = int16(round((2^15)*s1_16k));
+                s2_16k = int16(round((2^15)*s2_16k));
+                mix_16k = int16(round((2^15)*mix_16k));
+                audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s1/' mix_name '.wav'],s1_8k,fs8k);
+                audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s1/' mix_name '.wav'],s1_16k,fs);
+                audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s2/' mix_name '.wav'],s2_8k,fs8k);
+                audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s2/' mix_name '.wav'],s2_16k,fs);
+                audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/mix/' mix_name '.wav'],mix_8k,fs8k);
+                audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/mix/' mix_name '.wav'],mix_16k,fs);
+            else
+                wavwrite(s1_8k,fs8k,[output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s1/' mix_name '.wav']); %#ok<*DWVWR>
+                wavwrite(s1_16k,fs,[output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s1/' mix_name '.wav']);
+                wavwrite(s2_8k,fs8k,[output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s2/' mix_name '.wav']);
+                wavwrite(s2_16k,fs,[output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s2/' mix_name '.wav']);
+                wavwrite(mix_8k,fs8k,[output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/mix/' mix_name '.wav']);
+                wavwrite(mix_16k,fs,[output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/mix/' mix_name '.wav']);
+            end
+            
+            if mod(i,10)==0
+                fprintf(1,'.');
+                if mod(i,200)==0
+                    fprintf(1,'\n');
+                end
+            end
+            
+        end
+        save([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/scaling.mat'],'scaling_8k','scaling16bit_8k');
+        save([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/scaling.mat'],'scaling_16k','scaling16bit_16k');
+        
+        fclose(fid);
+        fclose(fid_s1);
+        fclose(fid_s2);
+        fclose(fid_m);
+    end
+end

create-speaker-mixtures-2345/create-speaker-mixtures-2345/create_wav_3speakers.m

@@ -0,0 +1,188 @@
+% create_wav_3_speakers.m
+%
+% Create 3-speaker mixtures
+% 
+% This script assumes that WSJ0's wv1 sphere files have already
+% been converted to wav files, using the original folder structure
+% under wsj0/, e.g., 
+% 11-1.1/wsj0/si_tr_s/01t/01to030v.wv1 is converted to wav and 
+% stored in YOUR_PATH/wsj0/si_tr_s/01t/01to030v.wav, and
+% 11-6.1/wsj0/si_dt_05/050/050a0501.wv1 is converted to wav and
+% stored in YOUR_PATH/wsj0/si_dt_05/050/050a0501.wav.
+% Relevant data from all disks are assumed merged under YOUR_PATH/wsj0/
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%   Copyright (C) 2016 Mitsubishi Electric Research Labs 
+%                          (Jonathan Le Roux, John R. Hershey, Zhuo Chen)
+%   Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0) 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%addpath('./voicebox')
+data_type = {'tr','cv','tt'};
+wsj0root = '/home/joseph/Desktop/WSJ0/'; % YOUR_PATH/,  the folder containing wsj0/
+output_dir16k='/home/joseph/Desktop/WSJ0/dataset/3speakers/wav16k';
+output_dir8k='/home/joseph/Desktop/WSJ0/dataset/3speakers/wav8k';
+
+min_max = {'min'}; %{'min','max'};
+
+for i_mm = 1:length(min_max)
+    for i_type = 1:length(data_type)
+        if ~exist([output_dir16k '/' min_max{i_mm} '/' data_type{i_type}],'dir')
+            mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type}]);
+        end
+        if ~exist([output_dir8k '/' min_max{i_mm} '/' data_type{i_type}],'dir')
+            mkdir([output_dir8k '/' min_max{i_mm} '/' data_type{i_type}]);
+        end
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s1/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s2/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s3/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/mix/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s1/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s2/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s3/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/mix/']);
+                
+        TaskFile = ['mix_3_spk_' data_type{i_type} '.txt'];
+        fid=fopen(TaskFile,'r');
+        C=textscan(fid,'%s %f %s %f %s %f');
+        
+        Source1File = ['mix_3_spk_' min_max{i_mm} '_' data_type{i_type} '_1'];
+        Source2File = ['mix_3_spk_' min_max{i_mm} '_' data_type{i_type} '_2'];
+        Source3File = ['mix_3_spk_' min_max{i_mm} '_' data_type{i_type} '_3'];
+        MixFile     = ['mix_3_spk_' min_max{i_mm} '_' data_type{i_type} '_mix'];
+        fid_s1 = fopen(Source1File,'w');
+        fid_s2 = fopen(Source2File,'w');
+        fid_s3 = fopen(Source3File,'w');
+        fid_m  = fopen(MixFile,'w');
+        
+        num_files = length(C{1});
+        fs8k=8000;
+        
+        scaling_16k = zeros(num_files,3);
+        scaling_8k = zeros(num_files,3);
+        scaling16bit_16k = zeros(num_files,1);
+        scaling16bit_8k = zeros(num_files,1);
+        fprintf(1,'%s\n',[min_max{i_mm} '_' data_type{i_type}]);
+        for i = 1:num_files
+            [inwav1_dir,invwav1_name,inwav1_ext] = fileparts(C{1}{i});
+            [inwav2_dir,invwav2_name,inwav2_ext] = fileparts(C{3}{i});
+            [inwav3_dir,invwav3_name,inwav3_ext] = fileparts(C{5}{i});
+            fprintf(fid_s1,'%s\n',C{1}{i});%[inwav1_dir,'/',invwav1_name,inwav1_ext]);
+            fprintf(fid_s2,'%s\n',C{3}{i});%[inwav2_dir,'/',invwav2_name,inwav2_ext]);
+            fprintf(fid_s3,'%s\n',C{5}{i});%[inwav3_dir,'/',invwav3_name,inwav3_ext]);
+            inwav1_snr = C{2}(i);
+            inwav2_snr = C{4}(i);
+            inwav3_snr = C{6}(i);
+            mix_name = [invwav1_name,'_',num2str(inwav1_snr),...
+                        '_',invwav2_name,'_',num2str(inwav2_snr),...
+                        '_',invwav3_name,'_',num2str(inwav3_snr)];
+            fprintf(fid_m,'%s\n',mix_name);
+            
+            % get input wavs
+            [s1, fs] = audioread([wsj0root C{1}{i}]);
+            s2       = audioread([wsj0root C{3}{i}]);
+            s3       = audioread([wsj0root C{5}{i}]);
+            
+            % resample, normalize 8 kHz file, save scaling factor
+            s1_8k=resample(s1,fs8k,fs);
+            [s1_8k,lev1]=activlev(s1_8k,fs8k,'n'); % y_norm = y /sqrt(lev);
+            s2_8k=resample(s2,fs8k,fs);
+            [s2_8k,lev2]=activlev(s2_8k,fs8k,'n');
+            s3_8k=resample(s3,fs8k,fs);
+            [s3_8k,lev3]=activlev(s3_8k,fs8k,'n');
+            
+            weight_1=10^(inwav1_snr/20);
+            weight_2=10^(inwav2_snr/20);
+            weight_3=10^(inwav3_snr/20);
+            
+            s1_8k = weight_1 * s1_8k;
+            s2_8k = weight_2 * s2_8k;
+            s3_8k = weight_3 * s3_8k;
+            
+            switch min_max{i_mm}
+                case 'max'
+                    mix_8k_length = max([length(s1_8k),length(s2_8k),length(s3_8k)]);
+                    s1_8k = cat(1,s1_8k,zeros(mix_8k_length - length(s1_8k),1));
+                    s2_8k = cat(1,s2_8k,zeros(mix_8k_length - length(s2_8k),1));
+                    s3_8k = cat(1,s3_8k,zeros(mix_8k_length - length(s3_8k),1));
+                case 'min'
+                    mix_8k_length = min([length(s1_8k),length(s2_8k),length(s3_8k)]);
+                    s1_8k = s1_8k(1:mix_8k_length);
+                    s2_8k = s2_8k(1:mix_8k_length);
+                    s3_8k = s3_8k(1:mix_8k_length);
+            end
+            mix_8k = s1_8k + s2_8k + s3_8k;
+                    
+            max_amp_8k = max(cat(1,abs(mix_8k(:)),abs(s1_8k(:)),abs(s2_8k(:)),abs(s3_8k(:))));
+            mix_scaling_8k = 1/max_amp_8k*0.9;
+            s1_8k = mix_scaling_8k * s1_8k;
+            s2_8k = mix_scaling_8k * s2_8k;
+            s3_8k = mix_scaling_8k * s3_8k;
+            mix_8k = mix_scaling_8k * mix_8k;
+            
+            % apply same gain to 16 kHz file
+            s1_16k = weight_1 * s1 / sqrt(lev1);
+            s2_16k = weight_2 * s2 / sqrt(lev2);
+            s3_16k = weight_3 * s3 / sqrt(lev3);
+            
+            switch min_max{i_mm}
+                case 'max'
+                    mix_16k_length = max([length(s1_16k),length(s2_16k),length(s3_16k)]);
+                    s1_16k = cat(1,s1_16k,zeros(mix_16k_length - length(s1_16k),1));
+                    s2_16k = cat(1,s2_16k,zeros(mix_16k_length - length(s2_16k),1));
+                    s3_16k = cat(1,s3_16k,zeros(mix_16k_length - length(s3_16k),1));
+                case 'min'
+                    mix_16k_length = min([length(s1_16k),length(s2_16k),length(s3_16k)]);
+                    s1_16k = s1_16k(1:mix_16k_length);
+                    s2_16k = s2_16k(1:mix_16k_length);
+                    s3_16k = s3_16k(1:mix_16k_length);
+            end
+            mix_16k = s1_16k + s2_16k + s3_16k;
+            
+            max_amp_16k = max(cat(1,abs(mix_16k(:)),abs(s1_16k(:)),abs(s2_16k(:)),abs(s3_16k(:))));
+            mix_scaling_16k = 1/max_amp_16k*0.9;
+            s1_16k = mix_scaling_16k * s1_16k;
+            s2_16k = mix_scaling_16k * s2_16k;
+            s3_16k = mix_scaling_16k * s3_16k;
+            mix_16k = mix_scaling_16k * mix_16k;
+            
+            % save 8 kHz and 16 kHz mixtures, as well as
+            % necessary scaling factors
+            
+            scaling_16k(i,1) = weight_1 * mix_scaling_16k/ sqrt(lev1);
+            scaling_16k(i,2) = weight_2 * mix_scaling_16k/ sqrt(lev2);
+            scaling_16k(i,3) = weight_3 * mix_scaling_16k/ sqrt(lev3);
+            scaling_8k(i,1) = weight_1 * mix_scaling_8k/ sqrt(lev1);
+            scaling_8k(i,2) = weight_2 * mix_scaling_8k/ sqrt(lev2);
+            scaling_8k(i,3) = weight_3 * mix_scaling_8k/ sqrt(lev3);
+            
+            scaling16bit_16k(i) = mix_scaling_16k;
+            scaling16bit_8k(i)  = mix_scaling_8k;
+            
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s1/' mix_name '.wav'], s1_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s1/' mix_name '.wav'], s1_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s2/' mix_name '.wav'], s2_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s2/' mix_name '.wav'], s2_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s3/' mix_name '.wav'], s3_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s3/' mix_name '.wav'], s3_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/mix/' mix_name '.wav'], mix_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/mix/' mix_name '.wav'], mix_16k,fs);
+            
+            if mod(i,10)==0
+                fprintf(1,'.');
+                if mod(i,200)==0
+                    fprintf(1,'\n');
+                end
+            end
+            
+        end
+        save([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/scaling.mat'],'scaling_8k','scaling16bit_8k');
+        save([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/scaling.mat'],'scaling_16k','scaling16bit_16k');
+        
+        fclose(fid);
+        fclose(fid_s1);
+        fclose(fid_s2);
+        fclose(fid_s3);
+        fclose(fid_m);
+    end
+end

create-speaker-mixtures-2345/create-speaker-mixtures-2345/create_wav_4speakers.m

@@ -0,0 +1,214 @@
+% create_wav_3_speakers.m
+%
+% Create 3-speaker mixtures
+% 
+% This script assumes that WSJ0's wv1 sphere files have already
+% been converted to wav files, using the original folder structure
+% under wsj0/, e.g., 
+% 11-1.1/wsj0/si_tr_s/01t/01to030v.wv1 is converted to wav and 
+% stored in YOUR_PATH/wsj0/si_tr_s/01t/01to030v.wav, and
+% 11-6.1/wsj0/si_dt_05/050/050a0501.wv1 is converted to wav and
+% stored in YOUR_PATH/wsj0/si_dt_05/050/050a0501.wav.
+% Relevant data from all disks are assumed merged under YOUR_PATH/wsj0/
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%   Copyright (C) 2016 Mitsubishi Electric Research Labs 
+%                          (Jonathan Le Roux, John R. Hershey, Zhuo Chen)
+%   Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0) 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%addpath('./voicebox')
+data_type = {'tr','cv','tt'};
+wsj0root = '/home/joseph/Desktop/WSJ0/'; % YOUR_PATH/,  the folder containing wsj0/
+output_dir16k='/home/joseph/Desktop/WSJ0/dataset/4speakers/wav16k';
+output_dir8k='/home/joseph/Desktop/WSJ0/dataset/4speakers/wav8k';
+
+min_max = {'min'}; %{'min','max'};
+
+for i_mm = 1:length(min_max)
+    for i_type = 1:length(data_type)
+        if ~exist([output_dir16k '/' min_max{i_mm} '/' data_type{i_type}],'dir')
+            mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type}]);
+        end
+        if ~exist([output_dir8k '/' min_max{i_mm} '/' data_type{i_type}],'dir')
+            mkdir([output_dir8k '/' min_max{i_mm} '/' data_type{i_type}]);
+        end
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s1/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s2/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s3/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s4/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/mix/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s1/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s2/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s3/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s4/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/mix/']);
+                
+        TaskFile = ['mix_4_spk_' data_type{i_type} '.txt'];
+        fid=fopen(TaskFile,'r');
+        C=textscan(fid,'%s %f %s %f %s %f %s %f');
+        
+        Source1File = ['mix_4_spk_' min_max{i_mm} '_' data_type{i_type} '_1'];
+        Source2File = ['mix_4_spk_' min_max{i_mm} '_' data_type{i_type} '_2'];
+        Source3File = ['mix_4_spk_' min_max{i_mm} '_' data_type{i_type} '_3'];
+        Source4File = ['mix_4_spk_' min_max{i_mm} '_' data_type{i_type} '_4'];
+        MixFile     = ['mix_4_spk_' min_max{i_mm} '_' data_type{i_type} '_mix'];
+        fid_s1 = fopen(Source1File,'w');
+        fid_s2 = fopen(Source2File,'w');
+        fid_s3 = fopen(Source3File,'w');
+        fid_s4 = fopen(Source4File,'w');
+        fid_m  = fopen(MixFile,'w');
+        
+        num_files = length(C{1});
+        fs8k=8000;
+        
+        scaling_16k = zeros(num_files,3);
+        scaling_8k = zeros(num_files,3);
+        scaling16bit_16k = zeros(num_files,1);
+        scaling16bit_8k = zeros(num_files,1);
+        fprintf(1,'%s\n',[min_max{i_mm} '_' data_type{i_type}]);
+        for i = 1:num_files
+            [inwav1_dir,invwav1_name,inwav1_ext] = fileparts(C{1}{i});
+            [inwav2_dir,invwav2_name,inwav2_ext] = fileparts(C{3}{i});
+            [inwav3_dir,invwav3_name,inwav3_ext] = fileparts(C{5}{i});
+            [inwav4_dir,invwav4_name,inwav4_ext] = fileparts(C{7}{i});
+            fprintf(fid_s1,'%s\n',C{1}{i});%[inwav1_dir,'/',invwav1_name,inwav1_ext]);
+            fprintf(fid_s2,'%s\n',C{3}{i});%[inwav2_dir,'/',invwav2_name,inwav2_ext]);
+            fprintf(fid_s3,'%s\n',C{5}{i});%[inwav3_dir,'/',invwav3_name,inwav3_ext]);
+            fprintf(fid_s4,'%s\n',C{7}{i});%[inwav4_dir,'/',invwav4_name,inwav4_ext]);
+            inwav1_snr = C{2}(i);
+            inwav2_snr = C{4}(i);
+            inwav3_snr = C{6}(i);
+            inwav4_snr = C{8}(i);
+            mix_name = [invwav1_name,'_',num2str(inwav1_snr),...
+                        '_',invwav2_name,'_',num2str(inwav2_snr),...
+                        '_',invwav3_name,'_',num2str(inwav3_snr),...
+                        '_',invwav4_name,'_',num2str(inwav4_snr)];
+            fprintf(fid_m,'%s\n',mix_name);
+            
+            % get input wavs
+            [s1, fs] = audioread([wsj0root C{1}{i}]);
+            s2       = audioread([wsj0root C{3}{i}]);
+            s3       = audioread([wsj0root C{5}{i}]);
+            s4       = audioread([wsj0root C{7}{i}]);
+
+            % resample, normalize 8 kHz file, save scaling factor
+            s1_8k=resample(s1,fs8k,fs);
+            [s1_8k,lev1]=activlev(s1_8k,fs8k,'n'); % y_norm = y /sqrt(lev);
+            s2_8k=resample(s2,fs8k,fs);
+            [s2_8k,lev2]=activlev(s2_8k,fs8k,'n');
+            s3_8k=resample(s3,fs8k,fs);
+            [s3_8k,lev3]=activlev(s3_8k,fs8k,'n');
+            s4_8k=resample(s4,fs8k,fs);
+            [s4_8k,lev4]=activlev(s4_8k,fs8k,'n');
+            
+            weight_1=10^(inwav1_snr/20);
+            weight_2=10^(inwav2_snr/20);
+            weight_3=10^(inwav3_snr/20);
+            weight_4=10^(inwav4_snr/20);
+            
+            s1_8k = weight_1 * s1_8k;
+            s2_8k = weight_2 * s2_8k;
+            s3_8k = weight_3 * s3_8k;
+            s4_8k = weight_4 * s4_8k;
+            
+            switch min_max{i_mm}
+                case 'max'
+                    mix_8k_length = max([length(s1_8k),length(s2_8k),length(s3_8k),length(s4_8k)]);
+                    s1_8k = cat(1,s1_8k,zeros(mix_8k_length - length(s1_8k),1));
+                    s2_8k = cat(1,s2_8k,zeros(mix_8k_length - length(s2_8k),1));
+                    s3_8k = cat(1,s3_8k,zeros(mix_8k_length - length(s3_8k),1));
+                    s4_8k = cat(1,s4_8k,zeros(mix_8k_length - length(s4_8k),1));
+
+                case 'min'
+                    mix_8k_length = min([length(s1_8k),length(s2_8k),length(s3_8k),length(s4_8k)]);
+                    s1_8k = s1_8k(1:mix_8k_length);
+                    s2_8k = s2_8k(1:mix_8k_length);
+                    s3_8k = s3_8k(1:mix_8k_length);
+                    s4_8k = s4_8k(1:mix_8k_length);
+            end
+            mix_8k = s1_8k + s2_8k + s3_8k + s4_8k;
+                    
+            max_amp_8k = max(cat(1,abs(mix_8k(:)),abs(s1_8k(:)),abs(s2_8k(:)),abs(s3_8k(:)),abs(s4_8k(:))));
+            mix_scaling_8k = 1/max_amp_8k*0.9;
+            s1_8k = mix_scaling_8k * s1_8k;
+            s2_8k = mix_scaling_8k * s2_8k;
+            s3_8k = mix_scaling_8k * s3_8k;
+            s4_8k = mix_scaling_8k * s4_8k;
+            mix_8k = mix_scaling_8k * mix_8k;
+            
+            % apply same gain to 16 kHz file
+            s1_16k = weight_1 * s1 / sqrt(lev1);
+            s2_16k = weight_2 * s2 / sqrt(lev2);
+            s3_16k = weight_3 * s3 / sqrt(lev3);
+            s4_16k = weight_4 * s4 / sqrt(lev4);
+            
+            switch min_max{i_mm}
+                case 'max'
+                    mix_16k_length = max([length(s1_16k),length(s2_16k),length(s3_16k),length(s4_16k)]);
+                    s1_16k = cat(1,s1_16k,zeros(mix_16k_length - length(s1_16k),1));
+                    s2_16k = cat(1,s2_16k,zeros(mix_16k_length - length(s2_16k),1));
+                    s3_16k = cat(1,s3_16k,zeros(mix_16k_length - length(s3_16k),1));
+                    s4_16k = cat(1,s4_16k,zeros(mix_16k_length - length(s4_16k),1));
+                case 'min'
+                    mix_16k_length = min([length(s1_16k),length(s2_16k),length(s3_16k),length(s4_16k)]);
+                    s1_16k = s1_16k(1:mix_16k_length);
+                    s2_16k = s2_16k(1:mix_16k_length);
+                    s3_16k = s3_16k(1:mix_16k_length);
+                    s4_16k = s4_16k(1:mix_16k_length);
+            end
+            mix_16k = s1_16k + s2_16k + s3_16k + s4_16k;
+            
+            max_amp_16k = max(cat(1,abs(mix_16k(:)),abs(s1_16k(:)),abs(s2_16k(:)),abs(s3_16k(:)),abs(s4_16k(:))));
+            mix_scaling_16k = 1/max_amp_16k*0.9;
+            s1_16k = mix_scaling_16k * s1_16k;
+            s2_16k = mix_scaling_16k * s2_16k;
+            s3_16k = mix_scaling_16k * s3_16k;
+            s4_16k = mix_scaling_16k * s4_16k;
+            mix_16k = mix_scaling_16k * mix_16k;
+            
+            % save 8 kHz and 16 kHz mixtures, as well as
+            % necessary scaling factors
+            
+            scaling_16k(i,1) = weight_1 * mix_scaling_16k/ sqrt(lev1);
+            scaling_16k(i,2) = weight_2 * mix_scaling_16k/ sqrt(lev2);
+            scaling_16k(i,3) = weight_3 * mix_scaling_16k/ sqrt(lev3);
+            scaling_16k(i,4) = weight_4 * mix_scaling_16k/ sqrt(lev4);
+            scaling_8k(i,1) = weight_1 * mix_scaling_8k/ sqrt(lev1);
+            scaling_8k(i,2) = weight_2 * mix_scaling_8k/ sqrt(lev2);
+            scaling_8k(i,3) = weight_3 * mix_scaling_8k/ sqrt(lev3);
+            scaling_8k(i,4) = weight_4 * mix_scaling_8k/ sqrt(lev4);
+            
+            scaling16bit_16k(i) = mix_scaling_16k;
+            scaling16bit_8k(i)  = mix_scaling_8k;
+            
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s1/' mix_name '.wav'], s1_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s1/' mix_name '.wav'], s1_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s2/' mix_name '.wav'], s2_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s2/' mix_name '.wav'], s2_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s3/' mix_name '.wav'], s3_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s3/' mix_name '.wav'], s3_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s4/' mix_name '.wav'], s4_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s4/' mix_name '.wav'], s4_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/mix/' mix_name '.wav'], mix_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/mix/' mix_name '.wav'], mix_16k,fs);
+            
+            if mod(i,10)==0
+                fprintf(1,'.');
+                if mod(i,200)==0
+                    fprintf(1,'\n');
+                end
+            end
+            
+        end
+        save([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/scaling.mat'],'scaling_8k','scaling16bit_8k');
+        save([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/scaling.mat'],'scaling_16k','scaling16bit_16k');
+        
+        fclose(fid);
+        fclose(fid_s1);
+        fclose(fid_s2);
+        fclose(fid_s3);
+        fclose(fid_s4);
+        fclose(fid_m);
+    end
+end

create-speaker-mixtures-2345/create-speaker-mixtures-2345/create_wav_5speakers.m

@@ -0,0 +1,238 @@
+% create_wav_3_speakers.m
+%
+% Create 3-speaker mixtures
+% 
+% This script assumes that WSJ0's wv1 sphere files have already
+% been converted to wav files, using the original folder structure
+% under wsj0/, e.g., 
+% 11-1.1/wsj0/si_tr_s/01t/01to030v.wv1 is converted to wav and 
+% stored in YOUR_PATH/wsj0/si_tr_s/01t/01to030v.wav, and
+% 11-6.1/wsj0/si_dt_05/050/050a0501.wv1 is converted to wav and
+% stored in YOUR_PATH/wsj0/si_dt_05/050/050a0501.wav.
+% Relevant data from all disks are assumed merged under YOUR_PATH/wsj0/
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%   Copyright (C) 2016 Mitsubishi Electric Research Labs 
+%                          (Jonathan Le Roux, John R. Hershey, Zhuo Chen)
+%   Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0) 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%addpath('./voicebox')
+data_type = {'tr','cv','tt'};
+wsj0root = '/home/joseph/Desktop/WSJ0/'; % YOUR_PATH/,  the folder containing wsj0/
+output_dir16k='/home/joseph/Desktop/WSJ0/dataset/5speakers/wav16k';
+output_dir8k='/home/joseph/Desktop/WSJ0/dataset/5speakers/wav8k';
+
+min_max = {'min'}; %{'min','max'};
+
+for i_mm = 1:length(min_max)
+    for i_type = 1:length(data_type)
+        if ~exist([output_dir16k '/' min_max{i_mm} '/' data_type{i_type}],'dir')
+            mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type}]);
+        end
+        if ~exist([output_dir8k '/' min_max{i_mm} '/' data_type{i_type}],'dir')
+            mkdir([output_dir8k '/' min_max{i_mm} '/' data_type{i_type}]);
+        end
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s1/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s2/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s3/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s4/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/s5/']); %#ok<NASGU>
+        status = mkdir([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/mix/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s1/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s2/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s3/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s4/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s5/']); %#ok<NASGU>
+        status = mkdir([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/mix/']);
+                
+        TaskFile = ['mix_5_spk_' data_type{i_type} '.txt'];
+        fid=fopen(TaskFile,'r');
+        C=textscan(fid,'%s %f %s %f %s %f %s %f %s %f');
+        
+        Source1File = ['mix_5_spk_' min_max{i_mm} '_' data_type{i_type} '_1'];
+        Source2File = ['mix_5_spk_' min_max{i_mm} '_' data_type{i_type} '_2'];
+        Source3File = ['mix_5_spk_' min_max{i_mm} '_' data_type{i_type} '_3'];
+        Source4File = ['mix_5_spk_' min_max{i_mm} '_' data_type{i_type} '_4'];
+        Source5File = ['mix_5_spk_' min_max{i_mm} '_' data_type{i_type} '_5'];
+        MixFile     = ['mix_5_spk_' min_max{i_mm} '_' data_type{i_type} '_mix'];
+        fid_s1 = fopen(Source1File,'w');
+        fid_s2 = fopen(Source2File,'w');
+        fid_s3 = fopen(Source3File,'w');
+        fid_s4 = fopen(Source4File,'w');
+        fid_s5 = fopen(Source5File,'w');
+        fid_m  = fopen(MixFile,'w');
+        
+        num_files = length(C{1});
+        fs8k=8000;
+        
+        scaling_16k = zeros(num_files,3);
+        scaling_8k = zeros(num_files,3);
+        scaling16bit_16k = zeros(num_files,1);
+        scaling16bit_8k = zeros(num_files,1);
+        fprintf(1,'%s\n',[min_max{i_mm} '_' data_type{i_type}]);
+        for i = 1:num_files
+            [inwav1_dir,invwav1_name,inwav1_ext] = fileparts(C{1}{i});
+            [inwav2_dir,invwav2_name,inwav2_ext] = fileparts(C{3}{i});
+            [inwav3_dir,invwav3_name,inwav3_ext] = fileparts(C{5}{i});
+            [inwav4_dir,invwav4_name,inwav4_ext] = fileparts(C{7}{i});
+            [inwav5_dir,invwav5_name,inwav5_ext] = fileparts(C{9}{i});
+            fprintf(fid_s1,'%s\n',C{1}{i});%[inwav1_dir,'/',invwav1_name,inwav1_ext]);
+            fprintf(fid_s2,'%s\n',C{3}{i});%[inwav2_dir,'/',invwav2_name,inwav2_ext]);
+            fprintf(fid_s3,'%s\n',C{5}{i});%[inwav3_dir,'/',invwav3_name,inwav3_ext]);
+            fprintf(fid_s4,'%s\n',C{7}{i});%[inwav4_dir,'/',invwav4_name,inwav4_ext]);
+            fprintf(fid_s5,'%s\n',C{9}{i});%[inwav5_dir,'/',invwav5_name,inwav5_ext]);
+            inwav1_snr = C{2}(i);
+            inwav2_snr = C{4}(i);
+            inwav3_snr = C{6}(i);
+            inwav4_snr = C{8}(i);
+            inwav5_snr = C{10}(i);
+            mix_name = [invwav1_name,'_',num2str(inwav1_snr),...
+                        '_',invwav2_name,'_',num2str(inwav2_snr),...
+                        '_',invwav3_name,'_',num2str(inwav3_snr),...
+                        '_',invwav4_name,'_',num2str(inwav4_snr),...
+                        '_',invwav5_name,'_',num2str(inwav5_snr)];
+            fprintf(fid_m,'%s\n',mix_name);
+            
+            % get input wavs
+            [s1, fs] = audioread([wsj0root C{1}{i}]);
+            s2       = audioread([wsj0root C{3}{i}]);
+            s3       = audioread([wsj0root C{5}{i}]);
+            s4       = audioread([wsj0root C{7}{i}]);
+            s5       = audioread([wsj0root C{9}{i}]);
+
+            % resample, normalize 8 kHz file, save scaling factor
+            s1_8k=resample(s1,fs8k,fs);
+            [s1_8k,lev1]=activlev(s1_8k,fs8k,'n'); % y_norm = y /sqrt(lev);
+            s2_8k=resample(s2,fs8k,fs);
+            [s2_8k,lev2]=activlev(s2_8k,fs8k,'n');
+            s3_8k=resample(s3,fs8k,fs);
+            [s3_8k,lev3]=activlev(s3_8k,fs8k,'n');
+            s4_8k=resample(s4,fs8k,fs);
+            [s4_8k,lev4]=activlev(s4_8k,fs8k,'n');
+            s5_8k=resample(s5,fs8k,fs);
+            [s5_8k,lev5]=activlev(s5_8k,fs8k,'n');
+            
+            weight_1=10^(inwav1_snr/20);
+            weight_2=10^(inwav2_snr/20);
+            weight_3=10^(inwav3_snr/20);
+            weight_4=10^(inwav4_snr/20);
+            weight_5=10^(inwav5_snr/20);
+            
+            s1_8k = weight_1 * s1_8k;
+            s2_8k = weight_2 * s2_8k;
+            s3_8k = weight_3 * s3_8k;
+            s4_8k = weight_4 * s4_8k;
+            s5_8k = weight_5 * s5_8k;
+            
+            switch min_max{i_mm}
+                case 'max'
+                    mix_8k_length = max([length(s1_8k),length(s2_8k),length(s3_8k),length(s4_8k),length(s5_8k)]);
+                    s1_8k = cat(1,s1_8k,zeros(mix_8k_length - length(s1_8k),1));
+                    s2_8k = cat(1,s2_8k,zeros(mix_8k_length - length(s2_8k),1));
+                    s3_8k = cat(1,s3_8k,zeros(mix_8k_length - length(s3_8k),1));
+                    s4_8k = cat(1,s4_8k,zeros(mix_8k_length - length(s4_8k),1));
+                    s5_8k = cat(1,s5_8k,zeros(mix_8k_length - length(s5_8k),1));
+
+                case 'min'
+                    mix_8k_length = min([length(s1_8k),length(s2_8k),length(s3_8k),length(s4_8k),length(s5_8k)]);
+                    s1_8k = s1_8k(1:mix_8k_length);
+                    s2_8k = s2_8k(1:mix_8k_length);
+                    s3_8k = s3_8k(1:mix_8k_length);
+                    s4_8k = s4_8k(1:mix_8k_length);
+                    s5_8k = s5_8k(1:mix_8k_length);
+            end
+            mix_8k = s1_8k + s2_8k + s3_8k + s4_8k + s5_8k;
+                    
+            max_amp_8k = max(cat(1,abs(mix_8k(:)),abs(s1_8k(:)),abs(s2_8k(:)),abs(s3_8k(:)),abs(s4_8k(:)),abs(s5_8k(:))));
+            mix_scaling_8k = 1/max_amp_8k*0.9;
+            s1_8k = mix_scaling_8k * s1_8k;
+            s2_8k = mix_scaling_8k * s2_8k;
+            s3_8k = mix_scaling_8k * s3_8k;
+            s4_8k = mix_scaling_8k * s4_8k;
+            s5_8k = mix_scaling_8k * s5_8k;
+            mix_8k = mix_scaling_8k * mix_8k;
+            
+            % apply same gain to 16 kHz file
+            s1_16k = weight_1 * s1 / sqrt(lev1);
+            s2_16k = weight_2 * s2 / sqrt(lev2);
+            s3_16k = weight_3 * s3 / sqrt(lev3);
+            s4_16k = weight_4 * s4 / sqrt(lev4);
+            s5_16k = weight_5 * s5 / sqrt(lev5);
+            
+            switch min_max{i_mm}
+                case 'max'
+                    mix_16k_length = max([length(s1_16k),length(s2_16k),length(s3_16k),length(s4_16k),length(s5_16k)]);
+                    s1_16k = cat(1,s1_16k,zeros(mix_16k_length - length(s1_16k),1));
+                    s2_16k = cat(1,s2_16k,zeros(mix_16k_length - length(s2_16k),1));
+                    s3_16k = cat(1,s3_16k,zeros(mix_16k_length - length(s3_16k),1));
+                    s4_16k = cat(1,s4_16k,zeros(mix_16k_length - length(s4_16k),1));
+                    s5_16k = cat(1,s5_16k,zeros(mix_16k_length - length(s5_16k),1));
+                case 'min'
+                    mix_16k_length = min([length(s1_16k),length(s2_16k),length(s3_16k),length(s4_16k),length(s5_16k)]);
+                    s1_16k = s1_16k(1:mix_16k_length);
+                    s2_16k = s2_16k(1:mix_16k_length);
+                    s3_16k = s3_16k(1:mix_16k_length);
+                    s4_16k = s4_16k(1:mix_16k_length);
+                    s5_16k = s5_16k(1:mix_16k_length);
+            end
+            mix_16k = s1_16k + s2_16k + s3_16k + s4_16k + s5_16k;
+            
+            max_amp_16k = max(cat(1,abs(mix_16k(:)),abs(s1_16k(:)),abs(s2_16k(:)),abs(s3_16k(:)),abs(s4_16k(:)),abs(s5_16k(:))));
+            mix_scaling_16k = 1/max_amp_16k*0.9;
+            s1_16k = mix_scaling_16k * s1_16k;
+            s2_16k = mix_scaling_16k * s2_16k;
+            s3_16k = mix_scaling_16k * s3_16k;
+            s4_16k = mix_scaling_16k * s4_16k;
+            s5_16k = mix_scaling_16k * s5_16k;
+            mix_16k = mix_scaling_16k * mix_16k;
+            
+            % save 8 kHz and 16 kHz mixtures, as well as
+            % necessary scaling factors
+            
+            scaling_16k(i,1) = weight_1 * mix_scaling_16k/ sqrt(lev1);
+            scaling_16k(i,2) = weight_2 * mix_scaling_16k/ sqrt(lev2);
+            scaling_16k(i,3) = weight_3 * mix_scaling_16k/ sqrt(lev3);
+            scaling_16k(i,4) = weight_4 * mix_scaling_16k/ sqrt(lev4);
+            scaling_16k(i,5) = weight_5 * mix_scaling_16k/ sqrt(lev5);
+            scaling_8k(i,1) = weight_1 * mix_scaling_8k/ sqrt(lev1);
+            scaling_8k(i,2) = weight_2 * mix_scaling_8k/ sqrt(lev2);
+            scaling_8k(i,3) = weight_3 * mix_scaling_8k/ sqrt(lev3);
+            scaling_8k(i,4) = weight_4 * mix_scaling_8k/ sqrt(lev4);
+            scaling_8k(i,5) = weight_5 * mix_scaling_8k/ sqrt(lev5);
+            
+            scaling16bit_16k(i) = mix_scaling_16k;
+            scaling16bit_8k(i)  = mix_scaling_8k;
+            
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s1/' mix_name '.wav'], s1_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s1/' mix_name '.wav'], s1_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s2/' mix_name '.wav'], s2_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s2/' mix_name '.wav'], s2_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s3/' mix_name '.wav'], s3_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s3/' mix_name '.wav'], s3_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s4/' mix_name '.wav'], s4_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s4/' mix_name '.wav'], s4_16k,fs);
+            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/s5/' mix_name '.wav'], s5_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/s5/' mix_name '.wav'], s5_16k,fs);            audiowrite([output_dir8k '/' min_max{i_mm} '/' data_type{i_type} '/mix/' mix_name '.wav'], mix_8k,fs8k);
+            audiowrite([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/mix/' mix_name '.wav'], mix_16k,fs);
+            
+            if mod(i,10)==0
+                fprintf(1,'.');
+                if mod(i,200)==0
+                    fprintf(1,'\n');
+                end
+            end
+            
+        end
+        save([output_dir8k  '/' min_max{i_mm} '/' data_type{i_type} '/scaling.mat'],'scaling_8k','scaling16bit_8k');
+        save([output_dir16k '/' min_max{i_mm} '/' data_type{i_type} '/scaling.mat'],'scaling_16k','scaling16bit_16k');
+        
+        fclose(fid);
+        fclose(fid_s1);
+        fclose(fid_s2);
+        fclose(fid_s3);
+        fclose(fid_s4);
+        fclose(fid_s5);
+        fclose(fid_m);
+    end
+end

create-speaker-mixtures-2345/create-speaker-mixtures-2345/maxfilt.m

@@ -0,0 +1,127 @@
+function [y,k,y0]=maxfilt(x,f,n,d,x0)
+%MAXFILT find max of an exponentially weighted sliding window  [Y,K,Y0]=(X,F,nn,D,X0)
+%
+% Usage: (1) y=maxfilt(x)   % maximum filter along first non-singleton dimension
+%        (2) y=maxfilt(x,0.95) % use a forgetting factor of 0.95 (= time const of -1/log(0.95)=19.5 samples)
+%        (3) Two equivalent methods (i.e. you can process x in chunks):
+%                 y=maxfilt([u v]);      [yu,ku,x0)=maxfilt(u);
+%                                        yv=maxfilt(v,[],[],[],x0);
+%                                        y=[yu yv];
+%
+% Inputs:  X  Vector or matrix of input data
+%          F  exponential forgetting factor in the range 0 (very forgetful) to 1 (no forgetting)
+%             F=exp(-1/T) gives a time constant of T samples [default = 1]
+%          n  Length of sliding window [default = Inf (equivalent to [])]
+%          D  Dimension for work along [default = first non-singleton dimension]
+%         X0  Initial values placed in front of the X data
+%
+% Outputs: Y  Output matrix - same size as X
+%          K  Index array: Y=X(K). (Note that these value may be <=0 if input X0 is present)
+%         Y0  Last nn-1 values (used to initialize a subsequent call to
+%             maxfilt()) (or last output if n=Inf)
+%
+% This routine calaulates y(p)=max(f^r*x(p-r), r=0:n-1) where x(r)=-inf for r<1
+% y=x(k) on output
+
+% Example: find all peaks in x that are not exceeded within +-w samples
+% w=4;m=100;x=rand(m,1);[y,k]=maxfilt(x,1,2*w+1);p=find(((1:m)-k)==w);plot(1:m,x,'-',p-w,x(p-w),'+')
+
+%      Copyright (C) Mike Brookes 2003
+%      Version: $Id: maxfilt.m 4054 2014-01-12 19:11:46Z dmb $
+%
+%   VOICEBOX is a MATLAB toolbox for speech processing.
+%   Home page: http://www.ee.ic.ac.uk/hp/staff/dmb/voicebox/voicebox.html
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%   This program is free software; you can redistribute it and/or modify
+%   it under the terms of the GNU General Public License as published by
+%   the Free Software Foundation; either version 2 of the License, or
+%   (at your option) any later version.
+%
+%   This program is distributed in the hope that it will be useful,
+%   but WITHOUT ANY WARRANTY; without even the implied warranty of
+%   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%   GNU General Public License for more details.
+%
+%   You can obtain a copy of the GNU General Public License from
+%   http://www.gnu.org/copyleft/gpl.html or by writing to
+%   Free Software Foundation, Inc.,675 Mass Ave, Cambridge, MA 02139, USA.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+s=size(x);
+if nargin<4 || isempty(d)
+    d=find(s>1,1);                  % find first non-singleton dimension
+    if isempty(d)
+        d=1;
+    end
+end
+if nargin>4 && numel(x0)>0          % initial values specified
+    y=shiftdim(cat(d,x0,x),d-1);    % concatenate x0 and x along d
+    nx0=size(x0,d);                 % number of values added onto front of data
+else                                % dimension specified, d
+    y=shiftdim(x,d-1);
+    nx0=0;
+end
+s=size(y);
+s1=s(1);
+if nargin<3 || isempty(n)
+    n0=Inf;
+else
+    n0=max(n,1);
+end
+if nargin<2 || isempty(f)
+    f=1;
+end
+nn=n0;
+if nargout>2 % we need to output the tail for next time
+    if n0<Inf
+        ny0=min(s1,nn-1);
+    else
+        ny0=min(s1,1);
+    end
+    sy0=s;
+    sy0(1)=ny0;
+    if ny0<=0 || n0==Inf
+        y0=zeros(sy0);
+    else
+        y0=reshape(y(1+s1-ny0:end,:),sy0);
+        y0=shiftdim(y0,ndims(x)-d+1);
+    end
+end
+nn=min(nn,s1);         % no point in having nn>s1 
+k=repmat((1:s1)',[1 s(2:end)]);
+if nn>1
+    j=1;
+    j2=1;
+    while j>0
+        g=f^j;
+        m=find(y(j+1:s1,:)<=g*y(1:s1-j,:));
+        m=m+j*fix((m-1)/(s1-j));
+        y(m+j)=g*y(m);
+        k(m+j)=k(m);
+        j2=j2+j;
+        j=min(j2,nn-j2);                    % j approximately doubles each iteration
+    end
+end
+if nargout==0
+    if nargin<3
+        x=shiftdim(x);
+    else
+        x=shiftdim(x,d-1);
+    end
+    ss=min(prod(s(2:end)),5);   % maximum of 5 plots
+    plot(1:s1,reshape(y(nx0+1:end,1:ss),s1,ss),'-r',1:s1,reshape(x(:,1:ss),s1,ss),'-b');
+else
+    if nargout>2 && n0==Inf && ny0==1 % if n0==Inf, we need to save the final output
+        y0=reshape(y(end,:),sy0);
+        y0=shiftdim(y0,ndims(x)-d+1);
+    end
+    if nx0>0                        % pre-data specified, x0
+        s(1)=s(1)-nx0;
+        y=shiftdim(reshape(y(nx0+1:end,:),s),ndims(x)-d+1);
+        k=shiftdim(reshape(k(nx0+1:end,:),s),ndims(x)-d+1)-nx0;
+    else                            % no pre-data
+        y=shiftdim(y,ndims(x)-d+1);
+        k=shiftdim(k,ndims(x)-d+1);
+    end
+end