Renamed speech input implementation from to speech_recognition_*. The namespace has been renamed fr…

content/browser/speech/audio_encoder.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 The Chromium 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 "content/browser/speech/audio_encoder.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "third_party/flac/flac.h"
 #include "third_party/speex/speex.h"
 
 using std::string;
 
 namespace {
 
 //-------------------------------- FLACEncoder ---------------------------------
 
 const char* const kContentTypeFLAC = "audio/x-flac; rate=";
 const int kFLACCompressionLevel = 0;  // 0 for speed
 
-class FLACEncoder : public speech_input::AudioEncoder {
+class FLACEncoder : public speech::AudioEncoder {
  public:
   FLACEncoder(int sampling_rate, int bits_per_sample);
   virtual ~FLACEncoder();
   virtual void Encode(const short* samples, int num_samples);
   virtual void Flush();
 
  private:
   static FLAC__StreamEncoderWriteStatus WriteCallback(
       const FLAC__StreamEncoder* encoder,
       const FLAC__byte buffer[],
@@ skipping 65 matching lines @@
 //-------------------------------- SpeexEncoder --------------------------------
 
 const char* const kContentTypeSpeex = "audio/x-speex-with-header-byte; rate=";
 const int kSpeexEncodingQuality = 8;
 const int kMaxSpeexFrameLength = 110;  // (44kbps rate sampled at 32kHz).
 
 // Since the frame length gets written out as a byte in the encoded packet,
 // make sure it is within the byte range.
 COMPILE_ASSERT(kMaxSpeexFrameLength <= 0xFF, invalidLength);
 
-class SpeexEncoder : public speech_input::AudioEncoder {
+class SpeexEncoder : public speech::AudioEncoder {
  public:
   explicit SpeexEncoder(int sampling_rate);
   virtual ~SpeexEncoder();
   virtual void Encode(const short* samples, int num_samples);
   virtual void Flush() {}
 
  private:
   void* encoder_state_;
   SpeexBits bits_;
   int samples_per_frame_;
@@ skipping 35 matching lines @@
     // is the packet format for MIME type x-speex-with-header-byte.
     int frame_length = speex_bits_write(&bits_, encoded_frame_data_ + 1,
                                         kMaxSpeexFrameLength);
     encoded_frame_data_[0] = static_cast<char>(frame_length);
     AppendToBuffer(new string(encoded_frame_data_, frame_length + 1));
   }
 }
 
 }  // namespace
 
-namespace speech_input {
+namespace speech {
 
 AudioEncoder* AudioEncoder::Create(Codec codec,
                                    int sampling_rate,
                                    int bits_per_sample) {
   if (codec == CODEC_FLAC)
     return new FLACEncoder(sampling_rate, bits_per_sample);
   return new SpeexEncoder(sampling_rate);
 }
 
 AudioEncoder::AudioEncoder(const std::string& mime_type)
@@ skipping 21 matching lines @@
 
   STLDeleteElements(&audio_buffers_);
 
   return true;
 }
 
 void AudioEncoder::AppendToBuffer(std::string* item) {
   audio_buffers_.push_back(item);
 }
 
-}  // namespace speech_input
+}  // namespace speech