Upload 7 files

tools/utils/extract.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+""" extract.py
+
+Extract CHiME 3 audio segments from continuous audio
+
+Usage:
+  extract.py [-f] [-p pad] [-c channel] <segfilenm> <inwavroot> <outwavroot>
+  extract.py --help
+
+Options:
+  <segfilenm>    Name of the segmentation file
+  <inwavroot>    Name of the root dir for the input audio file
+  <outwavroot>   Name of the root dir for the output segments
+  -p <pad>, --padding=<pad> padding at start and end in seconds  [default: 0]
+  -f, --fullname  Use fullname for outfile
+  -c <chan>, --channel=<chan>  Recording channel (defaults to all)
+  --help         print this help screen
+
+"""
+
+from __future__ import print_function
+import json
+import os
+import subprocess
+import argparse
+import sys
+
+
+def extract(segment, in_root, out_root, padding=0.0, channel=0, fullname=False):
+    """use sox to extract segment from wav file
+
+       in_root - root directory for unsegmented audio files
+       out_root - root directory for output audio segments
+    """
+    infilenm = '{}/{}.CH{}.wav'.format(in_root, segment['wavfile'], channel)
+
+    if fullname:
+        outtemplate = '{}/{}.{}.{}.{}.{:02d}.{:03d}.ch{}.wav'
+        outfilenm = outtemplate.format(out_root,
+                                       segment['wavfile'],
+                                       segment['wsj_name'],
+                                       segment['environment'],
+                                       segment['speaker'],
+                                       segment['repeat'],
+                                       segment['index'],
+                                       channel)
+    else:
+        outfilenm = '{}/{}_{}_{}.CH{}.wav'.format(out_root,
+                                                  segment['speaker'],
+                                                  segment['wsj_name'],
+                                                  segment['environment'],
+                                                  channel)
+
+    subprocess.call(['sox', infilenm, outfilenm,
+                     'trim',
+                     str(segment['start'] - padding),
+                     '=' + str(segment['end'] + padding)])
+
+
+def to_string(segment):
+    return "{}:{}-{}:{:03d}({:03d})".format(segment['wavfile'],
+                                            segment['start'],
+                                            segment['end'],
+                                            segment['index'],
+                                            segment['repeat'])
+
+
+def do_extract(seg_filenm, in_root, out_root,
+               padding=0.0, channel=0, fullname=False):
+    """
+    Extract segments listed in seg file from recording channel, 'channel'
+    """
+
+    with open(seg_filenm, 'r') as infile:
+        json_string = infile.read()
+    segments = json.loads(json_string)
+
+    if not os.path.isdir(out_root):
+        os.makedirs(out_root)
+
+    print('Extracting audio in channel {}...'.format(channel))
+
+    for i, segment in enumerate(segments):
+        sys.stdout.write(' Processing segment {: 5}/{: <5}\r'.format(i+1, len(segments)))
+        sys.stdout.flush()
+
+        extract(segment, in_root, out_root, padding=padding,
+                channel=channel, fullname=fullname)
+    sys.stdout.write('\n')
+    sys.stdout.flush()
+
+
+def main():
+    """Main method called from commandline."""
+    parser = argparse.ArgumentParser(description='Extract CHiME 3 audio segments from continuous audio.')
+    parser.add_argument('segfilenm', metavar='<segfilenm>',
+                        help='Name of the segmentation file', type=str)
+    parser.add_argument('inwavroot', metavar='<inwavroot>',
+                        help='Name of the root dir for the input audio file', type=str)
+    parser.add_argument('outwavroot', metavar='<outwavroot>',
+                        help='Name of the root dir for the output segments', type=str)
+    parser.add_argument('-p', '--padding', metavar='pad',
+                        help='Padding at start and end in seconds [default: 0]', type=float, default=0)
+    parser.add_argument('-f', '--fullname',
+                        help='Use fullname for outfile', action='store_true')
+    parser.add_argument('-c', '--channel', metavar='channel',
+                        help='Recording channel (defaults to all).', action='append', type=int, default=[])
+
+    args = parser.parse_args()
+
+    segfilenm = args.segfilenm
+    in_root = args.inwavroot
+    out_root = args.outwavroot
+    padding = args.padding
+    fullname = args.fullname
+    channels = args.channel
+
+    if len(channels) == 0:
+        channels = [0, 1, 2, 3, 4, 5, 6]
+
+    for channel in channels:
+        do_extract(segfilenm, in_root, out_root, padding, channel, fullname)
+
+
+if __name__ == '__main__':
+    main()
+
+# ./extract.py ../../data/annotations/utterance/LR_141103_01.json ../../data/16khz16bit xxx

