dmazzoni's fixes to ALSA for speech_synthesis

tts_service.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <string>
 
 #include "audio_output.h"
 #include "log.h"
 #include "resampler.h"
@@ skipping 174 matching lines @@
     }
 
     utterance_running_ = true;
 
     mutex_->Unlock();
 
     if (!current_utterance_) {
       continue;
     }
 
-    engine_->SetRate(current_utterance_->options->rate);
-    engine_->SetPitch(current_utterance_->options->pitch);
-    engine_->SetVolume(current_utterance_->options->volume);
+    if (current_utterance_->options) {
+      engine_->SetRate(current_utterance_->options->rate);
+      engine_->SetPitch(current_utterance_->options->pitch);
+      engine_->SetVolume(current_utterance_->options->volume);
+    }
 
     // Synthesize the current utterance.  The TTS engine will call our
     // callback method, Receive, repeatedly while it performs synthesis.
     // During that callback, we check if Stop was called and can cause
     // this method to exit prematurely.  Otherwise this method won't exit
     // until this utterance is done synthesizing, and then current_utterance_
     // will be set to NULL.
     int samples_output = 0;
     engine_->SetVoice(current_utterance_->voice_index);
 
     resampler_ = NULL;
     if (audio_output_->GetSampleRate() != engine_->GetSampleRate()) {
       resampler_ = new Resampler(this,
                                  engine_->GetSampleRate(),
                                  audio_output_->GetSampleRate(),
                                  audio_buffer_size_);
       engine_->SetReceiver(resampler_);
     } else {
       engine_->SetReceiver(this);
     }
 
+    // Save the utterance text because current_utterance_ is deleted
+    // by the Done() callback before the call to SynthesizeText exits.
+    string utterance_text = current_utterance_->text;
+
     engine_->SynthesizeText(
-        current_utterance_->text.c_str(),
+        utterance_text.c_str(),
         audio_buffer_,
         audio_buffer_size_,
         &samples_output);
 
     // TODO(chaitanyag): Make the completion callback here.
-    LOG(INFO) << "Done: " << current_utterance_->text.c_str();
+    LOG(INFO) << "Done: " << utterance_text.c_str();
 
     mutex_->Lock();
     if (utterance_running_ == false) {
       // The utterance was interrupted
       engine_->Stop();
     }
     utterance_running_ = false;
     cond_var_->Signal();
     mutex_->Unlock();
 
@@ skipping 37 matching lines @@
     cond_var_->WaitWithTimeout(mutex_, ms_to_sleep);
     if (service_running_ == false || utterance_running_ == false) {
       mutex_->Unlock();
       return TTS_CALLBACK_HALT;
     }
     mutex_->Unlock();
   }
 
   bool success = ring_buffer_->Write(data, num_samples);
   if (!success) {
+    LOG(INFO) << "Unable to write to ring buffer";
     exit(0);
   }
 
   if (status == TTS_SYNTH_DONE) {
     ring_buffer_->MarkFinished();
   }
 
   return TTS_CALLBACK_CONTINUE;
 }
 
@@ skipping 12 matching lines @@
   ring_buffer_->Read(samples, copy_len);
   for (int i = copy_len; i < size; i++) {
     samples[i] = 0;
   }
 
   return !ring_buffer_->IsFinished();
 }
 
 }  // namespace speech_synthesis