src/audio/symbian/streamplayer.cpp

   1 #include "streamplayer.h"
   2 #include <mda/common/audio.h>
   3
   4 const int KMaxVolume = 256;
   5
   6 static int GetSampleRate(int aRate)
   7 {
   8         switch(aRate)
   9         {
  10                 case 8000: return TMdaAudioDataSettings::ESampleRate8000Hz;
  11                 case 11025: return TMdaAudioDataSettings::ESampleRate11025Hz;
  12                 case 12000: return TMdaAudioDataSettings::ESampleRate12000Hz;
  13                 case 16000: return TMdaAudioDataSettings::ESampleRate16000Hz;
  14                 case 22050: return TMdaAudioDataSettings::ESampleRate22050Hz;
  15                 case 24000: return TMdaAudioDataSettings::ESampleRate24000Hz;
  16                 case 32000: return TMdaAudioDataSettings::ESampleRate32000Hz;
  17                 case 44100: return TMdaAudioDataSettings::ESampleRate44100Hz;
  18                 case 48000: return TMdaAudioDataSettings::ESampleRate48000Hz;
  19                 case 64000: return TMdaAudioDataSettings::ESampleRate64000Hz;
  20                 case 96000: return TMdaAudioDataSettings::ESampleRate96000Hz;
  21                 default: break;
  22         }
  23         return KErrNotFound;
  24 }
  25
  26 static int GetChannels(int aChannels)
  27 {
  28         switch(aChannels)
  29         {
  30                 case 1: return TMdaAudioDataSettings::EChannelsMono;
  31                 case 2: return TMdaAudioDataSettings::EChannelsStereo;
  32                 default: break;
  33         }
  34         return KErrNotFound;
  35 }
  36
  37 int CStreamPlayer::ClosestSupportedRate(int aRate)
  38 {
  39         if(aRate > 96000)
  40                 return 96000;
  41
  42         int rate = aRate;
  43         while(GetSampleRate(rate) == KErrNotFound)
  44         {
  45                 ++rate;
  46         }
  47         return rate;
  48 }
  49
  50 CStreamPlayer::CStreamPlayer(MStreamProvider& aProvider, MStreamObs& aObs)
  51         : iProvider(aProvider), iObs(aObs), iVolume(KMaxVolume)
  52 {
  53 }
  54
  55 CStreamPlayer::~CStreamPlayer()
  56 {
  57         iState |= EDied;
  58         if(iState & EInited)
  59                 Close();
  60         User::After(100000); //wait buffer to be flushed
  61         ASSERT(iPtr.Length() == 0);
  62         delete iStream;
  63 }
  64
  65 void CStreamPlayer::ConstructL()
  66 {
  67         iStream = CMdaAudioOutputStream::NewL(*this, EMdaPriorityMax);
  68         iSilence.SetMax();
  69         iSilence.FillZ();
  70 }
  71
  72 int CStreamPlayer::OpenStream(int aRate, int aChannels, TUint32 aType)
  73 {
  74         Close();
  75
  76         iType = aType;
  77
  78         iRate = GetSampleRate(aRate);
  79         if(iRate == KErrNotFound)
  80                 return KErrNotSupported;
  81
  82         iChannels = GetChannels(aChannels);
  83         if(iChannels == KErrNotFound)
  84                 return KErrNotSupported;
  85
  86         Open();
  87
  88         return KErrNone;
  89 }
  90
  91 int CStreamPlayer::MaxVolume() const
  92 {
  93         return KMaxVolume;
  94 }
  95
  96 void CStreamPlayer::SetVolume(int aNew)
  97 {
  98         const int maxi = MaxVolume();
  99
 100         if(aNew > maxi)
 101                 return;
 102         if(aNew < 0)
 103                 return;
 104
 105         iVolume = aNew;
 106
 107         iState |= EVolumeChange;
 108 }
 109
 110 int CStreamPlayer::Volume() const
 111 {
 112         return iVolume;
 113 }
 114
 115 void CStreamPlayer::Open()
 116 {
 117         TMdaAudioDataSettings audioSettings;
 118         audioSettings.Query();
 119         audioSettings.iCaps = TMdaAudioDataSettings::ERealTime | TMdaAudioDataSettings::ESampleRateFixed;
 120         audioSettings.iSampleRate = iRate;
 121         audioSettings.iChannels = iChannels;
 122         audioSettings.iFlags = TMdaAudioDataSettings::ENoNetworkRouting;
 123         audioSettings.iVolume = 0;
 124
 125         iState &= ~EStopped;
 126         iStream->Open(&audioSettings);
 127 }
 128
 129 void CStreamPlayer::Stop()
 130 {
 131         if(iState & (EStarted | EInited))
 132         {
 133                 Close();
 134                 iState |= EStopped;
 135         }
 136 }
 137
 138 void CStreamPlayer::Start()
 139 {
 140         if(iPtr.Length() == 0)
 141         {
 142                 iState |= EStarted;
 143                 if(iState & EInited)
 144                 {
 145                         Request();
 146                 }
 147                 else if(iState & EStopped)
 148                 {
 149                         Open();
 150                 }
 151         }
 152 }
 153
 154 void CStreamPlayer::Close()
 155 {
 156         iState &= ~EInited;
 157         iStream->Stop();
 158         iState &= ~EStarted;
 159 }
 160
 161 void CStreamPlayer::Request()
 162 {
 163         if(iState & EInited)
 164         {
 165                 iPtr.Set(KNullDesC8);
 166
 167                 if(iState & EVolumeChange)
 168                 {
 169                         const TReal newVol = iVolume;
 170                         const TReal newMax = MaxVolume();
 171                         const int maxVol = iStream->MaxVolume();
 172                         const TReal max = static_cast<TReal>(maxVol);
 173                         const TReal newvolume = (newVol * max) / newMax;
 174                         const int vol = static_cast<TReal>(newvolume);
 175                         iStream->SetVolume(vol);
 176                         iState &= ~EVolumeChange;
 177                 }
 178
 179                 if(iState & EStarted)
 180                 {
 181                         iPtr.Set(iProvider.Data());
 182                 }
 183                 if(iPtr.Length() == 0)
 184                 {
 185                         iPtr.Set(iSilence);
 186                 }
 187                 TRAPD(err, iStream->WriteL(iPtr));
 188                 if(err != KErrNone)
 189                 {
 190                         iObs.Complete(MStreamObs::EWrite, err);
 191                 }
 192         }
 193 }
 194
 195
 196 void CStreamPlayer::SetCapsL()
 197 {
 198         iStream->SetDataTypeL(iType);
 199         iStream->SetAudioPropertiesL(iRate, iChannels);
 200 }
 201
 202 void CStreamPlayer::MaoscOpenComplete(int aError)
 203 {
 204         if(aError == KErrNone)
 205         {
 206                 TRAPD(err, SetCapsL());
 207                 if(err == KErrNone)
 208                 {
 209                         iStream->SetPriority(EPriorityNormal, EMdaPriorityPreferenceTime);
 210                         iState |= EInited;
 211
 212                         SetVolume(Volume());
 213
 214                         if(iState & EStarted)
 215                         {
 216                                 Request();
 217                         }
 218                 }
 219                 aError = err;
 220         }
 221         if(!(iState & EDied))
 222                 iObs.Complete(MStreamObs::EInit, aError);
 223 }
 224
 225 void CStreamPlayer::MaoscBufferCopied(int aError, const TDesC8& /*aBuffer*/)
 226 {
 227         iPtr.Set(KNullDesC8);
 228         if(aError == KErrNone)
 229         {
 230                 if(iState & EInited)
 231                         Request();
 232                 else
 233                         iStream->Stop();
 234         }
 235         else if(!(iState & EDied))
 236                 iObs.Complete(MStreamObs::EPlay, aError);
 237 }
 238
 239 void CStreamPlayer::MaoscPlayComplete(int aError)
 240 {
 241         iPtr.Set(KNullDesC8);
 242         iState &= ~EStarted;
 243         if(!(iState & EDied))
 244                 iObs.Complete(MStreamObs::EClose, aError);
 245 }
 246
 247 TBool CStreamPlayer::Playing() const
 248 {
 249         return (iState & EInited) && (iState & EStarted);
 250 }
 251
 252 TBool CStreamPlayer::Closed() const
 253 {
 254         return !(iState & EInited) && !(iState & EDied);
 255 }