src/audio/symbian/streamplayer.cpp

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