Player
User
Developer
00001 /* 00002 * Player - One Hell of a Robot Server 00003 * Copyright (C) 2003 00004 * Brian Gerkey 00005 * 00006 * 00007 * This program is free software; you can redistribute it and/or modify 00008 * it under the terms of the GNU General Public License as published by 00009 * the Free Software Foundation; either version 2 of the License, or 00010 * (at your option) any later version. 00011 * 00012 * This program is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00015 * GNU General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU General Public License 00018 * along with this program; if not, write to the Free Software 00019 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00020 * 00021 */ 00022 00023 #include <alsa/asoundlib.h> 00024 00025 #include "audio_sample.h" 00026 00028 // Describes a prestored sample for playing with PLAYER_AUDIO_CMD_SAMPLE_PLAY 00029 typedef struct StoredSample 00030 { 00031 AudioSample *sample; 00032 int index; // Index of sample 00033 struct StoredSample *next; // Next sample in the linked list 00034 } StoredSample; 00035 00037 // An item on the queue of waves to play 00038 typedef struct QueueItem 00039 { 00040 AudioSample *sample; // Audio sample at this position in the queue 00041 bool temp; // If true, the AudioSample will be deleted after playback completes 00042 struct QueueItem *next; // Next item in the queue 00043 } QueueItem; 00044 00046 // Capabilities of a mixer element 00047 typedef uint32_t ElemCap; 00048 const ElemCap ELEMCAP_CAN_PLAYBACK = 0x0001; 00049 const ElemCap ELEMCAP_CAN_CAPTURE = 0x0002; 00050 const ElemCap ELEMCAP_COMMON = 0x0004; // Has a single volume control for both playback and record 00051 const ElemCap ELEMCAP_PLAYBACK_VOL = 0x0008; 00052 const ElemCap ELEMCAP_CAPTURE_VOL = 0x0010; 00053 const ElemCap ELEMCAP_COMMON_VOL = 0x0020; 00054 const ElemCap ELEMCAP_PLAYBACK_SWITCH = 0x0040; 00055 const ElemCap ELEMCAP_CAPTURE_SWITCH = 0x0080; 00056 const ElemCap ELEMCAP_COMMON_SWITCH = 0x0100; 00057 // const ElemCap ELEMCAP_PB_JOINED_SWITCH = 0x0200; 00058 // const ElemCap ELEMCAP_CAP_JOINED_SWITCH = 0x0400; 00059 00060 // Describes an ALSA mixer element 00061 typedef struct MixerElement 00062 { 00063 snd_mixer_elem_t *elem; // ALSA Mixer element structure 00064 long minPlayVol, curPlayVol, maxPlayVol; // min, current and max volume levels for playback 00065 long minCapVol, curCapVol, maxCapVol; // min, current and max volume levels for capture 00066 long minComVol, curComVol, maxComVol; // min, current and max volume levels for common 00067 int playSwitch, capSwitch, comSwitch; // Current switch status 00068 char *name; // Name of the element 00069 ElemCap caps; // Capabilities 00070 } MixerElement; 00071 00073 // State of the playback system 00074 typedef uint8_t PBState; 00075 const PBState PB_STATE_STOPPED = 0; // Not playing anything 00076 const PBState PB_STATE_PLAYING = 1; // Playing 00077 const PBState PB_STATE_DRAIN = 2; // Draining current wave 00078 const PBState PB_STATE_RECORDING = 3; // Recording 00079 00081 // The class for the driver 00082 class Alsa : public ThreadedDriver 00083 { 00084 public: 00085 Alsa (ConfigFile* cf, int section); 00086 ~Alsa (void); 00087 00088 virtual int ProcessMessage (QueuePointer &resp_queue, player_msghdr *hdr, void *data); 00089 00090 private: 00091 // Driver options 00092 bool useQueue; // If should use a queue for playback or just stop currently playing 00093 uint8_t debugLevel; // Debug info level 00094 char **mixerFilters; // Null-terminated array of strings to filter mixer elements by 00095 bool mixerFilterExact; // If mixer filters need to match element names exactly 00096 char *pbDevice; // Name of the playback device 00097 char *mixerDevice; // Name of the mixer device 00098 char *recDevice; // Name of the record device 00099 uint32_t cfgPBPeriodTime; // Length of a playback period in milliseconds 00100 uint32_t cfgPBBufferTime; // Length of the playback buffer in milliseconds 00101 uint32_t silenceTime; // Length of silence to put between samples in the queue 00102 uint32_t cfgRecBufferTime; // Length of the record buffer in milliseconds 00103 uint32_t cfgRecStoreTime; // Length of time to store recorded data before sending to clients 00104 uint32_t cfgRecPeriodTime; // Length of a record period in milliseconds 00105 uint8_t recNumChannels; // Number of channels for recording 00106 uint32_t recSampleRate; // Sample rate for recording 00107 uint8_t recBits; // Sample bits per frame for recording 00108 00109 // ALSA variables 00110 // Playback 00111 snd_pcm_t *pbHandle; // Handle to the PCM device for playback 00112 int numPBFDs; // Number of playback file descriptors 00113 struct pollfd *pbFDs; // Playback file descriptors for polling 00114 uint32_t actPBBufferTime; // Length of the playback buffer in microseconds (actual value) 00115 uint32_t actPBPeriodTime; // Length of a playback period in microseconds (actual value) 00116 snd_pcm_uframes_t pbPeriodSize; // Size of a playback period (used for filling the buffer) 00117 uint8_t *periodBuffer; // A buffer used to copy data from samples to the playback buffer 00118 // Record 00119 snd_pcm_t *recHandle; // Handle to the PCM device for recording 00120 int numRecFDs; // Number of record file descriptors 00121 struct pollfd *recFDs; // Record file descriptors for polling 00122 uint32_t actRecBufferTime; // Length of the record buffer in microseconds (actual value) 00123 uint32_t actRecPeriodTime; // Length of a record period in microseconds (actual value) 00124 snd_pcm_uframes_t recPeriodSize; // Size of a record period (used for filling the buffer) 00125 // Mixer 00126 snd_mixer_t *mixerHandle; // Mixer for controlling volume levels 00127 MixerElement *mixerElements; // Elements of the mixer 00128 uint32_t numElements; // Number of elements 00129 00130 // Other driver data 00131 int nextSampleIdx; // Next free index to store a sample at 00132 StoredSample *samplesHead, *samplesTail; // Stored samples 00133 QueueItem *queueHead, *queueTail; // Queue of audio data waiting to play 00134 PBState playState; // Playback state 00135 PBState recState; // Record state 00136 uint32_t recDataLength; // Length of recorded data buffer (in bytes) 00137 uint32_t recDataOffset; // Current end of recorded data in recData 00138 uint8_t *recData; // Somewhere to store recorded data before it goes to the client 00139 int recDest; // Destination of recorded data: -ve for to clients via data packets, 00140 // >=0 for to stored sample at that index 00141 00142 // Internal functions 00143 virtual void Main (void); 00144 virtual int MainSetup (void); 00145 virtual void MainQuit (void); 00146 void SendStateMessage (void); 00147 00148 // Stored sample functions 00149 bool AddStoredSample (StoredSample *newSample); 00150 bool AddStoredSample (player_audio_wav_t *waveData); 00151 bool AddStoredSample (const char *filePath); 00152 StoredSample* GetSampleAtIndex (int index); 00153 00154 // Queue functions 00155 void ClearQueue (void); 00156 bool AddToQueue (QueueItem *newItem); 00157 bool AddToQueue (player_audio_wav_t *waveData); 00158 bool AddToQueue (AudioSample *sample); 00159 bool AddSilence (uint32_t time, AudioSample *format); 00160 void AdvanceQueue (void); 00161 00162 // Playback functions 00163 // bool SetGeneralParams (void); 00164 // bool SetWaveHWParams (AudioSample *sample); 00165 bool SetupPlayBack (void); 00166 bool SetPBParams (AudioSample *sample); 00167 void PlaybackCallback (int numFrames); 00168 00169 // Record functions 00170 bool SetupRecord (void); 00171 bool SetRecParams (void); 00172 bool SetupRecordBuffer (uint32_t length); 00173 void RecordCallback (int numFrames); 00174 void HandleRecordedData (void); 00175 void PublishRecordedData (void); 00176 00177 // Playback/record control functions 00178 void StartPlayback (void); 00179 void StopPlayback (void); 00180 void StartRecording (void); 00181 void StopRecording (void); 00182 00183 // Mixer functions 00184 bool SetupMixer (void); 00185 bool EnumMixerElements (void); 00186 bool EnumElementCaps (MixerElement *element); 00187 MixerElement* SplitElements (MixerElement *elements, uint32_t &count); 00188 MixerElement* FilterElements (MixerElement *elements, uint32_t &count); 00189 void CleanUpMixerElements (MixerElement *elements, uint32_t count); 00190 void MixerDetailsToPlayer (player_audio_mixer_channel_list_detail_t *dest); 00191 void MixerLevelsToPlayer (player_audio_mixer_channel_list_t *dest); 00192 void SetElementLevel (uint32_t index, float level); 00193 void SetElementSwitch (uint32_t index, player_bool_t active); 00194 void PublishMixerData (void); 00195 float LevelToPlayer (long min, long max, long level); 00196 long LevelFromPlayer (long min, long max, float level); 00197 void PrintMixerElements (MixerElement *elements, uint32_t count); 00198 00199 // Command and request handling 00200 int HandleWavePlayCmd (player_audio_wav_t *waveData); 00201 int HandleSamplePlayCmd (player_audio_sample_item_t *data); 00202 int HandleRecordCmd (player_bool_t *data); 00203 int HandleMixerChannelCmd (player_audio_mixer_channel_list_t *data); 00204 int HandleSampleLoadReq (player_audio_sample_t *data, QueuePointer &resp_queue); 00205 int HandleSampleRetrieveReq (player_audio_sample_t *data, QueuePointer &resp_queue); 00206 int HandleSampleRecordReq (player_audio_sample_rec_req_t *data, QueuePointer &resp_queue); 00207 int HandleMixerChannelListReq (player_audio_mixer_channel_list_detail_t *data, QueuePointer &resp_queue); 00208 int HandleMixerChannelLevelReq (player_audio_mixer_channel_list_t *data, QueuePointer &resp_queue); 00209 };