1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_SYNC_READER_H_ 6 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_SYNC_READER_H_ 7 8 #include "base/process/process.h" 9 #include "base/sync_socket.h" 10 #include "base/synchronization/lock.h" 11 #include "base/time/time.h" 12 #include "media/audio/audio_output_controller.h" 13 #include "media/base/audio_bus.h" 14 15 #if defined(OS_POSIX) 16 #include "base/file_descriptor_posix.h" 17 #endif 18 19 namespace base { 20 class SharedMemory; 21 } 22 23 namespace content { 24 25 // A AudioOutputController::SyncReader implementation using SyncSocket. This 26 // is used by AudioOutputController to provide a low latency data source for 27 // transmitting audio packets between the browser process and the renderer 28 // process. 29 class AudioSyncReader : public media::AudioOutputController::SyncReader { 30 public: 31 AudioSyncReader(base::SharedMemory* shared_memory, 32 const media::AudioParameters& params); 33 34 virtual ~AudioSyncReader(); 35 36 // media::AudioOutputController::SyncReader implementations. 37 virtual void UpdatePendingBytes(uint32 bytes) OVERRIDE; 38 virtual void Read(media::AudioBus* dest) OVERRIDE; 39 virtual void Close() OVERRIDE; 40 41 bool Init(); 42 bool PrepareForeignSocket(base::ProcessHandle process_handle, 43 base::SyncSocket::TransitDescriptor* descriptor); 44 45 private: 46 // Blocks until data is ready for reading or a timeout expires. Returns false 47 // if an error or timeout occurs. 48 bool WaitUntilDataIsReady(); 49 50 const base::SharedMemory* const shared_memory_; 51 52 // Mutes all incoming samples. This is used to prevent audible sound 53 // during automated testing. 54 const bool mute_audio_; 55 56 // Socket for transmitting audio data. 57 scoped_ptr<base::CancelableSyncSocket> socket_; 58 59 // Socket to be used by the renderer. The reference is released after 60 // PrepareForeignSocketHandle() is called and ran successfully. 61 scoped_ptr<base::CancelableSyncSocket> foreign_socket_; 62 63 // Shared memory wrapper used for transferring audio data to Read() callers. 64 scoped_ptr<media::AudioBus> output_bus_; 65 66 // Maximum amount of audio data which can be transferred in one Read() call. 67 const int packet_size_; 68 69 // Track the number of times the renderer missed its real-time deadline and 70 // report a UMA stat during destruction. 71 size_t renderer_callback_count_; 72 size_t renderer_missed_callback_count_; 73 74 // The maximum amount of time to wait for data from the renderer. Calculated 75 // from the parameters given at construction. 76 const base::TimeDelta maximum_wait_time_; 77 78 // The index of the audio buffer we're expecting to be sent from the renderer; 79 // used to block with timeout for audio data. 80 uint32 buffer_index_; 81 82 DISALLOW_COPY_AND_ASSIGN(AudioSyncReader); 83 }; 84 85 } // namespace content 86 87 #endif // CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_SYNC_READER_H_ 88