platform/uiq3/engine/audio_mediaserver.cpp

   1 /*******************************************************************\r
   2  *\r
   3  *      File:           Audio_mediaserver.cpp\r
   4  *\r
   5  *      Author:         Peter van Sebille (peter@yipton.net)\r
   6  *\r
   7  *  Modified/adapted for picodriveN by notaz, 2006\r
   8  *\r
   9  *  (c) Copyright 2006, notaz\r
  10  *      (c) Copyright 2001, Peter van Sebille\r
  11  *      All Rights Reserved\r
  12  *\r
  13  *******************************************************************/\r
  14 \r
  15 #include "audio_mediaserver.h"\r
  16 #include "debug.h"\r
  17 \r
  18 //#define DEBUG_UNDERFLOWS\r
  19 //#undef DEBUGPRINT\r
  20 //#define DEBUGPRINT(x...)\r
  21 \r
  22 \r
  23 const TInt KUpdatesPerSec = 10;\r
  24 const TInt KBlockTime = 1000000 / KUpdatesPerSec;\r
  25 const TInt KMaxLag = 200000; // max sound lag, lower values increase chance of underflow\r
  26 const TInt KMaxUnderflows = 50; // max underflows/API errors we are going allow in a row (to prevent lockups)\r
  27 \r
  28 \r
  29 /*******************************************\r
  30  *\r
  31  * CGameAudioMS\r
  32  *\r
  33  *******************************************/\r
  34 \r
  35 CGameAudioMS::CGameAudioMS(TInt aRate, TBool aStereo, TInt aWritesPerSec, TInt aVolume)\r
  36 : iRate(aRate), iStereo(aStereo), iWritesPerSec(aWritesPerSec), iVolume(aVolume)\r
  37 {\r
  38 }\r
  39 \r
  40 \r
  41 CGameAudioMS* CGameAudioMS::NewL(TInt aRate, TBool aStereo, TInt aWritesPerSec, TInt aVolume)\r
  42 {\r
  43         DEBUGPRINT(_L("CGameAudioMS::NewL(%i, %i, %i, %i)"), aRate, aStereo, aWritesPerSec, aVolume);\r
  44         CGameAudioMS*           self = new(ELeave) CGameAudioMS(aRate, aStereo, aWritesPerSec, aVolume);\r
  45         CleanupStack::PushL(self);\r
  46         self->ConstructL();\r
  47         CleanupStack::Pop();            // self\r
  48         return self;\r
  49 }\r
  50 \r
  51 \r
  52 CGameAudioMS::~CGameAudioMS()\r
  53 {\r
  54         DEBUGPRINT(_L("CGameAudioMS::~CGameAudioMS()"));\r
  55         if(iMdaAudioOutputStream) {\r
  56                 iScheduler->Schedule(); // let it finish it's stuff\r
  57                 iMdaAudioOutputStream->Stop();\r
  58                 delete iMdaAudioOutputStream;\r
  59         }\r
  60         if(iServer) delete iServer;\r
  61 \r
  62         for (TInt i=0; i<KSoundBuffers; i++)\r
  63                 delete iSoundBuffers[i];\r
  64 \r
  65         // Polled AS\r
  66         //if(iScheduler) delete iScheduler;\r
  67 }\r
  68 \r
  69 \r
  70 void CGameAudioMS::ConstructL()\r
  71 {\r
  72         iServer = CMdaServer::NewL();\r
  73 \r
  74         // iScheduler = CPolledActiveScheduler::NewL();\r
  75         iScheduler = CPolledActiveScheduler::Instance();\r
  76 \r
  77         switch(iRate) {\r
  78                 case 11025: iMdaAudioDataSettings.iSampleRate = TMdaAudioDataSettings::ESampleRate11025Hz; break;\r
  79                 case 16000: iMdaAudioDataSettings.iSampleRate = TMdaAudioDataSettings::ESampleRate16000Hz; break;\r
  80                 case 22050: iMdaAudioDataSettings.iSampleRate = TMdaAudioDataSettings::ESampleRate22050Hz; break;\r
  81                 case 44100: iMdaAudioDataSettings.iSampleRate = TMdaAudioDataSettings::ESampleRate44100Hz; break;\r
  82                 default:    iMdaAudioDataSettings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz;  break;\r
  83         }\r
  84 \r
  85         iMdaAudioDataSettings.iChannels   = (iStereo) ? TMdaAudioDataSettings::EChannelsStereo : TMdaAudioDataSettings::EChannelsMono;\r
  86         iMdaAudioDataSettings.iCaps       = TMdaAudioDataSettings::ESampleRateFixed | iMdaAudioDataSettings.iSampleRate;\r
  87         iMdaAudioDataSettings.iFlags      = TMdaAudioDataSettings::ENoNetworkRouting;\r
  88 \r
  89         iMaxWriteSamples = iRate / iWritesPerSec;\r
  90         if (iRate % iWritesPerSec)\r
  91                 iMaxWriteSamples++;\r
  92         int bufferedFrames = iWritesPerSec / KUpdatesPerSec;\r
  93 \r
  94         iBufferSize = iMaxWriteSamples * (iStereo ? 4 : 2);\r
  95         iBufferSize *= bufferedFrames;\r
  96         for (TInt i=0 ; i<KSoundBuffers ; i++)\r
  97         {\r
  98                 // it seems .SetLength(max) throws USER:23 panic,\r
  99                 // so make them a bit larger\r
 100                 iSoundBuffers[i] = HBufC8::NewL(iBufferSize+4);\r
 101                 iSoundBuffers[i]->Des().FillZ  (iBufferSize+4);\r
 102         }\r
 103 \r
 104         iCurrentBuffer = 0;\r
 105         iCurrentBufferSize = 0;\r
 106 \r
 107         DEBUGPRINT(_L("sound: iMaxWriteSamples: %i, iBufferSize: %i"), iMaxWriteSamples, iBufferSize);\r
 108 \r
 109         // here we actually test if we can create and open CMdaAudioOutputStream at all, but really create and use it later.\r
 110         iMdaAudioOutputStream = CMdaAudioOutputStream::NewL(iListener, iServer);\r
 111         if (iMdaAudioOutputStream) {\r
 112                 if (iVolume < 0 || iVolume > iMdaAudioOutputStream->MaxVolume())\r
 113                         iVolume = iMdaAudioOutputStream->MaxVolume();\r
 114                 delete iMdaAudioOutputStream;\r
 115                 iMdaAudioOutputStream = 0;\r
 116         }\r
 117 }\r
 118 \r
 119 // returns a pointer to buffer for next frame,\r
 120 // to be used when iSoundBuffers are used directly\r
 121 TInt16 *CGameAudioMS::NextFrameL(TInt aPcmFrames)\r
 122 {\r
 123         TInt mul = iStereo ? 4 : 2;\r
 124         TInt bytes = aPcmFrames * mul;\r
 125         iCurrentPosition   += bytes / 2;\r
 126         iCurrentBufferSize += bytes;\r
 127 \r
 128         if (aPcmFrames > iMaxWriteSamples) {\r
 129                 DEBUGPRINT(_L("too many samples: %i > %i"), aPcmFrames, iMaxWriteSamples);\r
 130         }\r
 131 \r
 132         if (iCurrentBufferSize + iMaxWriteSamples * mul > iBufferSize)\r
 133         {\r
 134                 //DEBUGPRINT(_L("write on iCurrentBufferSize %i"), iCurrentBufferSize);\r
 135                 WriteBlockL();\r
 136         }\r
 137 \r
 138         iScheduler->Schedule();\r
 139 \r
 140         if(iListener.iUnderflowed) {\r
 141                 if(iListener.iUnderflowed > KMaxUnderflows) {\r
 142                         delete iMdaAudioOutputStream;\r
 143                         iMdaAudioOutputStream = 0;\r
 144                         return 0;\r
 145                 }\r
 146                 UnderflowedL(); // not again!\r
 147         }\r
 148 \r
 149         return iCurrentPosition;\r
 150 }\r
 151 \r
 152 void CGameAudioMS::WriteBlockL()\r
 153 {\r
 154         iScheduler->Schedule();\r
 155         // do not write until stream is open\r
 156         if(!iListener.iIsOpen) WaitForOpenToCompleteL();\r
 157         //if(!iListener.iHasCopied) WaitForCopyToCompleteL(); // almost never happens anyway and sometimes even deadlocks?\r
 158         //iListener.iHasCopied = EFalse;\r
 159         \r
 160 \r
 161         if(!iListener.iUnderflowed) {\r
 162                 TInt64 delta;\r
 163                 // don't write if sound is lagging too much\r
 164                 delta = iTime - iMdaAudioOutputStream->Position().Int64();\r
 165                 if (delta > MAKE_TINT64(0, KMaxLag))\r
 166                         // another query sometimes returns very different result\r
 167                         delta = iTime - iMdaAudioOutputStream->Position().Int64();\r
 168 \r
 169                 if(delta <= MAKE_TINT64(0, KMaxLag)) {\r
 170                         //RDebug::Print(_L("delta: %i"), iTime.Low() - iMdaAudioOutputStream->Position().Int64().Low());\r
 171                         iSoundBuffers[iCurrentBuffer]->Des().SetLength(iCurrentBufferSize);\r
 172                         iMdaAudioOutputStream->WriteL(*iSoundBuffers[iCurrentBuffer]);\r
 173                         iTime += KBlockTime;\r
 174                 } else {\r
 175                         DEBUGPRINT(_L("lag: %i"), I64LOW(delta));\r
 176                 }\r
 177         }\r
 178 \r
 179         if (++iCurrentBuffer == KSoundBuffers)\r
 180                 iCurrentBuffer = 0;\r
 181         iSoundBuffers[iCurrentBuffer]->Des().SetMax();\r
 182         iCurrentPosition = (TInt16*) iSoundBuffers[iCurrentBuffer]->Ptr();\r
 183         iCurrentBufferSize = 0;\r
 184 }\r
 185 \r
 186 void CGameAudioMS::Pause()\r
 187 {\r
 188         if(!iMdaAudioOutputStream) return;\r
 189 \r
 190         iScheduler->Schedule(); // let it finish it's stuff\r
 191         iMdaAudioOutputStream->Stop();\r
 192         delete iMdaAudioOutputStream;\r
 193         iMdaAudioOutputStream = 0;\r
 194 }\r
 195 \r
 196 // call this before doing any playback!\r
 197 TInt16 *CGameAudioMS::ResumeL()\r
 198 {\r
 199         DEBUGPRINT(_L("CGameAudioMS::Resume()"));\r
 200         iScheduler->Schedule();\r
 201 \r
 202         // we act a bit strange here: simulate buffer underflow, which actually starts audio\r
 203         iListener.iIsOpen = ETrue;\r
 204         iListener.iUnderflowed = 1;\r
 205         iListener.iLastError = 0;\r
 206         iCurrentBufferSize = 0;\r
 207         iCurrentPosition = (TInt16*) iSoundBuffers[iCurrentBuffer]->Ptr();\r
 208         return iCurrentPosition;\r
 209 }\r
 210 \r
 211 // handles underflow condition\r
 212 void CGameAudioMS::UnderflowedL()\r
 213 {\r
 214 #ifdef DEBUG_UNDERFLOWS\r
 215         DEBUGPRINT(_L("UnderflowedL()"));\r
 216 #endif\r
 217 \r
 218         if (iListener.iLastError != KErrUnderflow)\r
 219         {\r
 220                 // recreate the stream\r
 221                 //iMdaAudioOutputStream->Stop();\r
 222                 if(iMdaAudioOutputStream) delete iMdaAudioOutputStream;\r
 223                 iMdaAudioOutputStream = CMdaAudioOutputStream::NewL(iListener, iServer);\r
 224                 iMdaAudioOutputStream->Open(&iMdaAudioDataSettings);\r
 225                 iMdaAudioOutputStream->SetAudioPropertiesL(iMdaAudioDataSettings.iSampleRate, iMdaAudioDataSettings.iChannels);\r
 226                 iMdaAudioOutputStream->SetVolume(iVolume); // new in UIQ3\r
 227 \r
 228                 iListener.iIsOpen = EFalse;   // wait for it to open\r
 229                 //iListener.iHasCopied = ETrue; // but don't wait for last copy to complete\r
 230                 // let it open and feed some stuff to make it happy\r
 231                 User::After(0);\r
 232                 iScheduler->Schedule();\r
 233                 iListener.iLastError = 0;\r
 234                 if(!iListener.iIsOpen) WaitForOpenToCompleteL();\r
 235         } else {\r
 236                 iListener.iLastError = iListener.iUnderflowed = 0;\r
 237         }\r
 238         iTime = iMdaAudioOutputStream->Position().Int64();\r
 239 }\r
 240 \r
 241 void CGameAudioMS::WaitForOpenToCompleteL()\r
 242 {\r
 243         DEBUGPRINT(_L("CGameAudioMS::WaitForOpenToCompleteL"));\r
 244         TInt    count = 20;             // 2 seconds\r
 245         TInt    waitPeriod = 100 * 1000;\r
 246 \r
 247         if(!iListener.iIsOpen) {\r
 248                 // it is often enough to do this\r
 249                 User::After(0);\r
 250                 iScheduler->Schedule();\r
 251         }\r
 252         while (!iListener.iIsOpen && --count)\r
 253         {\r
 254                 User::After(waitPeriod);\r
 255                 iScheduler->Schedule();\r
 256         }\r
 257         if (!iListener.iIsOpen)\r
 258                 User::LeaveIfError(KErrNotSupported);\r
 259 }\r
 260 \r
 261 TInt CGameAudioMS::ChangeVolume(TInt aUp)\r
 262 {\r
 263         //DEBUGPRINT(_L("CGameAudioMS::ChangeVolume(%i)"), aUp);\r
 264 \r
 265         if (iMdaAudioOutputStream) {\r
 266                 if (aUp) {\r
 267                         iVolume += 5;\r
 268                         if (iVolume > iMdaAudioOutputStream->MaxVolume())\r
 269                                 iVolume = iMdaAudioOutputStream->MaxVolume();\r
 270                 } else {\r
 271                         iVolume -= 5;\r
 272                         if (iVolume < 0) iVolume = 0;\r
 273                 }\r
 274                 iMdaAudioOutputStream->SetVolume(iVolume);\r
 275         }\r
 276 \r
 277         return iVolume;\r
 278 }\r
 279 \r
 280 void TGameAudioEventListener::MaoscOpenComplete(TInt aError)\r
 281 {\r
 282 #ifdef DEBUG_UNDERFLOWS\r
 283         DEBUGPRINT(_L("CGameAudioMS::MaoscOpenComplete, error=%d"), aError);\r
 284 #endif\r
 285 \r
 286         iIsOpen = ETrue;\r
 287         if(aError) {\r
 288                 iLastError = aError;\r
 289                 iUnderflowed++;\r
 290         }\r
 291         else iUnderflowed = 0;\r
 292 }\r
 293 \r
 294 void TGameAudioEventListener::MaoscBufferCopied(TInt aError, const TDesC8& aBuffer)\r
 295 {\r
 296         if (aError)\r
 297                 DEBUGPRINT(_L("CGameAudioMS::MaoscBufferCopied, error=%d"), aError);\r
 298 \r
 299 //      iHasCopied = ETrue;\r
 300 \r
 301         if(aError) { // shit!\r
 302                 iLastError = aError;\r
 303                 iUnderflowed++;\r
 304         }\r
 305 }\r
 306 \r
 307 void TGameAudioEventListener::MaoscPlayComplete(TInt aError)\r
 308 {\r
 309 #ifdef DEBUG_UNDERFLOWS\r
 310         DEBUGPRINT(_L("CGameAudioMS::MaoscPlayComplete: %i"), aError);\r
 311 #endif\r
 312         if(aError) {\r
 313                 iLastError = aError;\r
 314                 iUnderflowed++; // never happened to me while testing, but just in case\r
 315         }\r
 316 }\r
 317 \r