sink-input, source-output: Assign to volume from only one place

[pulseaudio] / src / pulsecore / sink-input.h

diff --git a/src/pulsecore/sink-input.h b/src/pulsecore/sink-input.h
index 3d2a8c0dcaab2307d66f1fe5855cf432beb05001..2be2c33e4b3090e9f709884745f142407e70f536 100644 (file)
--- a/src/pulsecore/sink-input.h
+++ b/src/pulsecore/sink-input.h
@@ -9,7 +9,7 @@
 
   PulseAudio is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
 
   PulseAudio is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published

-  by the Free Software Foundation; either version 2 of the License,
+  by the Free Software Foundation; either version 2.1 of the License,

   or (at your option) any later version.
 
   PulseAudio is distributed in the hope that it will be useful, but
   or (at your option) any later version.
 
   PulseAudio is distributed in the hope that it will be useful, but


@@ -28,7 +28,7 @@
 typedef struct pa_sink_input pa_sink_input;
 
 #include <pulse/sample.h>
 typedef struct pa_sink_input pa_sink_input;
 
 #include <pulse/sample.h>

-#include <pulsecore/hook-list.h>
+#include <pulse/format.h>

 #include <pulsecore/memblockq.h>
 #include <pulsecore/resampler.h>
 #include <pulsecore/module.h>
 #include <pulsecore/memblockq.h>
 #include <pulsecore/resampler.h>
 #include <pulsecore/module.h>


@@ -37,14 +37,15 @@ typedef struct pa_sink_input pa_sink_input;
 #include <pulsecore/core.h>
 
 typedef enum pa_sink_input_state {
 #include <pulsecore/core.h>
 
 typedef enum pa_sink_input_state {

-    PA_SINK_INPUT_INIT,         /*< The stream is not active yet, because pa_sink_put() has not been called yet */
+    PA_SINK_INPUT_INIT,         /*< The stream is not active yet, because pa_sink_input_put() has not been called yet */

     PA_SINK_INPUT_DRAINED,      /*< The stream stopped playing because there was no data to play */
     PA_SINK_INPUT_RUNNING,      /*< The stream is alive and kicking */
     PA_SINK_INPUT_CORKED,       /*< The stream was corked on user request */
     PA_SINK_INPUT_UNLINKED      /*< The stream is dead */
     PA_SINK_INPUT_DRAINED,      /*< The stream stopped playing because there was no data to play */
     PA_SINK_INPUT_RUNNING,      /*< The stream is alive and kicking */
     PA_SINK_INPUT_CORKED,       /*< The stream was corked on user request */
     PA_SINK_INPUT_UNLINKED      /*< The stream is dead */

+    /* FIXME: we need a state for MOVING here */

 } pa_sink_input_state_t;
 
 } pa_sink_input_state_t;
 

-static inline pa_bool_t PA_SINK_INPUT_IS_LINKED(pa_sink_input_state_t x) {
+static inline bool PA_SINK_INPUT_IS_LINKED(pa_sink_input_state_t x) {

     return x == PA_SINK_INPUT_DRAINED || x == PA_SINK_INPUT_RUNNING || x == PA_SINK_INPUT_CORKED;
 }
 
     return x == PA_SINK_INPUT_DRAINED || x == PA_SINK_INPUT_RUNNING || x == PA_SINK_INPUT_CORKED;
 }
 


