Adding pulseaudio input support to chrome

media/audio/pulse/pulse_wrapper.h

Index: media/audio/pulse/pulse_wrapper.h
diff --git a/media/audio/pulse/pulse_wrapper.h b/media/audio/pulse/pulse_wrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d3fd188759e69a200cd4134657c05ed2f267675
--- /dev/null
+++ b/media/audio/pulse/pulse_wrapper.h
@@ -0,0 +1,148 @@
+// Copyright 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 <pulse/pulseaudio.h>
+
+#include "base/basictypes.h"
+#include "base/scoped_native_library.h"
+
+namespace media {
+
+// PulseWrapper is a stateless class that loads the pulse audio library
+// dynamically and wraps the pulse library commands we want to use.
+class PulseWrapper {
+ public:
+  PulseWrapper();
+  virtual ~PulseWrapper();
+
+  static PulseWrapper* Create();
+
+  typedef pa_mainloop_api*(*PaThreadedMainloopGetApiT)(pa_threaded_mainloop* m);
+  typedef void(*PaThreadedMainloopFreeT)(pa_threaded_mainloop* m);
+  typedef pa_threaded_mainloop*(*PaThreadedMainloopNewT)();
+  typedef void(*PaThreadedMainloopLockT)(pa_threaded_mainloop* m);
+  typedef void(*PaThreadedMainloopSignalT)(
+      pa_threaded_mainloop* m, int wait_for_accept);
+  typedef int(*PaThreadedMainloopStartT)(pa_threaded_mainloop* m);
+  typedef void(*PaThreadedMainloopStopT)(pa_threaded_mainloop* m);
+  typedef void(*PaThreadedMainloopUnlockT)(pa_threaded_mainloop* m);
+  typedef void(*PaThreadedMainloopWaitT)(pa_threaded_mainloop* m);
+  typedef pa_channel_map*(*PaChannelMapInitT)(pa_channel_map* m);
+  typedef int(*PaContextConnectT)(
+      pa_context* c, const char* server, pa_context_flags_t flags,
+      const pa_spawn_api* api);
+  typedef void(*PaContextDisconnectT)(pa_context* c);
+  typedef pa_operation*(*PaContextGetServerInfoT)(
+      pa_context* c, pa_server_info_cb_t cb, void* userdata);
+  typedef pa_operation*(*PaContextGetSourceInfoByIndexT)(
+      pa_context* c, uint32_t idx, pa_source_info_cb_t cb, void* userdata);
+  typedef pa_operation*(*PaContextGetSourceInfoListT)(
+      pa_context* c, pa_source_info_cb_t cb, void* userdata);
+  typedef pa_context_state_t(*PaContextGetStateT)(pa_context* c);
+  typedef pa_context*(*PaContextNew)(
+      pa_mainloop_api* mainloop, const char* name);
+  typedef pa_operation*(*PaContextSetSourceVolumeByIndexT)(
+      pa_context* c, uint32_t idx, const pa_cvolume* volume,
+      pa_context_success_cb_t cb, void* userdata);
+  typedef void(*PaContextSetStateCallbackT)(
+      pa_context* c, pa_context_notify_cb_t cb, void* userdata);
+  typedef void(*PaContextUnrefT)(pa_context* c);
+  typedef pa_operation_state_t(*PaOperationGetStateT)(pa_operation* o);
+  typedef void(*PaOperationUnrefT)(pa_operation* o);
+  typedef int(*PaStreamBeginWriteT)(pa_stream* p, void** data, size_t* nbytes);
+  typedef int(*PaStreamConnectPlaybackT)(
+      pa_stream* s, const char* dev, const pa_buffer_attr* attr,
+      pa_stream_flags_t flags, const pa_cvolume* volume,
+      pa_stream* sync_stream);
+  typedef int(*PaStreamConnectRecordT)(
+      pa_stream* s, const char* dev, const pa_buffer_attr* attr,
+      pa_stream_flags_t flags);
+  typedef pa_operation*(*PaStreamCorkT)(
+      pa_stream* s, int b, pa_stream_success_cb_t cb, void* userdata);
+  typedef int(*PaStreamDisconnectT)(pa_stream* s);
+  typedef int(*PaStreamDropT)(pa_stream *p);
+  typedef pa_operation*(*PaStreamFlushT)(
+      pa_stream* s, pa_stream_success_cb_t cb, void* userdata);
+  typedef uint32_t(*PaStreamGetDeviceIndexT)(pa_stream* s);
+  typedef int(*PaStreamGetLatencyT)(
+      pa_stream* s, pa_usec_t* r_usec, int* negative);
+  typedef pa_stream_state_t(*PaStreamGetStateT)(pa_stream* p);
+  typedef pa_stream*(*PaStreamNewT)(
+      pa_context*  c, const char*  name, const pa_sample_spec*  ss,
+      const pa_channel_map *  map);
+  typedef size_t(*PaStreamReadableSizeT)(pa_stream *p);
+  typedef int(*PaStreamPeekT)(
+      pa_stream* p, const void** data, size_t* nbytes);
+  typedef void(*PaStreamSetReadCallbackT)(
+      pa_stream* p, pa_stream_request_cb_t cb, void* userdata);
+  typedef void(*PaStreamSetStateCallbackT)(
+      pa_stream* s, pa_stream_notify_cb_t cb, void* userdata);
+  typedef void(*PaStreamUnrefT)(pa_stream* s);
+  typedef void(*PaStreamSetWriteCallbackT)(
+      pa_stream *p, pa_stream_request_cb_t cb, void *userdata);
+  typedef int(*PaStreamWriteT)(
+      pa_stream* p, const void* data, size_t nbytes,
+      pa_free_cb_t free_cb, int64_t offset, pa_seek_mode_t seek);
+  typedef int(*PaContextErrnoT)(pa_context *c);
+  typedef const char*(*PaStrerrorT)(int error);
+  typedef pa_cvolume*(*PaCvolumeSetT)(
+      pa_cvolume* a, unsigned  channels, pa_volume_t v);
+
+  PaThreadedMainloopGetApiT pa_threaded_mainloop_get_api_;
+  PaThreadedMainloopFreeT pa_threaded_mainloop_free_;
+  PaThreadedMainloopNewT pa_threaded_mainloop_new_;
+  PaThreadedMainloopLockT pa_threaded_mainloop_lock_;
+  PaThreadedMainloopSignalT pa_threaded_mainloop_signal_;
+  PaThreadedMainloopStartT pa_threaded_mainloop_start_;
+  PaThreadedMainloopStopT pa_threaded_mainloop_stop_;
+  PaThreadedMainloopUnlockT pa_threaded_mainloop_unlock_;
+  PaThreadedMainloopWaitT pa_threaded_mainloop_wait_;
+  PaChannelMapInitT pa_channel_map_init_;
+  PaContextConnectT pa_context_connect_;
+  PaContextDisconnectT pa_context_disconnect_;
+  PaContextErrnoT pa_context_errno_;
+  PaContextGetServerInfoT pa_context_get_server_info_;
+  PaContextGetSourceInfoByIndexT pa_context_get_source_info_by_index_;
+  PaContextGetSourceInfoListT pa_context_get_source_info_list_;
+  PaContextGetStateT pa_context_get_state_;
+  PaContextNew pa_context_new_;
+  PaContextSetSourceVolumeByIndexT pa_context_set_source_volume_by_index_;
+  PaContextSetStateCallbackT pa_context_set_state_callback_;
+  PaContextUnrefT pa_context_unref_;
+  PaOperationGetStateT pa_operation_get_state_;
+  PaOperationUnrefT pa_operation_unref_;
+  PaStreamBeginWriteT pa_stream_begin_write_;
+  PaStreamConnectPlaybackT pa_stream_connect_playback_;
+  PaStreamConnectRecordT pa_stream_connect_record_;
+  PaStreamCorkT pa_stream_cork_;
+  PaStreamDisconnectT pa_stream_disconnect_;
+  PaStreamDropT pa_stream_drop_;
+  PaStreamFlushT pa_stream_flush_;
+  PaStreamGetDeviceIndexT pa_stream_get_device_index_;
+  PaStreamGetLatencyT pa_stream_get_latency_;
+  PaStreamGetStateT pa_stream_get_state_;
+  PaStreamNewT pa_stream_new_;
+  PaStreamPeekT pa_stream_peek_;
+  PaStreamReadableSizeT pa_stream_readable_size_;
+  PaStreamSetReadCallbackT pa_stream_set_read_callback_;
+  PaStreamSetStateCallbackT pa_stream_set_state_callback_;
+  PaStreamSetWriteCallbackT pa_stream_set_write_callback_;
+  PaStreamUnrefT pa_stream_unref_;
+  PaStreamWriteT pa_stream_write_;
+  PaStrerrorT pa_strerror_;
+  PaCvolumeSetT pa_cvolume_set_;
+
+ private:
+  // Loads the pulse library and symbols.
+  bool Load();
+
+  // Binds the |function_pointer| to the Pulse function.
+  template <class T>
+  bool Bind(T* function_pointer, const std::string& function_name);
+
+  base::ScopedNativeLibrary pulse_lib_;
+  DISALLOW_COPY_AND_ASSIGN(PulseWrapper);
+};
+
+}  // namespace media