root/Trunk/Scripts/Audio_scripts/AudioSegmentation/AudioBook.pm

#! /usr/bin/perl
$VERSION = 0.2.2;

=head1 NAME

AudioBook - Convert a single transcribed audio file into audio segments 

=cut 

package AudioBook; 
use strict;
use diagnostics;
use Carp;
use Getopt::Std;
use File::Basename;
use File::Copy;

use AudioBook::Audio;
use AudioBook::Text;
use AudioBook::Dictionary;

use AudioBook::Segments; 
use AudioBook::MissingWords;
use AudioBook::MissingWords::CommandLine; 
use AudioBook::Chapter;

=head1 SYNOPSIS

 $./AudioBook -h                                                display help
 $./AudioBook -a speechfile.wav -t text.txt             minimal run configuration
 
=head1 REQUIREMENTS

=item 1 - Sequitor G2P trainable Grapheme-to-Phoneme converter (GPL v2; requires Python to be installed)

        http://www-i6.informatik.rwth-aachen.de/web/Software/g2p.html

=item 2 - HTK Hidden Markov Model Toolkit (note: the source is "open" - i.e. you can read the code - but there are distribution restrictions)

        http://htk.eng.cam.ac.uk/
        
        The HTK toolkit needs to be in your path 
        (see http://www.voxforge.org/home/dev/acousticmodels/linux/create/htkjulius/tutorial/download)

=item 3 - Perl packages

        Term::ReadLine::Gnu
        Audio::Wav
        Lingua::EN::Numbers
        XML::LibXML
        File::Copy

=head1 DESCRIPTION

This is a command line program that segments a speech audio file into 15 word (on average) speech segments.  
It is executable from the command line and uses the following configuration options to help in segmenting speech:

        VoxForge Audio Segmentation Script Parameters
        =============================================
        -a      * audio file name (WAV format only)
        -b      notify if beam width for Forced Alignment exceeds a certain level (default = 250)
                (does not set HVite's beam width parameter)
        -d      pronunciation dictionary  (default = AudioBook/input_files/VoxforgeDict)
        -h      show help
        -i      interactive validation of missing word pronunciations
        -l      LICENSE file (default = AudioBook/input_files/LICENCE)
        -m      Target maximum sentence length (default = 20 words)
        -p      Minimum pause for sentence break (default = 2000000 in units of 100ns)
        -q      log words with single quotes (default = yes)
        -r      README file (default = AudioBook/input_files/README)
        -s      Average sentence length (default = 15 words)
        -t      * text file name (containing transcriptions of speech in audio file)
        -u      username or name you want file stats collected by on VoxForge Metrics 
                page:   (http://www.voxforge.org/home/downloads/metrics)
        -v      validate segment audio files to prompt text using forced Aligment
        -w      validate missing word pronunciations to audio recordings
        -x      unique tar file suffix (max 3 characters - remainder is truncated)
        -S      run sanity test
        -T      create gzipped/tar file

        * minimum required for script to run


=head1 Suggested Segmentation Approach:

=head2 Step 1 

Spell check the text for the audiobook and remove any mistakes or archiac spellings (its good to remove
these to ensure that the pronunciation dictionary does not get cluttered).


=head2 Step 2 - First Pass Forced Alignment - Getting it to Run Completely Without Errors

Execute the script as follows using only the audio file ('-a') and and text file ('-t') parameters:

  $./AudioBook.pm -a audio -t eText.txt
  
This tries to match the words in the text file with the words in the speech audio file, and create time stamps for each word.  
These time stamps are used to determine where pauses are located, and if the pause is large enough, it will create a segment 
of the sentence, and put an entry into the prompts file.

=head3 NOTES

=head4 Text Does not Match Audio

The text file *must exactly* match the contents of the speech audio file (...well actually, it will run OK even if some words do not exactly
match... it only needs about 98-99% accuracy).

If there are any errors when you are trying to run the segmentation script for the first time on a new set of text and speech audio files,
the likely reason is that there is something in the text file that does not match what was said in the audio file.  Figuring this out usually
ends up being an iterative process (i.e. you fix an error, run the script, fix another error, ... until you get an error-free run).  Look
for non-alphanumeric characters and remove them from the text - like multiple dashes (---), multiple periods (...) - any weird non-alphanumeric 
characters not being automatically removed by the script.

If there are a large divergence in the text from the speech audio, then you will have to manually listen to the speech audio to determine 
where the biggest transcription errors lie, and then modify the original text file to match the speech audio file.  This may involves mistakes 
(e.g the reader missing a line while reading the text) or formatting issues in the text (e.g. there might be columnar data in the text, 
and it is read by column by the reader - you then need to rewrite the text to match how the reader read the passage).
 
=head4 Dealing With Out-of-vocabulary Words 

Forced Alignment is performed with HTK's HVite tool as part of the segmentation process.   Force Alignment simply means that the HTK tools 
listens to the audio and looks up the most probable phone sequence in the pronunciation dictionary, and returns the word that corresponds 
to this phone sequence.

HVite requires that each word in the text to be "forced aligned" to have a pronunciation entry in the pronunications lexicon.  The AudioBook.pm 
script uses Sequitor G2P (trained on the VoxForge pronunciation lexicon) to provide draft pronunciations for Out-Of-Vocabulary words so that 
the first pass forced alignment will work.  

This seems to be "good-enough" to find silences of reasonable lengths.  Using this information, the script can create a prompt entries and 
corresponding audio segment.  

=head4 Segmenting Large Audio Files

For larger files (i.e. greater than 30 minutes of audio), you *may* need to manually split the audio file into 30 minute segments, with 
corresponding text files.

=head4 Automatic Numeric Conversion

This script converts numbers to their word equivalent using these Perl packages:

        Lingua::EN::Numbers qw(num2en num2en_ordinal);
        Lingua::EN::Numbers::Years;

These packages make assumptions that need to be validated.  Usually 1, 2, and 3 digit numbers get processed OK.  
4 digit numbers can be pronounced a couple of ways, and should be checked.  For example, the script will converted 
these numbers as follows: 

        converted number:7500: to seven thousand five hundred
        converted number:8500: to eight thousand five hundred

But the actual pronunciation the user used is Seventy Five Hundred and Eighty Five Hundred.  These need to be 
corrected manually.

This script makes the assumptin that 4 digit numbers between 1000 and 2100 are years - this needs to be validated.

=head2 Step 3 - First Pass Forced Alignment - Runs completely, but there are Errors

If the transcription errors are only minor, then the first pass forced alignment usually completes successfully.  However, you might 
see "No tokens survived to final node of network at beam" errors in the HVite log (located in interim_files/logs).

You need to fix these errors by ensuring that the prompt text matches the prompt audio.

=head2 Step 4 - First Pass Forced Alignment - Verify the Segments

Get the script to perform a forced alignment on each of the segments, and display the worst 15 "average log likelihood per frame"
scores.  Then check the transcription and listen to the corresponding audio, and make corrections to the text, repeat as needed.

Run the script as follows:

  $./AudioBook.pm -a audio -t eText.txt -v

The verify switch performs a forced alignment on the individual segments generated from the first pass forced alignment.  Low scores 
(i.e. the lowest average log likelihood per frame score) indicate that the transcription text *might* not match the corresponding audio 
file.  Look at the segment text and listen to the corresponding audo file to determine if they match.  If they do not match (they might 
still match, but just have a low score), then fix the text in your original text transcription file, repeat this process (i.e. running 
the AudioBook program again with the verify switch on) until you can get a clean run.  

=head2 Step 5 - First Pass Forced Alignment - Adjusting Prompt Length

After you can get the First Pass Forced Alignment to run without errors, check the AudioBook.log log file (in the output_files directory) and 
review the length of the created prompts. If there are too many prompts over 30 words long (one or two prompts in the low 30s is passable...),
reduce the size of the pause ("-p" switch) and run First Pass Forced Alignment again - something like this:

  $./AudioBook.pm -a audio -t eText.txt -v - p 1000000
  
Continue making adjustments until you can get reasonable prompt lengths.

=head4 Note

The worst case scenario is that you cannot segment your audio because it does not have any pauses that are long enough to use for a 
segment.  This is unlikely, given that people need to breath in every once in a while.  What will likely occur is that you will have a few 
very long segments because the person spoke continuously for a long period of time.  You will probably have to segment these longer 
prompts manually.

=head2 Step 6 - Validate Suggested Out-of-Vocabulary Word Pronunciations

The pronunciations generated by the Sequitor G2P scripts need to be manually reviewed before any they are added to the
pronunciation dictionary.  One way to do this is to use Speech Recognition to determine the phone set of the word in the actual audio file.
You can do this with the '-w' switch:

  $./AudioBook.pm -a audio -t eText.txt -v - p 1000000 -w

The -w generates a report (MissingWords_combined) that contains a list of all the OOV words, with the speech segment ID and text 
(so you can listen to the audio segment), the g2p recommended phone list, and HVite phone list recommendations (determined using speech
recognition), so you can manually validate the final pronunciations. 

=head4 Note 

That this approach is only as good as the acoustic model you are using.  The pronunciations still need to be validated against the Sequitor G2P recommended 
pronunciations.  Please donate some speech to Voxforge to help improve our acoutic models.

=head2 Step 7 - Iteractive Missing Word Validation

You can also use the script interactively (using the -v switch) to review the Sequitor G2P suggested phone lists and HVite pronunciations.  It 
is a simple command line script.

This mode requires the output (an xml version of the MissingWords_combined file called MissingWords.xml) from the -w switch (which needs the -v 
switch).  This parameter uses the contents of the missingword.xml file to prompt the user to select or edit a suggested pronunciation.  Results 
are placed in the MissingWords_final file, and if the -d switch is selected, then that dictionary will be updated with the results, like this: 

  $./AudioBook.pm -i -d /home/me/voxforge/VoxForgeDict

=head2 Step 8 - Validated Pronunciation Lexicon

If you are submitting your segmented audio to VoxForge, please include your *validated* Out-of-Vocabulary word pronunciations
with your submission as a separate file called: "OOV_pron.txt"

=head1 ALGORITHM

=head2 Audio Segmentation

This program tries to segments the speech audio file into 15 word sentences.  However, if the pause following the 15th word relative to the current 
sentence start position is too short, the algorithm looks at the previous word (i.e. word 14) to see if it has a pause of suitable duration.  
If not, it then looks at word following the current start position (i.e. word 16), and so one until a pause of suitable
duration can be found, increasing the number of words to look behind and ahead each time. 

The default pause duration is 2000000 in units of 100ns.  This can be changed (using the "-p" switch") if the speech audio file doesn't segment well 
enough with this default.

=head2 Generating Out-of-Vocabulary Word Pronunciations

The script gets Sequitor to generate the 20 likeliest pronunciations for each OOV, and then add it to the dict file.  It then performs
another forced aligment on the audio segment containing the Out-of-Vocabulary word.  Hvite will take the sequence of phoneme sounds that it 
recognizes and try to match it to one of the possible pronunciations in the dictionary.  We are therefore using the audio to automatically 
help generate the correct pronunciation.  Because the VoxForge Aoustic models are not that accurate, these suggestions need to be validated 
and compared with the pronunications generated by Sequitor, and a judgment call needs to be made to select the correct pronunciations.

=cut

####################################################################
### Class Variables
####################################################################
our($opt_a,$opt_b,$opt_d,$opt_h,$opt_i,$opt_l,$opt_m,$opt_p,$opt_r,$opt_s,$opt_t,$opt_x,$opt_q,$opt_S,$opt_T,$opt_u,$opt_v,$opt_w); # need to define these because using strict.
my $self = {};
$self->{'debug'} = 0;
$self->{'g2p_model'} = "AudioBook/input_files/g2p/models/model-5";
$self->{'htk_files'} = "AudioBook/input_files/htk";
$self->{'log'} = "AudioBook/output_files/AudioBook_Log";
bless($self,"AudioBook");

my $default_average_sentence_length = 15;
my $default_max_sentence_length = 20;
my $default_min_pause_for_sentence_break = 2000000;
my $command;

####################################################################
### Main
####################################################################
$self->getOptions();
if ($self->getInteractive) {
        my $xmlfile = 'AudioBook/interim_files/MissingWords.xml';                       
        my $missingWords = AudioBook::MissingWords::CommandLine->new($xmlfile);
        $missingWords->interactive();
} else {
        $self->cleanupFiles();
        if ($self->getTesting) {
                $command = ("cp AudioBook/input_files/VoxForgeDict AudioBook/interim_files/VoxForgeDict"); print "cmd:$command\n" if $self->{'debug'} ; system($command);
        }
        $self->process();
}
print "completed!\n";

####################################################################
### Methods
####################################################################

=head1 METHODS (not user accessible)

=head2 process

Segment the user designated speech audio file (-a) using the supplied text file (-t) 

=cut

sub process {
        my ($self)= @_;
        my $tarSuffix = $self->{"tarSuffix"};
        my $chapter = AudioBook::Chapter->new($self);
        # need draft missing word pronunciations before audio can be processed
        my $missingWords = $chapter->processText(); 
        $chapter->processAudio();               
        
        my $segments = AudioBook::Segments->new($self,$chapter);
        $segments->processAudio();      
                        
        if ($chapter->getMissingWordFound()) {  
                if ($self->getVerify_out_of_vocabulary_pronunciations()) { 
                        $missingWords->getAudio();
                }
        }
                
        if (defined($tarSuffix)){
                _createTarFile($self);
        }       
}

=head2 cleanupFiles

Removes any old files in the AudioBook/interim_files/ and AudioBook/output_files/ directories, prior to processing.

=cut

sub cleanupFiles {
        my ($self)= @_;
        if (defined(<AudioBook/interim_files/*>)) {
                unlink (<AudioBook/interim_files/*>);
        }
        if (defined(<AudioBook/interim_files/logs/*>)) {
                unlink (<AudioBook/interim_files/logs/*>);      
        }
        if (defined(<AudioBook/interim_files/missingWordsFolder/*>)) {
                unlink (<AudioBook/interim_files/missingWordsFolder/*>);        
        }
        if (defined(<AudioBook/interim_files/wav/*>)) {
                unlink (<AudioBook/interim_files/wav/*>);       
        }       
        if (defined(<AudioBook/output_files/wav/*>)) {
                unlink (<AudioBook/output_files/wav/*>);        
        }
        if (defined(<AudioBook/output_files/*>)) {      
                unlink (<AudioBook/output_files/*>);
        }
}

=head2 _createTarFile 

creates a GZipped Tar file form files contained in AudioBook/output_files

=item * -T      Switch to turn on this functionality

=item * -u      username used in name of the tar file 

=cut

sub _createTarFile { # private
        my ($self)= @_;
        my $debug = $self->{'debug'};
        my $username = $self->{"username"};
        my $tarSuffix = $self->{"tarSuffix"};
        my $readme = $self->{"README"};
        my $license = $self->{"LICENSE"};
        
        my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
        $year += 1900;
        $mon = sprintf("%02d", $mon); 
        $mday = sprintf("%02d", $mday);
        print "creating gzipped tar file:$username\-$year$mon$mday\-$tarSuffix\.tgz \n";
        if (defined($readme)) {
                copy("$readme","AudioBook/output_files/README");
        } else {
                print "Warning: no README file to copy\n";
        }
        if (defined($license)) {
                copy("$license","AudioBook/output_files/LICENSE");
        } else {
                print "Warning: no LICENSE file to copy\n";
        }
        copy("AudioBook/interim_files/prompts","AudioBook/output_files/prompts");
        $command = ("cp AudioBook/interim_files/wav/* AudioBook/output_files/wav/"); print "cmd:$command\n" if $debug; system($command);        
        if ($debug) {
                $command = ("tar -zcvf $username\-$year$mon$mday\-$tarSuffix\.tgz AudioBook/output_files --exclude \"\.svn\" "); print "cmd:$command\n" if $debug; system($command);
        } else {
                $command = ("tar -zcf $username\-$year$mon$mday\-$tarSuffix\.tgz AudioBook/output_files --exclude \"\.svn\" "); print "cmd:$command\n" if $debug; system($command);
        }
        print "please submit your tar file to: www.voxforge.org\n";     
}

sub _random_characters {
        my ($length) = @_;      
        my @chars=('a'..'z');
        my $randomString;
        foreach (1..$length){
                $randomString.=$chars[rand @chars];
        }
        return $randomString;
}

=head2 getOptions 

Get the user submitted options ('a:b:d:hil:m:p:r:s:t:u:x:q:vwST')

=cut

sub getOptions {
        my ($self)= @_;
        my $debug = $self->{'debug'};   
        getopts('a:b:d:hil:m:p:r:s:t:u:x:q:vwST');    #  sets $opt_* as a side effect.
        if ($opt_h) {
                print "\nVoxForge Audio Segmentation Script Parameters\n";      
                print   "=============================================\n";      
                print "-a\t* audio file name (WAV format only)\n";
                print "-b\tnotify if beam width for Forced Alignment exceeds a certain level (default = 250)\n";
                print "\t(does not set HVite's beam width parameter)\n";
                print "-d\tpronunciation dictionary  (default = AudioBook/input_files/VoxforgeDict)\n";
                print "-h\tshow help\n";
                print "-i\tinteractive validation of missing word pronunciations\n";    
                print "-l\tLICENSE file (default = AudioBook/input_files/LICENCE)\n";
                print "-m\tTarget maximum sentence length (default = $default_max_sentence_length words)\n";
                print "-p\tMinimum pause for sentence break (default = $default_min_pause_for_sentence_break in units of 100ns)\n";             
                print "-q\tlog words with single quotes (default = yes)\n";             
                print "-r\tREADME file (default = AudioBook/input_files/README)\n";                             
                print "-s\tAverage sentence length (default = $default_average_sentence_length words)\n";                               
                print "-t\t* text file name (containing transcriptions of speech in audio file)\n";
                
                print "-u\tusername or name you want file stats collected by on VoxForge Metrics \n";
                print "\tpage:\t(http://www.voxforge.org/home/downloads/metrics)\n";    
                
                print "-v\tvalidate segment audio files to prompt text using forced Aligment\n";
                print "-w\tvalidate missing word pronunciations to audio recordings\n";         
                print "-x\tunique tar file suffix (max 3 characters - remainder is truncated)\n";
                print "-S\trun sanity test\n";          
                print "-T\tcreate gzipped/tar file\n";
                print "\n\t* minimum required for script to run\n";     
                print "\n";     
                print "--\n";                   
                print "Free Speech... Recognition\n";
                print "http://www.voxforge.org\n\n";
                exit;
        } elsif ($opt_S) { # Sanity test switch
                $self->{'testing'} = 1; 
                $self->{"audiofile"}="AudioBook/test/audio.wav";
                #$self->{"textFile"}="AudioBook/test/text-simple.txt";
                $self->{"textFile"}="AudioBook/test/text-original.txt";
                $self->{"pronDict"}="AudioBook/interim_files/VoxForgeDict";
                $self->{"tarSuffix"}=_random_characters(3);
                $self->{"username"}="test";
                $self->{"average_sentence_length"}= $default_average_sentence_length;
                $self->{"max_sentence_length"}= $default_max_sentence_length;
                $self->{"min_pause_for_sentence_break"}=$default_min_pause_for_sentence_break;
                
                $self->{"log_single_quotes"}= 1;
                $self->{"verify_segments"}=1;   
                $self->{"verify_out_of_vocabulary_pronunciations"}=1;   
                $self->{"README"}="AudioBook/test/README";
                $self->{"LICENSE"}="AudioBook/test/LICENSE";
        } elsif ($opt_a and $opt_t) {   
                if (-r $opt_a) {
                        $self->{"audiofile"}=$opt_a;
                } else {
                        die "can't open -a" . $self->{"audiofile"} . "\n";              
                }
                if (-r $opt_t) {
                        $self->{"textFile"}=$opt_t;
                } else {
                        die "can't open -t" . $self->{"textFile"} . "\n";               
                }
                if (defined($opt_d)) {
                        if (-r $opt_d) {
                                $self->{"pronDict"}=$opt_d;
                        } else {
                                die "can't open -d" . $self->{"pronDict"} . "\n";       
                        }
                } else {
                        $self->{"pronDict"}="AudioBook/input_files/VoxForgeDict";       
                }
                ### Audio Processing
                if ($opt_s) {
                        $self->{"average_sentence_length"}=$opt_s;
                } else {
                        $self->{"average_sentence_length"}= $default_average_sentence_length;   
                }
                if ($opt_m) {
                        $self->{"max_sentence_length"}=$opt_m;
                } else {
                        $self->{"max_sentence_length"}= $default_max_sentence_length;   
                }
                if ($opt_p) {
                        $self->{"min_pause_for_sentence_break"}=$opt_p;
                } else {
                        $self->{"min_pause_for_sentence_break"}= $default_min_pause_for_sentence_break; 
                }       
                if ($opt_q) {
                        if ($opt_v =~ /^n|no$/i){
                                $self->{"log_single_quotes"}= 0;
                        } else {
                                $self->{"log_single_quotes"}= 1;        
                        }
                } else {
                        $self->{"log_single_quotes"}= 1;        
                }       
                if ($opt_b) {
                        $self->{"beam_width"}=$opt_b;
                } else {
                        $self->{"beam_width"}=250;      
                }
                if ($opt_v) {
                        $self->{"verify_segments"}=1;
                } else {
                        $self->{"verify_segments"}=0;   
                }       
                if ($opt_w) {
                        $self->{"verify_out_of_vocabulary_pronunciations"}=1;
                } else {
                        $self->{"verify_out_of_vocabulary_pronunciations"}=0;   
                }       
                ### Tar file processing
                if (defined($opt_T)) {
                        if ($opt_x) {
                                $self->{"tarSuffix"}=substr($opt_x,0,3); # only use 1st 3 characters.                   
                        }else {
                                $self->{"tarSuffix"}=_random_characters(3);
                        }
                        if ($opt_u) {
                                $self->{"username"}=$opt_u;     
                        }else {
                                $self->{"username"}="anonymous";
                        }       
                        if ($opt_r) {
                                if (-r $opt_r) {
                                        $self->{"README"}=$opt_r;       
                                } else {
                                        die "can't open -r" . $self->{"README"} . "\n";                         
                                }
                        } else {
                                $self->{"README"}="AudioBook/input_files/README";
                        }               
                        if ($opt_l) {
                                if (-r $opt_l) {
                                        $self->{"LICENSE"}=$opt_l;      
                                } else {
                                        die "can't open -l" . $self->{"LICENSE"} . "\n";                                
                                }
                        } else {
                                $self->{"LICENSE"}="AudioBook/input_files/LICENSE";
                        }
                }
        } elsif ($opt_i) {
                if ($opt_i) {
                        $self->{"interactive"}=1;
                }
                if (defined($opt_d)) {
                        if (-r $opt_d) {
                                $self->{"pronDict"}=$opt_d;
                        } else {
                                die "can't open -d" . $self->{"pronDict"} . "\n";       
                        }
                } else {
                        $self->{"pronDict"}="AudioBook/input_files/VoxForgeDict";       
                }
        } else {
                print "\nVoxForge Audio Segmentation Script\n"; 
                print   "==================================\n"; 
                print "Parms -a and -t need to be defined. Use -h parameter for more information\n\n";
                print "--\n";                   
                print "Free Speech... Recognition\n";
                print "http://www.voxforge.org\n\n";
                exit;
        }
        print "audiofile:" . $self->{"audiofile"}. "\n" if $debug;
        print "textFile:" . $self->{"textFile"}. "\n" if $debug;
        print "pronDict:" . $self->{"pronDict"} . "\n\n" if $debug;     
}

=head2 Gettors 

=item * getAverage_sentence_length()

=cut

sub getAverage_sentence_length {
        my $self = shift;
        return $self->{"average_sentence_length"};
}

=item * getInteractive()

=cut

sub getInteractive {
        my $self = shift;
        return $self->{"interactive"};
}

=item * getTesting()

=cut

sub getTesting {
        my $self = shift;
        return $self->{'testing'};
}

=item * getBeam_width()

=cut

sub getBeam_width {
        my $self = shift;
        return $self->{"beam_width"};
}

=item * getMax_sentence_length()

=cut

sub getMax_sentence_length {
        my $self = shift;
        return $self->{"max_sentence_length"};
}

=item * getMin_pause_for_sentence_break()

=cut

sub getMin_pause_for_sentence_break {
        my $self = shift;
        return $self->{"min_pause_for_sentence_break"};
}

=item * getLog_single_quotes()

=cut

sub getLog_single_quotes {
        my $self = shift;
        return $self->{"log_single_quotes"};
}


=item * getTextFile()

=cut

sub getTextFile {
        my $self = shift;
        return $self->{"textFile"};
}

=item * getAudiofile()

=cut

sub getAudiofile {
        my $self = shift;
        return $self->{"audiofile"};
}

=item * getUsername()

=cut

sub getUsername {
        my $self = shift;
        return $self->{"username"};
}    

=item * getLog()

=cut

sub getLog {
        my $self = shift;
        return $self->{"log"};
}


=item * getPronDict()

=cut

sub getPronDict {
        my $self = shift;
        return $self->{"pronDict"};
}       

=item * getHtk_files()

=cut

sub getHtk_files {
        my $self = shift;
        return $self->{'htk_files'};
}  

=item * getG2p_model()

=cut

sub getG2p_model {
        my $self = shift;
        return $self->{'g2p_model'};
}

=item * getDebug()

=cut

sub getDebug {
        my $self = shift;
        return $self->{'debug'};
}

=item * getDebug()

=cut

sub getVerify_segments {
        my $self = shift;
        return $self->{'verify_segments'};
}

=item * getVerify_out_of_vocabulary_pronunciations()

=cut

sub getVerify_out_of_vocabulary_pronunciations {
        my $self = shift;
        return $self->{"verify_out_of_vocabulary_pronunciations"};
}
                

=head1 Change Log    

  2008/06/12 - 0.2.2 - created CommandLine class to permit interactive validation of missing word pronunciations
  2008/06/1 - 0.2.1 - refacture to create Chapter, Segments & MissingWords classes
  2008/06/09 - 0.2.1 - refacture to create Chapter, Segments & MissingWords classes
  2008/05/02 - 0.2 - convert to class; major refacture ; renamed fullrun.pl to AudioBook.pm                                                       
  2008/01/31 - 0.1 - created
        
=head1 AUTHOR
    
  Ken MacLean
  contact@voxforge.org
      
=head1 COPYRIGHT AND LICENSE       
      
Copyright (C) 2008 Ken MacLean
   
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.

=cut

1;