static int volume_set_request = 0; // set when an external request is made to set the volume.
int mute_request_pending = 0; // set when an external request is made to mute or unmute.
int overriding_mute_state_requested = 0; // 1 = mute; 0 = unmute requested
-int mixer_volume_setting_gives_mute = 0; // set when it is discovered that particular mixer volume setting causes a mute.
-long alsa_mix_mute; // setting the volume to this value mutes output, if mixer_volume_setting_gives_mute is true
-int volume_based_mute_is_active = 0; // set when muting is being done by a setting the volume to a magic value
+int mixer_volume_setting_gives_mute =
+ 0; // set when it is discovered that particular mixer volume setting causes a mute.
+long alsa_mix_mute; // setting the volume to this value mutes output, if
+ // mixer_volume_setting_gives_mute is true
+int volume_based_mute_is_active =
+ 0; // set when muting is being done by a setting the volume to a magic value
static snd_pcm_sframes_t (*alsa_pcm_write)(snd_pcm_t *, const void *,
snd_pcm_uframes_t) = snd_pcm_writei;
}
}
-void do_snd_mixer_selem_set_playback_dB_all(snd_mixer_elem_t * mix_elem, double vol) {
+void do_snd_mixer_selem_set_playback_dB_all(snd_mixer_elem_t *mix_elem, double vol) {
if (snd_mixer_selem_set_playback_dB_all(mix_elem, vol, 0) != 0) {
debug(1, "Can't set playback volume accurately to %f dB.", vol);
if (snd_mixer_selem_set_playback_dB_all(mix_elem, vol, -1) != 0)
// For instance, the Raspberry Pi does this
debug(1, "Lowest dB value is a mute");
mixer_volume_setting_gives_mute = 1;
- alsa_mix_mute = SND_CTL_TLV_DB_GAIN_MUTE; // this may not be necessary -- it's always going to be SND_CTL_TLV_DB_GAIN_MUTE, right?
+ alsa_mix_mute = SND_CTL_TLV_DB_GAIN_MUTE; // this may not be necessary -- it's always
+ // going to be SND_CTL_TLV_DB_GAIN_MUTE, right?
// debug(1, "Try minimum volume + 1 as lowest true attenuation value");
if (snd_mixer_selem_ask_playback_vol_dB(alsa_mix_elem, alsa_mix_minv + 1,
&alsa_mix_mindb) != 0)
}
}
if ((config.alsa_use_playback_switch_for_mute == 1) &&
- (snd_mixer_selem_has_playback_switch(alsa_mix_elem)) || mixer_volume_setting_gives_mute) {
+ (snd_mixer_selem_has_playback_switch(alsa_mix_elem)) ||
+ mixer_volume_setting_gives_mute) {
audio_alsa.mute = &mute; // insert the mute function now we know it can do muting stuff
// debug(1, "Has mixer and mute ability we will use.");
} else {
"control.");
}
} else {
- if (volume_based_mute_is_active==0) {
+ if (volume_based_mute_is_active == 0) {
// debug(1,"Set alsa volume.");
do_snd_mixer_selem_set_playback_dB_all(alsa_mix_elem, vol);
} else {
- debug(1,"Not setting volume because volume-based mute is active");
+ debug(1, "Not setting volume because volume-based mute is active");
}
}
volume_set_request = 0; // any external request that has been made is now satisfied
// If the hardware isn't there, or we are not allowed to use it, nothing will be done
// The caller must have the alsa mutex
- if ((config.alsa_use_playback_switch_for_mute == 1) || mixer_volume_setting_gives_mute){
+ if ((config.alsa_use_playback_switch_for_mute == 1) || mixer_volume_setting_gives_mute) {
if (mute_request_pending == 0)
local_mute_state_requested = mute_state_requested;
if (open_mixer()) {
mdns_backend *mdns;
int buffer_start_fill;
int64_t userSuppliedLatency; // overrides all other latencies -- use with caution
- int64_t fixedLatencyOffset; // add this to all automatic latencies supplied to get the actual total latency
- // the total latency will be limited to the min and max-latency values, if supplied
+ int64_t fixedLatencyOffset; // add this to all automatic latencies supplied to get the actual
+ // total latency
+ // the total latency will be limited to the min and max-latency values, if supplied
int daemonise;
int daemonise_store_pid; // don't try to save a PID file
char *piddir;
int32_t item_size;
if (reply_size >= 8) {
if (dacp_tlv_crawl(&sp, &item_size) == 'cmgt') {
- debug(1,"Volume:",item_size);
+ debug(1, "Volume:", item_size);
sp -= item_size; // drop down into the array -- don't skip over it
reply_size -= 8;
while (reply_size >= 8) {
}
}
} else {
- debug(1,"Unexpected payload response from getproperty?properties=dmcp.volume");
+ debug(1, "Unexpected payload response from getproperty?properties=dmcp.volume");
}
} else {
- debug(1,"Too short a response from getproperty?properties=dmcp.volume");
+ debug(1, "Too short a response from getproperty?properties=dmcp.volume");
}
- debug(1,"Overall Volume is %d.",overall_volume);
+ debug(1, "Overall Volume is %d.", overall_volume);
free(server_reply);
} else {
debug(1, "Unexpected response %d to dacp volume control request", response);
// should return 204
}
-int dacp_get_speaker_list(dacp_spkr_stuff *speaker_info,
- int max_size_of_array) {
+int dacp_get_speaker_list(dacp_spkr_stuff *speaker_info, int max_size_of_array) {
char *server_reply = NULL;
int speaker_index = -1; // will be incremented before use
int reply = -1; // will bve fixed if there is no problem
// calculate the real volume
int32_t overall_volume = dacp_get_client_volume();
- debug(1,"DACP Volume: %d.",overall_volume);
+ debug(1, "DACP Volume: %d.", overall_volume);
int speaker_count = dacp_get_speaker_list((dacp_spkr_stuff *)&speaker_info, 50);
// debug(1,"DACP Speaker Count: %d.",speaker_count);
run_metadata_watchers();
}
}
-
int dacp_set_speaker_volume(int64_t machine_number, int32_t vo);
-int dacp_get_speaker_list(dacp_spkr_stuff *speaker_array,
- int max_size_of_array);
+int dacp_get_speaker_list(dacp_spkr_stuff *speaker_array, int max_size_of_array);
void set_dacp_server_information(rtsp_conn_info *conn); // tell the DACP conversation thread that
// the dacp server information has been set
// or changed
int send_simple_dacp_command(const char *command);
-void dacp_get_volume(void); // get the speaker volume information from the DACP source and store it in the metadata_hub
+void dacp_get_volume(void); // get the speaker volume information from the DACP source and store it
+ // in the metadata_hub
unsigned char
item_composite_id[16]; // seems to be nowplaying 4 ids: dbid, plid, playlistItem, itemid
-
+
//
-
- enum play_status_type player_state; // this is the state of the actual player itself, which can be a bit noisy.
-
- int speaker_volume; // this is the actual speaker volume, allowing for the main volume and the speaker volume control
+
+ enum play_status_type
+ player_state; // this is the state of the actual player itself, which can be a bit noisy.
+
+ int speaker_volume; // this is the actual speaker volume, allowing for the main volume and the
+ // speaker volume control
int previous_speaker_volume; // this is needed to prevent a loop
-
+
metadata_watcher watchers[number_of_watchers]; // functions to call if the metadata is changed.
void *watchers_data[number_of_watchers]; // their individual data
// say we have started playing here
#ifdef HAVE_METADATA_HUB
- if (metadata_store.player_state != PS_PLAYING) {
- metadata_store.player_state = PS_PLAYING;
- run_metadata_watchers();
- }
+ if (metadata_store.player_state != PS_PLAYING) {
+ metadata_store.player_state = PS_PLAYING;
+ run_metadata_watchers();
+ }
#endif
if (reference_timestamp) { // if we have a reference time
// debug(1,"First frame seen with timestamp...");
conn->first_packet_timestamp = 0;
conn->flush_requested = 0;
// conn->fix_volume = 0x10000;
-
- if (conn->latency==0) {
- debug(1,"No latency has (yet) been specified. Setting 99225 (2.25 seconds) frames as a default.");
+
+ if (conn->latency == 0) {
+ debug(1,
+ "No latency has (yet) been specified. Setting 99225 (2.25 seconds) frames as a default.");
conn->latency = 99225;
}
if (metadata_store.player_state != PS_PAUSED) {
metadata_store.player_state = PS_PAUSED;
run_metadata_watchers();
- }
+ }
#endif
-
}
int player_play(rtsp_conn_info *conn) {
if (metadata_store.player_state != PS_PLAYING) {
metadata_store.player_state = PS_PLAYING;
run_metadata_watchers();
- }
+ }
#endif
return 0;
}
free(conn->player_thread);
conn->player_thread = NULL;
#ifdef HAVE_METADATA_HUB
- if (metadata_store.player_state != PS_STOPPED) {
- metadata_store.player_state = PS_STOPPED;
- run_metadata_watchers();
- }
+ if (metadata_store.player_state != PS_STOPPED) {
+ metadata_store.player_state = PS_STOPPED;
+ run_metadata_watchers();
+ }
#endif
} else {
debug(3, "player thread of RTSP conversation %d is already deleted.", conn->connection_number);
} stream_cfg;
typedef struct {
- int connection_number; // for debug ID purposes, nothing else...
- int64_t latency; // the actual latency used for this play session
- int64_t minimum_latency; // set if an a=min-latency: line appears in the ANNOUNCE message; zero otherwise
- int64_t maximum_latency; // set if an a=max-latency: line appears in the ANNOUNCE message; zero otherwise
-
+ int connection_number; // for debug ID purposes, nothing else...
+ int64_t latency; // the actual latency used for this play session
+ int64_t minimum_latency; // set if an a=min-latency: line appears in the ANNOUNCE message; zero
+ // otherwise
+ int64_t maximum_latency; // set if an a=max-latency: line appears in the ANNOUNCE message; zero
+ // otherwise
+
int fd;
int authorized; // set if a password is required and has been supplied
stream_cfg stream;
// debug(1,"Remote Sync Time: %0llx.",remote_time_of_sync);
sync_rtp_timestamp = monotonic_timestamp(ntohl(*((uint32_t *)&packet[16])), conn);
-
+
if (config.userSuppliedLatency) {
if (config.userSuppliedLatency != conn->latency) {
- debug(1,"Using the user-supplied latency: %lld.",config.userSuppliedLatency);
+ debug(1, "Using the user-supplied latency: %lld.", config.userSuppliedLatency);
}
conn->latency = config.userSuppliedLatency;
- } else if (packet[0] & 0x10) { // only set latency if it's a packet just after a flush or resume
- int64_t rtp_timestamp_less_latency = monotonic_timestamp(ntohl(*((uint32_t *)&packet[4])), conn);
- int64_t la =
- sync_rtp_timestamp - rtp_timestamp_less_latency + config.fixedLatencyOffset;
- if ((conn->maximum_latency) && (conn->maximum_latency<la))
+ } else if (packet[0] &
+ 0x10) { // only set latency if it's a packet just after a flush or resume
+ int64_t rtp_timestamp_less_latency =
+ monotonic_timestamp(ntohl(*((uint32_t *)&packet[4])), conn);
+ int64_t la = sync_rtp_timestamp - rtp_timestamp_less_latency + config.fixedLatencyOffset;
+ if ((conn->maximum_latency) && (conn->maximum_latency < la))
la = conn->maximum_latency;
- if ((conn->minimum_latency) && (conn->minimum_latency>la))
- la = conn->minimum_latency;
-
+ if ((conn->minimum_latency) && (conn->minimum_latency > la))
+ la = conn->minimum_latency;
+
if (la != conn->latency) {
conn->latency = la;
- debug(1,"New latency: %lld, sync latency: %lld, minimum latency: %lld, maximum latency: %lld, fixed offset: %lld.",
- la,sync_rtp_timestamp - rtp_timestamp_less_latency,conn->minimum_latency,conn->maximum_latency,config.fixedLatencyOffset);
+ debug(1, "New latency: %lld, sync latency: %lld, minimum latency: %lld, maximum "
+ "latency: %lld, fixed offset: %lld.",
+ la, sync_rtp_timestamp - rtp_timestamp_less_latency, conn->minimum_latency,
+ conn->maximum_latency, config.fixedLatencyOffset);
}
}
send_metadata('ssnc', 'daid', ar, strlen(ar), req, 1);
#endif
}
-
+
char *hdr = msg_get_header(req, "Transport");
if (!hdr)
goto error;
pc_queue_get_item(&metadata_queue, &pack);
if (config.metadata_enabled)
metadata_process(pack.type, pack.code, pack.data, pack.length);
-
+
if (pack.carrier)
msg_free(pack.carrier); // release the message
else if (pack.data)
if (!strncmp(cp, "a=max-latency:", 14))
pmaxlatency = cp + 14;
-
+
cp = next;
}
-
+
if (pminlatency) {
conn->minimum_latency = atoi(pminlatency);
- debug(1,"Minimum latency %d specified",conn->minimum_latency);
+ debug(1, "Minimum latency %d specified", conn->minimum_latency);
}
if (pmaxlatency) {
conn->maximum_latency = atoi(pmaxlatency);
- debug(1,"Maximum latency %d specified",conn->maximum_latency);
+ debug(1, "Maximum latency %d specified", conn->maximum_latency);
}
if ((paesiv == NULL) && (prsaaeskey == NULL)) {
#include "dacp.h"
#endif
-
#if defined(HAVE_METADATA_HUB)
#include "metadata_hub.h"
#endif
inform("Warning: the option -R or --reconnectToOutput is deprecated.");
break;
case 'A':
- inform("Warning: the option -A or --AirPlayLatency is deprecated and ignored. This setting is now "
+ inform("Warning: the option -A or --AirPlayLatency is deprecated and ignored. This setting "
+ "is now "
"automatically received from the AirPlay device.");
break;
case 'i':
- inform("Warning: the option -i or --iTunesLatency is deprecated and ignored. This setting is now "
+ inform("Warning: the option -i or --iTunesLatency is deprecated and ignored. This setting is "
+ "now "
"automatically received from iTunes");
break;
case 'f':
- inform("Warning: the option --forkedDaapdLatency is deprecated and ignored. This setting is now "
- "automatically received from forkedDaapd");
+ inform(
+ "Warning: the option --forkedDaapdLatency is deprecated and ignored. This setting is now "
+ "automatically received from forkedDaapd");
break;
case 'r':
inform("Warning: the option -r or --resync is deprecated. Please use the "
strcat(configuration_file_path, ".conf");
config.configfile = configuration_file_path;
- //config.statistics_requested = 0; // don't print stats in the log
- //config.userSuppliedLatency = 0; // zero means none supplied
- config.resyncthreshold = 0.05; // 50 ms
+ // config.statistics_requested = 0; // don't print stats in the log
+ // config.userSuppliedLatency = 0; // zero means none supplied
+ config.resyncthreshold = 0.05; // 50 ms
config.timeout = 120; // this number of seconds to wait for [more] audio before switching to idle.
config.tolerance =
0.002; // this number of seconds of timing error before attempting to correct it.
}
/* Mess around with the latency options */
- // Basically, we expect the source to set the latency and add a fixed offset of 11025 frames to it, which sounds right
- // If this latency is outside the max and min latensies that may be set by the source, clamp it to fit.
-
+ // Basically, we expect the source to set the latency and add a fixed offset of 11025 frames to
+ // it, which sounds right
+ // If this latency is outside the max and min latensies that may be set by the source, clamp it to
+ // fit.
+
// If they specify a non-standard latency, we suggest the user to use the
// audio_backend_latency_offset instead.
projects / thirdparty / shairport-sync.git / commitdiff