tools/utils/istft_multi.m

@@ -0,0 +1,59 @@
+function x=istft_multi(X,nsampl)
+
+% ISTFT_MULTI Multichannel inverse short-time Fourier transform (ISTFT)
+% using half-overlapping sine windows.
+%
+% x=istft_multi(X,nsampl)
+%
+% Inputs:
+% X: nbin x nfram x nsrc matrix containing STFT coefficients for nsrc
+% sources with nbin frequency bins and nfram time frames or nbin x nfram x
+% nsrc x nchan matrix containing the STFT coefficients of nsrc spatial
+% source images over nchan channels
+% nsampl: number of samples to which the corresponding time-domain signals
+% are to be truncated
+%
+% Output:
+% x: nsrc x nsampl matrix or nsrc x nsampl x nchan matrix containing the
+% corresponding time-domain signals
+% If x is a set of signals of length nsampl and X=stft_multi(x), then
+% x=istft_multi(X,nsampl).
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Copyright 2008 Emmanuel Vincent
+% This software is distributed under the terms of the GNU Public License
+% version 3 (http://www.gnu.org/licenses/gpl.txt)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+%%% Errors and warnings %%%
+if nargin<2, error('Not enough input arguments.'); end
+[nbin,nfram,nsrc,nchan]=size(X);
+if nbin==2*floor(nbin/2), error('The number of frequency bins must be odd.'); end
+wlen=2*(nbin-1);
+
+%%% Computing inverse STFT signal %%%
+% Defining sine window
+win=sin((.5:wlen-.5)/wlen*pi);
+% Pre-processing for edges
+swin=zeros(1,(nfram+1)*wlen/2);
+for t=0:nfram-1,
+    swin(t*wlen/2+1:t*wlen/2+wlen)=swin(t*wlen/2+1:t*wlen/2+wlen)+win.^2;
+end
+swin=sqrt(swin/wlen);
+x=zeros(nsrc,(nfram+1)*wlen/2,nchan);
+for i=1:nchan,
+    for j=1:nsrc,
+        for t=0:nfram-1,
+            % IFFT
+            fframe=[X(:,t+1,j,i);conj(X(wlen/2:-1:2,t+1,j,i))];
+            frame=real(ifft(fframe));
+            % Overlap-add
+            x(j,t*wlen/2+1:t*wlen/2+wlen,i)=x(j,t*wlen/2+1:t*wlen/2+wlen,i)+frame.'.*win./swin(t*wlen/2+1:t*wlen/2+wlen);
+        end
+    end
+end
+% Truncation
+x=x(:,wlen/4+1:wlen/4+nsampl,:);
+
+return;

tools/utils/json2mat.m

@@ -0,0 +1,65 @@
+function mat=json2mat(filename)
+
+% JSON2MAT Reads a JSON file
+%
+% mat=json2mat(filename)
+%
+% Input:
+% filename: JSON filename (.json extension)
+%
+% Output:
+% mat: Matlab cell array whose entries are Matlab structures containing the
+% value for each JSON field
+%
+% Note: all numeric fields are rounded to double precision. Digits beyond
+% double precision are lost.
+%
+% If you use this software in a publication, please cite:
+%
+% Jon Barker, Ricard Marxer, Emmanuel Vincent, and Shinji Watanabe, The
+% third 'CHiME' Speech Separation and Recognition Challenge: Dataset,
+% task and baselines, submitted to IEEE 2015 Automatic Speech Recognition
+% and Understanding Workshop (ASRU), 2015.
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Copyright 2015 University of Sheffield (Jon Barker, Ricard Marxer)
+%                Inria (Emmanuel Vincent)
+%                Mitsubishi Electric Research Labs (Shinji Watanabe)
+% This software is distributed under the terms of the GNU Public License
+% version 3 (http://www.gnu.org/licenses/gpl.txt)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+fid=fopen(filename,'r');
+fgetl(fid); % [
+txt=fgetl(fid); % { or ]
+txt=fgetl(fid); % first field
+mat=cell(1);
+ind=1; % entry index
+while txt~=-1, % end of file
+    if strcmp(txt,'    }, ') || strcmp(txt,'    }'), % next entry
+        ind=ind+1;
+        txt=fgetl(fid); % { or ]
+    else
+        try
+        pos=strfind(txt,'"');
+        field=txt(pos(1)+1:pos(2)-1);
+        catch
+            keyboard;
+        end
+        if ~strcmp(txt(end-1:end),', '), % last field
+            txt=txt(pos(2)+3:end);
+        else
+            txt=txt(pos(2)+3:end-2);
+        end
+        if strcmp(txt(1),'"') && strcmp(txt(end),'"'), % text value
+            value=txt(2:end-1);
+        else % boolean or numerical value
+            value=eval(txt);
+        end
+        mat{ind}.(field)=value;
+    end
+    txt=fgetl(fid); % next field
+end
+fclose(fid);
+
+return

tools/utils/localize.m

@@ -0,0 +1,158 @@
+function [path,TDOA]=localize(X,chanlist)
+
+% LOCALIZE Tracks the speaker spatial position over time and computes the
+% corresponding TDOA using SRP-PHAT and the Viterbi algorithm
+%
+% [path,TDOA]=localize(X,chanlist)
+%
+% Inputs:
+% Y: nbin x nfram x nchan STFT of the inpu signal
+% chanlist: list of input channels (from 1 to 6)
+%
+% Output:
+% path: 3 x nfram position of the speaker over time in centimeters
+% TDOA: nchan x nfram corresponding TDOAs between the speaker position and
+% the microphone positions
+%
+% Note: for computational efficiency, the position on the z-axis is assumed
+% to be constant over time.
+%
+% If you use this software in a publication, please cite:
+%
+% Jon Barker, Ricard Marxer, Emmanuel Vincent, and Shinji Watanabe, The
+% third 'CHiME' Speech Separation and Recognition Challenge: Dataset,
+% task and baselines, submitted to IEEE 2015 Automatic Speech Recognition
+% and Understanding Workshop (ASRU), 2015.
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Copyright 2015-2016 University of Sheffield (Jon Barker, Ricard Marxer)
+%                     Inria (Emmanuel Vincent)
+%                     Mitsubishi Electric Research Labs (Shinji Watanabe)
+% This software is distributed under the terms of the GNU Public License
+% version 3 (http://www.gnu.org/licenses/gpl.txt)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+if nargin < 2,
+    chanlist=[1 3:6];
+end
+
+% Define hyper-parameters
+pow_thresh=-20; % threshold in dB below which a microphone is considered to fail
+center_factor=0.05; % weight given to the prior that the speaker's horizontal position is close to the center
+smoothing_factor=3; % weight given to the transition probabilities
+            
+% Remove zero frequency
+X = X(2:end,:,:);
+[nbin,nfram,nchan] = size(X);
+wlen=2*nbin;
+f=16000/wlen*(1:nbin).';
+
+% Compute relative channel power
+if length(chanlist) > 2,
+    xpow=shiftdim(sum(sum(abs(X).^2,2),1));
+    xpow=10*log10(xpow/max(xpow));
+else
+    xpow=zeros(1,2);
+end
+
+% Define microphone positions in centimeters
+xmic=[-10 0 10 -10 0 10]; % left to right axis
+ymic=[9.5 9.5 9.5 -9.5 -9.5 -9.5]; % bottom to top axis
+zmic=[0 -2 0 0 0 0]; % back to front axis
+xmic=xmic(chanlist);
+ymic=ymic(chanlist);
+zmic=zmic(chanlist);
+
+% Define grid of possible speaker positions in centimeters
+xres=46;
+xpos=linspace(-45,45,xres);
+yres=46;
+ypos=linspace(-45,45,yres);
+zres=4;
+zpos=linspace(15,45,zres);
+ngrid=xres*yres*zres;
+
+% Compute horizontal distances between grid points
+xvect=reshape(repmat(xpos.',[1 yres]),xres*yres,1);
+yvect=reshape(repmat(ypos,[xres 1]),xres*yres,1);
+pair_dist=sqrt((repmat(xvect,[1 xres*yres])-repmat(xvect.',[xres*yres 1])).^2+(repmat(yvect,[1 xres*yres])-repmat(yvect.',[xres*yres 1])).^2);
+
+% Compute horizontal distances to the center
+center_dist=sqrt((xvect-mean(xpos)).^2+(yvect-mean(ypos)).^2);
+
+% Compute theoretical TDOAs between front pairs
+d_grid=zeros(nchan,xres,yres,zres); % speaker-to-microphone distances
+for c=1:nchan,
+    d_grid(c,:,:,:)=sqrt(repmat((xpos.'-xmic(c)).^2,[1 yres zres])+repmat((ypos-ymic(c)).^2,[xres 1 zres])+repmat((permute(zpos,[3 1 2])-zmic(c)).^2,[xres yres 1]));
+end
+d_grid=reshape(d_grid,nchan,ngrid);
+pairs=[];
+for c=1:nchan,
+    pairs=[pairs [c*ones(1,nchan-c); c+1:nchan]]; % microphone pairs
+end
+npairs=size(pairs,2);
+tau_grid=zeros(npairs,ngrid); % TDOAs
+for p=1:npairs,
+    c1=pairs(1,p);
+    c2=pairs(2,p);
+    tau_grid(p,:)=(d_grid(c2,:)-d_grid(c1,:))/343/100;
+end
+
+% Compute the SRP-PHAT pseudo-spectrum 
+srp=zeros(nfram,ngrid);
+for p=1:npairs, % Loop over front pairs
+    c1=pairs(1,p);
+    c2=pairs(2,p);
+    d=sqrt((xmic(c1)-xmic(c2))^2+(ymic(c1)-ymic(c2))^2+(zmic(c1)-zmic(c2))^2);
+    alpha=10*343/(d*16000);
+    lin_grid=linspace(min(tau_grid(p,:)),max(tau_grid(p,:)),100);
+    lin_spec=zeros(nbin,nfram,100); % GCC-PHAT pseudo-spectrum over a uniform interval
+    if (xpow(c1)>pow_thresh) && (xpow(c2)>pow_thresh), % discard channels with low power (microphone failure)
+        P=X(:,:,c1).*conj(X(:,:,c2));
+        P=P./abs(P);
+        for ind=1:100,
+            EXP=repmat(exp(-2*1i*pi*lin_grid(ind)*f),1,nfram);
+            lin_spec(:,:,ind)=ones(nbin,nfram)-tanh(alpha*real(sqrt(2-2*real(P.*EXP))));
+        end
+    end
+    lin_spec=shiftdim(sum(lin_spec,1));
+    tau_spec=zeros(nfram,ngrid); % GCC-PHAT pseudo-spectrum over the whole grid
+    for t=1:nfram,
+        tau_spec(t,:)=interp1(lin_grid,lin_spec(t,:),tau_grid(p,:));
+    end
+    srp=srp+tau_spec; % sum over the microphone pairs
+end
+
+% Loop over possible z-axis positions
+path=zeros(zres,nfram);
+logpost=zeros(zres,1);
+xpath=zeros(zres,nfram);
+ypath=zeros(zres,nfram);
+zpath=zeros(zres,nfram);
+srp=reshape(srp,nfram,xres*yres,zres);
+for zind=1:zres,
+
+    % Weight by distance to the center
+    weighted_srp=srp(:,:,zind)-center_factor*repmat(center_dist.',[nfram 1]);
+
+    % Track the source position over time
+    [path(zind,:),logpost(zind)]=viterbi(weighted_srp.',zeros(xres*yres,1),zeros(xres*yres,1),-smoothing_factor*pair_dist);
+    for t=1:nfram,
+        [xpath(zind,t),ypath(zind,t)]=ind2sub([xres yres],path(zind,t));
+        zpath(zind,t)=zind;
+    end
+end
+
+% Select the best z-axis position
+[~,zind]=max(logpost);
+path=(zind-1)*xres*yres+path(zind,:);
+xpath=xpos(xpath(zind,:));
+ypath=ypos(ypath(zind,:));
+zpath=zpos(zpath(zind,:));
+
+% Derive TDOA
+d_path=d_grid(:,path);
+TDOA=d_path/343/100;
+path=[xpath; ypath; zpath];
+
+return

tools/utils/mat2json.m

@@ -0,0 +1,66 @@
+function mat2json(mat,filename)
+
+% MAT2JSON Writes a JSON file
+%
+% mat2json(mat,filename)
+%
+% Inputs:
+% mat: Matlab cell array whose entries are Matlab structures containing the
+% value for each JSON field
+% filename: JSON filename (.json extension)
+%
+% Note: using JSON2MAT followed by MAT2JSON will generally not lead back to
+% the original JSON file due to the loss of digits beyond double precision
+% and to the handling of trailing zeros.
+%
+% If you use this software in a publication, please cite:
+%
+% Jon Barker, Ricard Marxer, Emmanuel Vincent, and Shinji Watanabe, The
+% third 'CHiME' Speech Separation and Recognition Challenge: Dataset,
+% task and baselines, submitted to IEEE 2015 Automatic Speech Recognition
+% and Understanding Workshop (ASRU), 2015.
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Copyright 2015 University of Sheffield (Jon Barker, Ricard Marxer)
+%                Inria (Emmanuel Vincent)
+%                Mitsubishi Electric Research Labs (Shinji Watanabe)
+% This software is distributed under the terms of the GNU Public License
+% version 3 (http://www.gnu.org/licenses/gpl.txt)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+fid=fopen(filename,'w');
+fprintf(fid,'%s\n','[');
+for ind=1:length(mat), % loop over entries
+    fprintf(fid,'    %s\n','{'); % entry delimiter
+    fields=fieldnames(mat{ind});
+    for f=1:length(fields), % loop over fields
+        field=fields{f};
+        value=mat{ind}.(field);
+        if ischar(value), % text field
+            fprintf(fid,'        "%s": "%s"',field,value);
+        elseif islogical(value), % boolean field
+            if value,
+                fprintf(fid,'        "%s": true',field);
+            else
+                fprintf(fid,'        "%s": false',field);
+            end
+        elseif value==floor(value), % integer field
+            fprintf(fid,'        "%s": %d',field,value);
+        else % double field
+            fprintf(fid,'        "%s": %17.*f',field,15-max(0,floor(log10(value))),value);
+        end
+        if f~=length(fields), % field delimiter
+            fprintf(fid,', ');
+        end
+        fprintf(fid,'\n');
+    end
+    fprintf(fid,'    }'); % entry delimiter
+    if ind~=length(mat),
+        fprintf(fid,', ');
+    end
+    fprintf(fid,'\n');
+end
+fprintf(fid,']');
+fclose(fid);
+
+return

tools/utils/stft_multi.m

@@ -0,0 +1,58 @@
+function X=stft_multi(x,wlen)
+
+% STFT_MULTI Multichannel short-time Fourier transform (STFT) using
+% half-overlapping sine windows.
+%
+% X=stft_multi(x)
+% X=stft_multi(x,wlen)
+%
+% Inputs:
+% x: nchan x nsampl matrix containing nchan time-domain mixture signals
+% with nsampl samples
+% wlen: window length (default: 1024 samples or 64ms at 16 kHz, which is
+% optimal for speech source separation via binary time-frequency masking)
+%
+% Output:
+% X: nbin x nfram x nchan matrix containing the STFT coefficients with nbin
+% frequency bins and nfram time frames
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Copyright 2008 Emmanuel Vincent
+% This software is distributed under the terms of the GNU Public License
+% version 3 (http://www.gnu.org/licenses/gpl.txt)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+%%% Errors and warnings %%%
+if nargin<1, error('Not enough input arguments.'); end
+if nargin<2, wlen=1024; end
+[nchan,nsampl]=size(x);
+if nchan>nsampl, error('The signals must be within rows.'); end
+if wlen~=4*floor(wlen/4), error('The window length must be a multiple of 4.'); end
+
+%%% Computing STFT coefficients %%%
+% Defining sine window
+win=sin((.5:wlen-.5)/wlen*pi).';
+% Zero-padding
+nfram=ceil(nsampl/wlen*2);
+x=[x,zeros(nchan,nfram*wlen/2-nsampl)];
+% Pre-processing for edges
+x=[zeros(nchan,wlen/4),x,zeros(nchan,wlen/4)];
+swin=zeros((nfram+1)*wlen/2,1);
+for t=0:nfram-1,
+    swin(t*wlen/2+1:t*wlen/2+wlen)=swin(t*wlen/2+1:t*wlen/2+wlen)+win.^2;
+end
+swin=sqrt(wlen*swin);
+nbin=wlen/2+1;
+X=zeros(nbin,nfram,nchan);
+for i=1:nchan,
+    for t=0:nfram-1,
+        % Framing
+        frame=x(i,t*wlen/2+1:t*wlen/2+wlen).'.*win./swin(t*wlen/2+1:t*wlen/2+wlen);
+        % FFT
+        fframe=fft(frame);
+        X(:,t+1,i)=fframe(1:nbin);
+    end
+end
+
+return;

tools/utils/viterbi.m

@@ -0,0 +1,45 @@
+function [path,logpost]=viterbi(loglik,loginitp,logfinalp,logtransp)
+
+% VITERBI Viterbi algorithm
+% 
+% path=viterbi(loglik,loginitp,logfinalp,logtransp)
+%
+% Inputs:
+% loglik: nstates x nfram matrix of log-likelihood values
+% loginitp: nstates x 1 vector of initial log-probability values
+% logfinalp: nstates x 1 vector of final log-probability values
+% logtransp: nstates x nstates matrix of transition log-probabilities
+%
+% Output:
+% path: 1 x nfram best state sequence
+% logpost: log-posterior probability of the best state sequence
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Copyright 2015 University of Sheffield (Jon Barker, Ricard Marxer)
+%                Inria (Emmanuel Vincent)
+%                Mitsubishi Electric Research Labs (Shinji Watanabe)
+% This software is distributed under the terms of the GNU Public License
+% version 3 (http://www.gnu.org/licenses/gpl.txt)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+[nstates,nfram]=size(loglik);
+
+% Forward pass
+logalpha=loglik(:,1)+loginitp;
+prev=zeros(nstates,nfram-1);
+for t=2:nfram,
+    logalphaprev=logalpha;
+    for n=1:nstates,
+        [logalpha(n),prev(n,t-1)]=max(logalphaprev+logtransp(:,n));
+    end
+    logalpha=logalpha+loglik(:,t);
+end
+
+% Backward pass
+path=zeros(1,nfram);
+[logpost,path(nfram)]=max(logalpha+logfinalp);
+for t=nfram-1:-1:1,
+    path(t)=prev(path(t+1),t);
+end
+
+return