Fixes in AlsaPcmOutputStream.

media/audio/linux/alsa_output.h

 // Copyright (c) 2010 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.
 //
 // Creates an output stream based on the ALSA PCM interface.
 //
 // On device write failure, the stream will move itself to an invalid state.
 // No more data will be pulled from the data source, or written to the device.
 // All calls to public API functions will either no-op themselves, or return an
 // error if possible.  Specifically, If the stream is in an error state, Open()
@@ skipping 21 matching lines @@
 
 #include <string>
 
 #include "base/lock.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/thread.h"
 #include "media/audio/audio_output.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
+namespace media {
+class SeekableBuffer;
+};  // namespace media
+
 class AlsaWrapper;
 class AudioManagerLinux;
 
 class AlsaPcmOutputStream :
     public AudioOutputStream,
     public base::RefCountedThreadSafe<AlsaPcmOutputStream> {
  public:
   // String for the generic "default" ALSA device that has the highest
   // compatibility and chance of working.
   static const char kDefaultDevice[];
@@ skipping 35 matching lines @@
  private:
   friend class base::RefCountedThreadSafe<AlsaPcmOutputStream>;
   friend class AlsaPcmOutputStreamTest;
   FRIEND_TEST(AlsaPcmOutputStreamTest, AutoSelectDevice_DeviceSelect);
   FRIEND_TEST(AlsaPcmOutputStreamTest, AutoSelectDevice_FallbackDevices);
   FRIEND_TEST(AlsaPcmOutputStreamTest, AutoSelectDevice_HintFail);
   FRIEND_TEST(AlsaPcmOutputStreamTest, BufferPacket);
   FRIEND_TEST(AlsaPcmOutputStreamTest, BufferPacket_Negative);
   FRIEND_TEST(AlsaPcmOutputStreamTest, BufferPacket_StopStream);
   FRIEND_TEST(AlsaPcmOutputStreamTest, BufferPacket_Underrun);
-  FRIEND_TEST(AlsaPcmOutputStreamTest, BufferPacket_UnfinishedPacket);
+  FRIEND_TEST(AlsaPcmOutputStreamTest, BufferPacket_FullBuffer);
   FRIEND_TEST(AlsaPcmOutputStreamTest, ConstructedState);
   FRIEND_TEST(AlsaPcmOutputStreamTest, LatencyFloor);
   FRIEND_TEST(AlsaPcmOutputStreamTest, OpenClose);
   FRIEND_TEST(AlsaPcmOutputStreamTest, PcmOpenFailed);
   FRIEND_TEST(AlsaPcmOutputStreamTest, PcmSetParamsFailed);
   FRIEND_TEST(AlsaPcmOutputStreamTest, ScheduleNextWrite);
   FRIEND_TEST(AlsaPcmOutputStreamTest, ScheduleNextWrite_StopStream);
   FRIEND_TEST(AlsaPcmOutputStreamTest, StartStop);
   FRIEND_TEST(AlsaPcmOutputStreamTest, WritePacket_FinishedPacket);
   FRIEND_TEST(AlsaPcmOutputStreamTest, WritePacket_NormalPacket);
   FRIEND_TEST(AlsaPcmOutputStreamTest, WritePacket_StopStream);
   FRIEND_TEST(AlsaPcmOutputStreamTest, WritePacket_WriteFails);
 
   virtual ~AlsaPcmOutputStream();
 
-  // In-memory buffer to hold sound samples before pushing to the sound device.
-  // TODO(ajwong): There are now about 3 buffer/packet implementations. Factor
-  // them out.
-  struct Packet {
-    explicit Packet(uint32 new_capacity)
-        : capacity(new_capacity),
-          size(0),
-          used(0),
-          buffer(new char[capacity]) {
-    }
-    uint32 capacity;
-    uint32 size;
-    uint32 used;
-    scoped_array<char> buffer;
-  };
-
   // Flags indicating the state of the stream.
   enum InternalState {
     kInError = 0,
     kCreated,
     kIsOpened,
     kIsPlaying,
     kIsStopped,
     kIsClosed
   };
   friend std::ostream& operator<<(std::ostream& os, InternalState);
 
   // Various tasks that complete actions started in the public API.
   void OpenTask(uint32 packet_size);
   void StartTask();
   void CloseTask();
 
   // Functions to get another packet from the data source and write it into the
   // ALSA device.
-  void BufferPacket(Packet* packet);
-  void WritePacket(Packet* packet);
+  void BufferPacket();
+  void WritePacket();
   void WriteTask();
-  void ScheduleNextWrite(Packet* current_packet);
+  void ScheduleNextWrite();
 
   // Utility functions for talking with the ALSA API.
-  static uint32 FramesInPacket(const Packet& packet, uint32 bytes_per_frame);
   static uint32 FramesToMicros(uint32 frames, uint32 sample_rate);
   static uint32 FramesToMillis(uint32 frames, uint32 sample_rate);
   std::string FindDeviceForChannels(uint32 channels);
   snd_pcm_t* OpenDevice(const std::string& device_name,
                         uint32 channels,
                         uint32 latency);
   bool CloseDevice(snd_pcm_t* handle);
   snd_pcm_sframes_t GetAvailableFrames();
+  snd_pcm_sframes_t GetCurrentDelay();
 
   // Attempts to find the best matching linux audio device for the given number
   // of channels.  This function will set |device_name_| and |should_downmix_|.
   snd_pcm_t* AutoSelectDevice(uint32 latency);
 
   // Thread-asserting accessors for member variables.
   AudioManagerLinux* manager();
 
   // Struct holding all mutable the data that must be shared by the
   // message_loop() and the thread that created the object.
@@ skipping 48 matching lines @@
   const snd_pcm_format_t pcm_format_;
   const uint32 channels_;
   const uint32 sample_rate_;
   const uint32 bytes_per_sample_;
   const uint32 bytes_per_frame_;
 
   // Device configuration data. Populated after OpenTask() completes.
   std::string device_name_;
   bool should_downmix_;
   uint32 latency_micros_;
+  uint32 packet_size_;
   uint32 micros_per_packet_;
   uint32 bytes_per_output_frame_;
+  uint32 alsa_buffer_frames_;
 
   // Flag indicating the code should stop reading from the data source or
   // writing to the ALSA device.  This is set because the device has entered
   // an unrecoverable error state, or the ClosedTask() has executed.
   bool stop_stream_;
 
   // Wrapper class to invoke all the ALSA functions.
   AlsaWrapper* wrapper_;
 
   // Audio manager that created us.  Used to report that we've been closed.
   // This should only be used on the |client_thread_loop_|.  Access via
   // the manager() function.
   AudioManagerLinux* manager_;
 
   // Handle to the actual PCM playback device.
   snd_pcm_t* playback_handle_;
 
-  scoped_ptr<Packet> packet_;
+  scoped_ptr<media::SeekableBuffer> buffer_;
   uint32 frames_per_packet_;
 
   // Used to check which message loop is allowed to call the public APIs.
   MessageLoop* client_thread_loop_;
 
   // The message loop responsible for querying the data source, and writing to
   // the output device.
   MessageLoop* message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(AlsaPcmOutputStream);
 };
 
 #endif  // MEDIA_AUDIO_LINUX_ALSA_OUTPUT_H_