@@ -58,6 +59,9 @@ typedef enum pa_sink_input_flags {
     PA_SINK_INPUT_FIX_RATE = 64,
     PA_SINK_INPUT_FIX_CHANNELS = 128,
     PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND = 256,
     PA_SINK_INPUT_FIX_RATE = 64,
     PA_SINK_INPUT_FIX_CHANNELS = 128,
     PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND = 256,

+    PA_SINK_INPUT_NO_CREATE_ON_SUSPEND = 512,
+    PA_SINK_INPUT_KILL_ON_SUSPEND = 1024,
+    PA_SINK_INPUT_PASSTHROUGH = 2048

 } pa_sink_input_flags_t;
 
 struct pa_sink_input {
 } pa_sink_input_flags_t;
 
 struct pa_sink_input {


@@ -78,7 +82,8 @@ struct pa_sink_input {
     pa_module *module;                  /* may be NULL */
     pa_client *client;                  /* may be NULL */
 
     pa_module *module;                  /* may be NULL */
     pa_client *client;                  /* may be NULL */
 

-    pa_sink *sink;
+    pa_sink *sink;                      /* NULL while we are being moved */
+    pa_sink *origin_sink;               /* only set by filter sinks */

 
     /* A sink input may be connected to multiple source outputs
      * directly, so that they don't get mixed data of the entire
 
     /* A sink input may be connected to multiple source outputs
      * directly, so that they don't get mixed data of the entire


@@ -87,15 +92,39 @@ struct pa_sink_input {
 
     pa_sample_spec sample_spec;
     pa_channel_map channel_map;
 
     pa_sample_spec sample_spec;
     pa_channel_map channel_map;

+    pa_format_info *format;

 
     pa_sink_input *sync_prev, *sync_next;
 
 
     pa_sink_input *sync_prev, *sync_next;
 

-    pa_cvolume virtual_volume;
+    /* Also see http://pulseaudio.org/wiki/InternalVolumes */
+    pa_cvolume volume;             /* The volume clients are informed about */
+    pa_cvolume reference_ratio;    /* The ratio of the stream's volume to the sink's reference volume */
+    pa_cvolume real_ratio;         /* The ratio of the stream's volume to the sink's real volume */
+    /* volume_factor is an internally used "additional volume" that can be used
+     * by modules without having the volume visible to clients. volume_factor
+     * calculated by merging all the individual items in volume_factor_items.
+     * Modules must not modify these variables directly, instead
+     * pa_sink_input_add/remove_volume_factor() have to be used to add and
+     * remove items, or pa_sink_input_new_data_add_volume_factor() during input
+     * creation time. */
+    pa_cvolume volume_factor;
+    pa_hashmap *volume_factor_items;
+    pa_cvolume soft_volume;          /* The internal software volume we apply to all PCM data while it passes through. Usually calculated as real_ratio * volume_factor */

 
 

-    pa_cvolume volume;
-    pa_bool_t muted;
+    pa_cvolume volume_factor_sink; /* A second volume factor in format of the sink this stream is connected to. */
+    pa_hashmap *volume_factor_sink_items;

 
 

-    pa_resample_method_t resample_method;
+    bool volume_writable:1;
+
+    bool muted:1;
+
+    /* if true then the sink we are connected to and/or the volume
+     * set is worth remembering, i.e. was explicitly chosen by the
+     * user and not automatically. module-stream-restore looks for
+     * this.*/
+    bool save_sink:1, save_volume:1, save_muted:1;
+
+    pa_resample_method_t requested_resample_method, actual_resample_method;

 
     /* Returns the chunk of audio data and drops it from the
      * queue. Returns -1 on failure. Called from IO thread context. If
 
     /* Returns the chunk of audio data and drops it from the
      * queue. Returns -1 on failure. Called from IO thread context. If


@@ -106,6 +135,11 @@ struct pa_sink_input {
      * the full block. */
     int (*pop) (pa_sink_input *i, size_t request_nbytes, pa_memchunk *chunk); /* may NOT be NULL */
 
      * the full block. */
     int (*pop) (pa_sink_input *i, size_t request_nbytes, pa_memchunk *chunk); /* may NOT be NULL */
 

+    /* This is called when the playback buffer has actually played back
+       all available data. Return true unless there is more data to play back.
+       Called from IO context. */
+    bool (*process_underrun) (pa_sink_input *i);
+

     /* Rewind the queue by the specified number of bytes. Called just
      * before peek() if it is called at all. Only called if the sink
      * input driver ever plans to call
     /* Rewind the queue by the specified number of bytes. Called just
      * before peek() if it is called at all. Only called if the sink
      * input driver ever plans to call


@@ -116,7 +150,7 @@ struct pa_sink_input {
      * changes. Called from IO context. */
     void (*update_max_rewind) (pa_sink_input *i, size_t nbytes); /* may be NULL */
 
      * changes. Called from IO context. */
     void (*update_max_rewind) (pa_sink_input *i, size_t nbytes); /* may be NULL */
 

-    /* Called whenever the maxiumum request size of the sink
+    /* Called whenever the maximum request size of the sink

      * changes. Called from IO context. */
     void (*update_max_request) (pa_sink_input *i, size_t nbytes); /* may be NULL */
 
      * changes. Called from IO context. */
     void (*update_max_request) (pa_sink_input *i, size_t nbytes); /* may be NULL */
 


@@ -124,10 +158,14 @@ struct pa_sink_input {
      * changes. Called from IO context. */
     void (*update_sink_requested_latency) (pa_sink_input *i); /* may be NULL */
 
      * changes. Called from IO context. */
     void (*update_sink_requested_latency) (pa_sink_input *i); /* may be NULL */
 

-    /* Called whenver the latency range of the sink changes. Called
+    /* Called whenever the latency range of the sink changes. Called

      * from IO context. */
     void (*update_sink_latency_range) (pa_sink_input *i); /* may be NULL */
 
      * from IO context. */
     void (*update_sink_latency_range) (pa_sink_input *i); /* may be NULL */
 

+    /* Called whenever the fixed latency of the sink changes, if there
+     * is one. Called from IO context. */
+    void (*update_sink_fixed_latency) (pa_sink_input *i); /* may be NULL */
+

     /* If non-NULL this function is called when the input is first
      * connected to a sink or when the rtpoll/asyncmsgq fields
      * change. You usually don't need to implement this function
     /* If non-NULL this function is called when the input is first
      * connected to a sink or when the rtpoll/asyncmsgq fields
      * change. You usually don't need to implement this function


@@ -139,19 +177,27 @@ struct pa_sink_input {
      * disconnected from its sink. Called from IO thread context */
     void (*detach) (pa_sink_input *i);           /* may be NULL */
 
      * disconnected from its sink. Called from IO thread context */
     void (*detach) (pa_sink_input *i);           /* may be NULL */
 

-    /* If non-NULL called whenever the the sink this input is attached
+    /* If non-NULL called whenever the sink this input is attached

      * to suspends or resumes. Called from main context */
      * to suspends or resumes. Called from main context */

-    void (*suspend) (pa_sink_input *i, pa_bool_t b);   /* may be NULL */
+    void (*suspend) (pa_sink_input *i, bool b);   /* may be NULL */

 
 

-    /* If non-NULL called whenever the the sink this input is attached
-     * to changes. Called from main context */
-    void (*moved) (pa_sink_input *i);   /* may be NULL */
+    /* If non-NULL called whenever the sink this input is attached
+     * to suspends or resumes. Called from IO context */
+    void (*suspend_within_thread) (pa_sink_input *i, bool b);   /* may be NULL */
+
+    /* If non-NULL called whenever the sink input is moved to a new
+     * sink. Called from main context after the sink input has been
+     * detached from the old sink and before it has been attached to
+     * the new sink. If dest is NULL the move was executed in two
+     * phases and the second one failed; the stream will be destroyed
+     * after this call. */
+    void (*moving) (pa_sink_input *i, pa_sink *dest);   /* may be NULL */

 
     /* Supposed to unlink and destroy this stream. Called from main
      * context. */
     void (*kill) (pa_sink_input *i);             /* may NOT be NULL */
 
 
     /* Supposed to unlink and destroy this stream. Called from main
      * context. */
     void (*kill) (pa_sink_input *i);             /* may NOT be NULL */
 

-    /* Return the current latency (i.e. length of bufferd audio) of
+    /* Return the current latency (i.e. length of buffered audio) of

     this stream. Called from main context. This is added to what the
     PA_SINK_INPUT_MESSAGE_GET_LATENCY message sent to the IO thread
     returns */
     this stream. Called from main context. This is added to what the
     PA_SINK_INPUT_MESSAGE_GET_LATENCY message sent to the IO thread
     returns */


@@ -162,15 +208,36 @@ struct pa_sink_input {
     void (*state_change) (pa_sink_input *i, pa_sink_input_state_t state); /* may be NULL */
 
     /* If non-NULL this function is called before this sink input is
     void (*state_change) (pa_sink_input *i, pa_sink_input_state_t state); /* may be NULL */
 
     /* If non-NULL this function is called before this sink input is

-     * move to a sink and if it returns FALSE the move will not
+     * move to a sink and if it returns false the move will not

      * be allowed */
      * be allowed */

-    pa_bool_t (*may_move_to) (pa_sink_input *i, pa_sink *s); /* may be NULL */
+    bool (*may_move_to) (pa_sink_input *i, pa_sink *s); /* may be NULL */
+
+    /* If non-NULL this function is used to dispatch asynchronous
+     * control events. Called from main context. */
+    void (*send_event)(pa_sink_input *i, const char *event, pa_proplist* data); /* may be NULL */
+
+    /* If non-NULL this function is called whenever the sink input
+     * volume changes. Called from main context */
+    void (*volume_changed)(pa_sink_input *i); /* may be NULL */
+
+    /* If non-NULL this function is called whenever the sink input
+     * mute status changes. Called from main context */
+    void (*mute_changed)(pa_sink_input *i); /* may be NULL */

 
     struct {
         pa_sink_input_state_t state;
         pa_atomic_t drained;
 
 
     struct {
         pa_sink_input_state_t state;
         pa_atomic_t drained;
 

-        pa_bool_t attached; /* True only between ->attach() and ->detach() calls */
+        pa_cvolume soft_volume;
+        bool muted:1;
+
+        bool attached:1; /* True only between ->attach() and ->detach() calls */
+
+        /* rewrite_nbytes: 0: rewrite nothing, (size_t) -1: rewrite everything, otherwise how many bytes to rewrite */
+        bool rewrite_flush:1, dont_rewind_render:1;
+        size_t rewrite_nbytes;
+        uint64_t underrun_for, playing_for;
+        uint64_t underrun_for_sink; /* Like underrun_for, but in sink sample spec */

 
         pa_sample_spec sample_spec;
 
 
         pa_sample_spec sample_spec;
 


@@ -179,16 +246,8 @@ struct pa_sink_input {
         /* We maintain a history of resampled audio data here. */
         pa_memblockq *render_memblockq;
 
         /* We maintain a history of resampled audio data here. */
         pa_memblockq *render_memblockq;
 

-        /* 0: rewrite nothing, (size_t) -1: rewrite everything, otherwise how many bytes to rewrite */
-        size_t rewrite_nbytes;
-        pa_bool_t rewrite_flush, dont_rewind_render;
-        uint64_t underrun_for, playing_for;
-

         pa_sink_input *sync_prev, *sync_next;
 
         pa_sink_input *sync_prev, *sync_next;
 

-        pa_cvolume volume;
-        pa_bool_t muted;
-

         /* The requested latency for the sink */
         pa_usec_t requested_sink_latency;
 
         /* The requested latency for the sink */
         pa_usec_t requested_sink_latency;
 


@@ -198,12 +257,12 @@ struct pa_sink_input {
     void *userdata;
 };
 
     void *userdata;
 };
 

-PA_DECLARE_CLASS(pa_sink_input);
+PA_DECLARE_PUBLIC_CLASS(pa_sink_input);

 #define PA_SINK_INPUT(o) pa_sink_input_cast(o)
 
 enum {
 #define PA_SINK_INPUT(o) pa_sink_input_cast(o)
 
 enum {

-    PA_SINK_INPUT_MESSAGE_SET_VOLUME,
-    PA_SINK_INPUT_MESSAGE_SET_MUTE,
+    PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME,
+    PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE,

     PA_SINK_INPUT_MESSAGE_GET_LATENCY,
     PA_SINK_INPUT_MESSAGE_SET_RATE,
     PA_SINK_INPUT_MESSAGE_SET_STATE,
     PA_SINK_INPUT_MESSAGE_GET_LATENCY,
     PA_SINK_INPUT_MESSAGE_SET_RATE,
     PA_SINK_INPUT_MESSAGE_SET_STATE,


@@ -212,7 +271,15 @@ enum {
     PA_SINK_INPUT_MESSAGE_MAX
 };
 
     PA_SINK_INPUT_MESSAGE_MAX
 };
 

+typedef struct pa_sink_input_send_event_hook_data {
+    pa_sink_input *sink_input;
+    const char *event;
+    pa_proplist *data;
+} pa_sink_input_send_event_hook_data;
+

 typedef struct pa_sink_input_new_data {
 typedef struct pa_sink_input_new_data {

+    pa_sink_input_flags_t flags;
+

     pa_proplist *proplist;
 
     const char *driver;
     pa_proplist *proplist;
 
     const char *driver;


@@ -220,6 +287,7 @@ typedef struct pa_sink_input_new_data {
     pa_client *client;
 
     pa_sink *sink;
     pa_client *client;
 
     pa_sink *sink;

+    pa_sink *origin_sink;

 
     pa_resample_method_t resample_method;
 
 
     pa_resample_method_t resample_method;
 


@@ -227,42 +295,45 @@ typedef struct pa_sink_input_new_data {
 
     pa_sample_spec sample_spec;
     pa_channel_map channel_map;
 
     pa_sample_spec sample_spec;
     pa_channel_map channel_map;

-
-    pa_cvolume virtual_volume;
+    pa_format_info *format;
+    pa_idxset *req_formats;
+    pa_idxset *nego_formats;

 
     pa_cvolume volume;
 
     pa_cvolume volume;

-    pa_bool_t muted:1;
+    bool muted:1;
+    pa_hashmap *volume_factor_items, *volume_factor_sink_items;

 
 

-    pa_bool_t sample_spec_is_set:1;
-    pa_bool_t channel_map_is_set:1;
-    pa_bool_t volume_is_set:1;
-    pa_bool_t muted_is_set:1;
+    bool sample_spec_is_set:1;
+    bool channel_map_is_set:1;
+
+    bool volume_is_set:1;
+    bool muted_is_set:1;
+
+    bool volume_is_absolute:1;
+
+    bool volume_writable:1;
+
+    bool save_sink:1, save_volume:1, save_muted:1;

 } pa_sink_input_new_data;
 
 pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data);
 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec);
 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map);
 } pa_sink_input_new_data;
 
 pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data);
 void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec);
 void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map);

+bool pa_sink_input_new_data_is_passthrough(pa_sink_input_new_data *data);

 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume);
 void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume);

-void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute);
+void pa_sink_input_new_data_add_volume_factor(pa_sink_input_new_data *data, const char *key, const pa_cvolume *volume_factor);
+void pa_sink_input_new_data_add_volume_factor_sink(pa_sink_input_new_data *data, const char *key, const pa_cvolume *volume_factor);
+void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, bool mute);
+bool pa_sink_input_new_data_set_sink(pa_sink_input_new_data *data, pa_sink *s, bool save);
+bool pa_sink_input_new_data_set_formats(pa_sink_input_new_data *data, pa_idxset *formats);

 void pa_sink_input_new_data_done(pa_sink_input_new_data *data);
 
 void pa_sink_input_new_data_done(pa_sink_input_new_data *data);
 

