1 //------------------------------------------------------------------------------ 2 // Copyright (c) 2001-2002, OpenBeOS 3 // 4 // Permission is hereby granted, free of charge, to any person obtaining a 5 // copy of this software and associated documentation files (the "Software"), 6 // to deal in the Software without restriction, including without limitation 7 // the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 // and/or sell copies of the Software, and to permit persons to whom the 9 // Software is furnished to do so, subject to the following conditions: 10 // 11 // The above copyright notice and this permission notice shall be included in 12 // all copies or substantial portions of the Software. 13 // 14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 19 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 20 // DEALINGS IN THE SOFTWARE. 21 // 22 // File Name: GameSoundBuffer.h 23 // Author: Christopher ML Zumwalt May (zummy@users.sf.net) 24 // Description: Interface to a single sound, managed by the GameSoundDevice. 25 //------------------------------------------------------------------------------ 26 27 28 #include "GameSoundBuffer.h" 29 30 #include <stdio.h> 31 #include <stdlib.h> 32 #include <string.h> 33 34 #include <MediaRoster.h> 35 #include <MediaAddOn.h> 36 #include <MediaTheme.h> 37 #include <TimeSource.h> 38 #include <BufferGroup.h> 39 40 #include "GameProducer.h" 41 #include "GameSoundDevice.h" 42 #include "StreamingGameSound.h" 43 #include "GSUtility.h" 44 45 46 // Sound Buffer Utility functions ---------------------------------------- 47 template<typename T> 48 static inline void 49 ApplyMod(T* data, T* buffer, int64 index, float * pan) 50 { 51 data[index * 2] += T(float(buffer[index * 2]) * pan[0]); 52 data[index * 2 + 1] += T(float(buffer[index * 2 + 1]) * pan[1]); 53 } 54 55 56 // GameSoundBuffer ------------------------------------------------------- 57 GameSoundBuffer::GameSoundBuffer(const gs_audio_format * format) 58 : 59 fLooping(false), 60 fIsConnected(false), 61 fIsPlaying(false), 62 fGain(1.0), 63 fPan(0.0), 64 fPanLeft(1.0), 65 fPanRight(1.0), 66 fGainRamp(NULL), 67 fPanRamp(NULL) 68 { 69 fConnection = new Connection; 70 fNode = new GameProducer(this, format); 71 72 fFrameSize = get_sample_size(format->format) * format->channel_count; 73 74 fFormat = *format; 75 } 76 77 78 // Play must stop before the distructor is called; otherwise, a fatal 79 // error occures if the playback is in a subclass. 80 GameSoundBuffer::~GameSoundBuffer() 81 { 82 BMediaRoster* roster = BMediaRoster::Roster(); 83 84 if (fIsConnected) { 85 // Ordinarily we'd stop *all* of the nodes in the chain at this point. 86 // However, one of the nodes is the System Mixer, and stopping the Mixer 87 // is a Bad Idea (tm). So, we just disconnect from it, and release our 88 // references to the nodes that we're using. We *are* supposed to do 89 // that even for global nodes like the Mixer. 90 roster->Disconnect(fConnection->producer.node, fConnection->source, 91 fConnection->consumer.node, fConnection->destination); 92 93 roster->ReleaseNode(fConnection->producer); 94 roster->ReleaseNode(fConnection->consumer); 95 } 96 97 delete fGainRamp; 98 delete fPanRamp; 99 100 delete fConnection; 101 delete fNode; 102 } 103 104 105 const gs_audio_format & 106 GameSoundBuffer::Format() const 107 { 108 return fFormat; 109 } 110 111 112 bool 113 GameSoundBuffer::IsLooping() const 114 { 115 return fLooping; 116 } 117 118 119 void 120 GameSoundBuffer::SetLooping(bool looping) 121 { 122 fLooping = looping; 123 } 124 125 126 float 127 GameSoundBuffer::Gain() const 128 { 129 return fGain; 130 } 131 132 133 status_t 134 GameSoundBuffer::SetGain(float gain, bigtime_t duration) 135 { 136 if (gain < 0.0 || gain > 1.0) 137 return B_BAD_VALUE; 138 139 delete fGainRamp; 140 fGainRamp = NULL; 141 142 if (duration > 100000) 143 fGainRamp = InitRamp(&fGain, gain, fFormat.frame_rate, duration); 144 else 145 fGain = gain; 146 147 return B_OK; 148 } 149 150 151 float 152 GameSoundBuffer::Pan() const 153 { 154 return fPan; 155 } 156 157 158 status_t 159 GameSoundBuffer::SetPan(float pan, bigtime_t duration) 160 { 161 if (pan < -1.0 || pan > 1.0) 162 return B_BAD_VALUE; 163 164 delete fPanRamp; 165 fPanRamp = NULL; 166 167 if (duration < 100000) { 168 fPan = pan; 169 170 if (fPan < 0.0) { 171 fPanLeft = 1.0; 172 fPanRight = 1.0 + fPan; 173 } else { 174 fPanRight = 1.0; 175 fPanLeft = 1.0 - fPan; 176 } 177 } else 178 fPanRamp = InitRamp(&fPan, pan, fFormat.frame_rate, duration); 179 180 return B_OK; 181 } 182 183 184 status_t 185 GameSoundBuffer::GetAttributes(gs_attribute * attributes, 186 size_t attributeCount) 187 { 188 for (size_t i = 0; i < attributeCount; i++) { 189 switch (attributes[i].attribute) { 190 case B_GS_GAIN: 191 attributes[i].value = fGain; 192 if (fGainRamp) 193 attributes[i].duration = fGainRamp->duration; 194 break; 195 196 case B_GS_PAN: 197 attributes[i].value = fPan; 198 if (fPanRamp) 199 attributes[i].duration = fPanRamp->duration; 200 break; 201 202 case B_GS_LOOPING: 203 attributes[i].value = (fLooping) ? -1.0 : 0.0; 204 attributes[i].duration = bigtime_t(0); 205 break; 206 207 default: 208 attributes[i].value = 0.0; 209 attributes[i].duration = bigtime_t(0); 210 break; 211 } 212 } 213 214 return B_OK; 215 } 216 217 218 status_t 219 GameSoundBuffer::SetAttributes(gs_attribute * attributes, 220 size_t attributeCount) 221 { 222 status_t error = B_OK; 223 224 for (size_t i = 0; i < attributeCount; i++) { 225 switch (attributes[i].attribute) { 226 case B_GS_GAIN: 227 error = SetGain(attributes[i].value, attributes[i].duration); 228 break; 229 230 case B_GS_PAN: 231 error = SetPan(attributes[i].value, attributes[i].duration); 232 break; 233 234 case B_GS_LOOPING: 235 fLooping = bool(attributes[i].value); 236 break; 237 238 default: 239 break; 240 } 241 } 242 243 return error; 244 } 245 246 247 void 248 GameSoundBuffer::Play(void * data, int64 frames) 249 { 250 // Mh... should we add some locking? 251 if (!fIsPlaying) 252 return; 253 254 if (fFormat.channel_count == 2) { 255 float pan[2]; 256 pan[0] = fPanRight * fGain; 257 pan[1] = fPanLeft * fGain; 258 259 char * buffer = new char[fFrameSize * frames]; 260 261 FillBuffer(buffer, frames); 262 263 switch (fFormat.format) { 264 case gs_audio_format::B_GS_U8: 265 { 266 for (int64 i = 0; i < frames; i++) { 267 ApplyMod((uint8*)data, (uint8*)buffer, i, pan); 268 UpdateMods(); 269 } 270 271 break; 272 } 273 274 case gs_audio_format::B_GS_S16: 275 { 276 for (int64 i = 0; i < frames; i++) { 277 ApplyMod((int16*)data, (int16*)buffer, i, pan); 278 UpdateMods(); 279 } 280 281 break; 282 } 283 284 case gs_audio_format::B_GS_S32: 285 { 286 for (int64 i = 0; i < frames; i++) { 287 ApplyMod((int32*)data, (int32*)buffer, i, pan); 288 UpdateMods(); 289 } 290 291 break; 292 } 293 294 case gs_audio_format::B_GS_F: 295 { 296 for (int64 i = 0; i < frames; i++) { 297 ApplyMod((float*)data, (float*)buffer, i, pan); 298 UpdateMods(); 299 } 300 301 break; 302 } 303 } 304 delete[] buffer; 305 } else if (fFormat.channel_count == 1) { 306 // FIXME the output should be stereo, and we could pan mono sounds 307 // here. But currently the output has the same number of channels as 308 // the sound and we can't do this. 309 // FIXME also, we don't handle the gain here. 310 FillBuffer(data, frames); 311 } else 312 debugger("Invalid number of channels."); 313 314 } 315 316 317 void 318 GameSoundBuffer::UpdateMods() 319 { 320 // adjust the gain if needed 321 if (fGainRamp) { 322 if (ChangeRamp(fGainRamp)) { 323 delete fGainRamp; 324 fGainRamp = NULL; 325 } 326 } 327 328 // adjust the ramp if needed 329 if (fPanRamp) { 330 if (ChangeRamp(fPanRamp)) { 331 delete fPanRamp; 332 fPanRamp = NULL; 333 } else { 334 if (fPan < 0.0) { 335 fPanLeft = 1.0; 336 fPanRight = 1.0 + fPan; 337 } else { 338 fPanRight = 1.0; 339 fPanLeft = 1.0 - fPan; 340 } 341 } 342 } 343 } 344 345 346 void 347 GameSoundBuffer::Reset() 348 { 349 fGain = 1.0; 350 delete fGainRamp; 351 fGainRamp = NULL; 352 353 fPan = 0.0; 354 fPanLeft = 1.0; 355 fPanRight = 1.0; 356 357 delete fPanRamp; 358 fPanRamp = NULL; 359 360 fLooping = false; 361 } 362 363 364 status_t 365 GameSoundBuffer::Connect(media_node * consumer) 366 { 367 BMediaRoster* roster = BMediaRoster::Roster(); 368 status_t err = roster->RegisterNode(fNode); 369 370 if (err != B_OK) 371 return err; 372 373 // make sure the Media Roster knows that we're using the node 374 err = roster->GetNodeFor(fNode->Node().node, &fConnection->producer); 375 376 if (err != B_OK) 377 return err; 378 379 // connect to the mixer 380 fConnection->consumer = *consumer; 381 382 // set the producer's time source to be the "default" time source, which 383 // the Mixer uses too. 384 err = roster->GetTimeSource(&fConnection->timeSource); 385 if (err != B_OK) 386 return err; 387 388 err = roster->SetTimeSourceFor(fConnection->producer.node, 389 fConnection->timeSource.node); 390 if (err != B_OK) 391 return err; 392 // got the nodes; now we find the endpoints of the connection 393 media_input mixerInput; 394 media_output soundOutput; 395 int32 count = 1; 396 err = roster->GetFreeOutputsFor(fConnection->producer, &soundOutput, 1, 397 &count); 398 399 if (err != B_OK) 400 return err; 401 count = 1; 402 err = roster->GetFreeInputsFor(fConnection->consumer, &mixerInput, 1, 403 &count); 404 if (err != B_OK) 405 return err; 406 407 // got the endpoints; now we connect it! 408 media_format format; 409 format.type = B_MEDIA_RAW_AUDIO; 410 format.u.raw_audio = media_raw_audio_format::wildcard; 411 err = roster->Connect(soundOutput.source, mixerInput.destination, &format, 412 &soundOutput, &mixerInput); 413 if (err != B_OK) 414 return err; 415 416 // the inputs and outputs might have been reassigned during the 417 // nodes' negotiation of the Connect(). That's why we wait until 418 // after Connect() finishes to save their contents. 419 fConnection->format = format; 420 fConnection->source = soundOutput.source; 421 fConnection->destination = mixerInput.destination; 422 423 fIsConnected = true; 424 return B_OK; 425 } 426 427 428 status_t 429 GameSoundBuffer::StartPlaying() 430 { 431 if (fIsPlaying) 432 return EALREADY; 433 434 BMediaRoster* roster = BMediaRoster::Roster(); 435 BTimeSource* source = roster->MakeTimeSourceFor(fConnection->producer); 436 437 // make sure we give the producer enough time to run buffers through 438 // the node chain, otherwise it'll start up already late 439 bigtime_t latency = 0; 440 status_t status = roster->GetLatencyFor(fConnection->producer, &latency); 441 if (status == B_OK) { 442 status = roster->StartNode(fConnection->producer, 443 source->Now() + latency); 444 } 445 source->Release(); 446 447 fIsPlaying = true; 448 449 return status; 450 } 451 452 453 status_t 454 GameSoundBuffer::StopPlaying() 455 { 456 if (!fIsPlaying) 457 return EALREADY; 458 459 BMediaRoster* roster = BMediaRoster::Roster(); 460 roster->StopNode(fConnection->producer, 0, true); 461 // synchronous stop 462 463 Reset(); 464 fIsPlaying = false; 465 466 return B_OK; 467 } 468 469 470 bool 471 GameSoundBuffer::IsPlaying() 472 { 473 return fIsPlaying; 474 } 475 476 477 // SimpleSoundBuffer ------------------------------------------------------ 478 SimpleSoundBuffer::SimpleSoundBuffer(const gs_audio_format * format, 479 const void * data, int64 frames) 480 : 481 GameSoundBuffer(format), 482 fPosition(0) 483 { 484 fBufferSize = frames * fFrameSize; 485 fBuffer = (char*)data; 486 } 487 488 489 SimpleSoundBuffer::~SimpleSoundBuffer() 490 { 491 delete [] fBuffer; 492 } 493 494 495 void 496 SimpleSoundBuffer::Reset() 497 { 498 GameSoundBuffer::Reset(); 499 fPosition = 0; 500 } 501 502 503 void 504 SimpleSoundBuffer::FillBuffer(void * data, int64 frames) 505 { 506 char * buffer = (char*)data; 507 size_t bytes = fFrameSize * frames; 508 509 if (fPosition + bytes >= fBufferSize) { 510 if (fPosition < fBufferSize) { 511 // copy the remaining frames 512 size_t remainder = fBufferSize - fPosition; 513 memcpy(buffer, &fBuffer[fPosition], remainder); 514 515 if (fLooping) { 516 // restart the sound from the begging 517 memcpy(&buffer[remainder], fBuffer, bytes - remainder); 518 fPosition = bytes - remainder; 519 } else 520 fPosition = fBufferSize; 521 } else 522 memset(data, 0, bytes); 523 // there is nothing left to play 524 } else { 525 memcpy(buffer, &fBuffer[fPosition], bytes); 526 fPosition += bytes; 527 } 528 } 529 530 531 // StreamingSoundBuffer ------------------------------------------------------ 532 StreamingSoundBuffer::StreamingSoundBuffer(const gs_audio_format * format, 533 const void * streamHook, size_t inBufferFrameCount, size_t inBufferCount) 534 : 535 GameSoundBuffer(format), 536 fStreamHook(const_cast<void *>(streamHook)) 537 { 538 if (inBufferFrameCount != 0 && inBufferCount != 0) { 539 BBufferGroup *bufferGroup 540 = new BBufferGroup(inBufferFrameCount * fFrameSize, inBufferCount); 541 fNode->SetBufferGroup(fConnection->source, bufferGroup); 542 } 543 } 544 545 546 StreamingSoundBuffer::~StreamingSoundBuffer() 547 { 548 } 549 550 551 void 552 StreamingSoundBuffer::FillBuffer(void * buffer, int64 frames) 553 { 554 BStreamingGameSound* object = (BStreamingGameSound*)fStreamHook; 555 556 size_t bytes = fFrameSize * frames; 557 object->FillBuffer(buffer, bytes); 558 } 559