-typedef struct pa_sink_input_move_hook_data {
-    pa_sink_input *sink_input;
-    pa_sink *destination;
-} pa_sink_input_move_hook_data;
-
-typedef struct pa_sink_set_input_volume_data {
-  pa_sink_input *sink_input;
-  pa_cvolume virtual_volume;
-  pa_cvolume volume;
-} pa_sink_input_set_volume_data;
-

 /* To be called by the implementing module only */
 
 /* To be called by the implementing module only */
 

-pa_sink_input* pa_sink_input_new(
+int pa_sink_input_new(
+        pa_sink_input **i,

         pa_core *core,
         pa_core *core,

-        pa_sink_input_new_data *data,
-        pa_sink_input_flags_t flags);
+        pa_sink_input_new_data *data);

 
 void pa_sink_input_put(pa_sink_input *i);
 void pa_sink_input_unlink(pa_sink_input* i);
 
 void pa_sink_input_put(pa_sink_input *i);
 void pa_sink_input_unlink(pa_sink_input* i);


@@ -278,11 +349,16 @@ fully -- or at all. If the request for a rewrite was successful, the
 sink driver will call ->rewind() and pass the number of bytes that
 could be rewound in the HW device. This functionality is required for
 implementing the "zero latency" write-through functionality. */
 sink driver will call ->rewind() and pass the number of bytes that
 could be rewound in the HW device. This functionality is required for
 implementing the "zero latency" write-through functionality. */

-void pa_sink_input_request_rewind(pa_sink_input *i, size_t nbytes, pa_bool_t rewrite, pa_bool_t flush, pa_bool_t dont_rewind_render);
+void pa_sink_input_request_rewind(pa_sink_input *i, size_t nbytes, bool rewrite, bool flush, bool dont_rewind_render);

 
 

-void pa_sink_input_cork(pa_sink_input *i, pa_bool_t b);
+void pa_sink_input_cork(pa_sink_input *i, bool b);

 
 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate);
 
 int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate);

+int pa_sink_input_update_rate(pa_sink_input *i);
+
+/* This returns the sink's fields converted into out sample type */
+size_t pa_sink_input_get_max_rewind(pa_sink_input *i);
+size_t pa_sink_input_get_max_request(pa_sink_input *i);

 
 /* Callable by everyone from main thread*/
 
 
 /* Callable by everyone from main thread*/
 


@@ -291,16 +367,32 @@ void pa_sink_input_kill(pa_sink_input*i);
 
 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency);
 
 
 pa_usec_t pa_sink_input_get_latency(pa_sink_input *i, pa_usec_t *sink_latency);
 

-void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume);
-const pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i);
-void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute);
-pa_bool_t pa_sink_input_get_mute(pa_sink_input *i);
-pa_bool_t pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p);
+bool pa_sink_input_is_passthrough(pa_sink_input *i);
+bool pa_sink_input_is_volume_readable(pa_sink_input *i);
+void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, bool save, bool absolute);
+void pa_sink_input_add_volume_factor(pa_sink_input *i, const char *key, const pa_cvolume *volume_factor);
+int pa_sink_input_remove_volume_factor(pa_sink_input *i, const char *key);
+pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i, pa_cvolume *volume, bool absolute);
+
+void pa_sink_input_set_mute(pa_sink_input *i, bool mute, bool save);
+bool pa_sink_input_get_mute(pa_sink_input *i);
+
+void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p);

 
 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i);
 
 
 pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i);
 

-int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest);
-pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest);
+void pa_sink_input_send_event(pa_sink_input *i, const char *name, pa_proplist *data);
+
+int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest, bool save);
+bool pa_sink_input_may_move(pa_sink_input *i); /* may this sink input move at all? */
+bool pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest); /* may this sink input move to this sink? */
+
+/* The same as pa_sink_input_move_to() but in two separate steps,
+ * first the detaching from the old sink, then the attaching to the
+ * new sink */
+int pa_sink_input_start_move(pa_sink_input *i);
+int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, bool save);
+void pa_sink_input_fail_move(pa_sink_input *i);

 
 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i);
 
 
 pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i);
 


@@ -308,7 +400,7 @@ pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i);
 
 /* To be used exclusively by the sink driver IO thread */
 
 
 /* To be used exclusively by the sink driver IO thread */
 

-int pa_sink_input_peek(pa_sink_input *i, size_t length, pa_memchunk *chunk, pa_cvolume *volume);
+void pa_sink_input_peek(pa_sink_input *i, size_t length, pa_memchunk *chunk, pa_cvolume *volume);

 void pa_sink_input_drop(pa_sink_input *i, size_t length);
 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */);
 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes  /* in the sink's sample spec */);
 void pa_sink_input_drop(pa_sink_input *i, size_t length);
 void pa_sink_input_process_rewind(pa_sink_input *i, size_t nbytes /* in the sink's sample spec */);
 void pa_sink_input_update_max_rewind(pa_sink_input *i, size_t nbytes  /* in the sink's sample spec */);


@@ -320,8 +412,19 @@ int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t
 
 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec);
 
 
 pa_usec_t pa_sink_input_set_requested_latency_within_thread(pa_sink_input *i, pa_usec_t usec);
 

-pa_bool_t pa_sink_input_safe_to_remove(pa_sink_input *i);
+bool pa_sink_input_safe_to_remove(pa_sink_input *i);
+bool pa_sink_input_process_underrun(pa_sink_input *i);

 
 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret);
 
 
 pa_memchunk* pa_sink_input_get_silence(pa_sink_input *i, pa_memchunk *ret);
 

+/* Called from the main thread, from sink.c only. The normal way to set the
+ * sink input volume is to call pa_sink_input_set_volume(), but the flat volume
+ * logic in sink.c needs also a function that doesn't do all the extra stuff
+ * that pa_sink_input_set_volume() does. This function simply sets i->volume
+ * and fires change notifications. */
+void pa_sink_input_set_volume_direct(pa_sink_input *i, const pa_cvolume *volume);
+
+#define pa_sink_input_assert_io_context(s) \
+    pa_assert(pa_thread_mq_get() || !PA_SINK_INPUT_IS_LINKED((s)->state))
+

 #endif
 #endif