src/audio.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * audio.cpp:
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2008 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  */
  12
  13 #include <config.h>
  14
  15 #include <pthread.h>
  16
  17 #include "audio.h"
  18 #include "audio-alsa.h"
  19 #include "audio-pulse.h"
  20 #include "pipeline.h"
  21 #include "runtime.h"
  22 #include "clock.h"
  23 #include "debug.h"
  24 #include "mediaplayer.h"
  25 #include "deployment.h"
  26
  27 /*
  28  * AudioSource::AudioFrame
  29  */
  30
  31 AudioSource::AudioFrame::AudioFrame (MediaFrame *frame)
  32 {
  33         this->frame = frame;
  34         this->frame->ref ();
  35         bytes_used = 0;
  36 }
  37
  38 AudioSource::AudioFrame::~AudioFrame ()
  39 {
  40         frame->unref ();
  41 }
  42
  43 /*
  44  * AudioSource
  45  */
  46
  47 AudioSource::AudioSource (AudioPlayer *player, MediaPlayer *mplayer, AudioStream *stream)
  48         : EventObject (Type::AUDIOSOURCE, true)
  49 {
  50         pthread_mutexattr_t attribs;
  51
  52         this->mplayer = mplayer;
  53         this->mplayer->ref ();
  54         this->stream = stream;
  55         this->stream->ref ();
  56         this->player = player;
  57
  58         stream->AddSafeHandler (IMediaStream::FirstFrameEnqueuedEvent, FirstFrameEnqueuedCallback, this, false);
  59
  60         current_frame = NULL;
  61
  62         state = AudioNone;
  63         flags = (AudioFlags) 0;
  64
  65         balance = 0.0f;
  66         volume = 1.0f;
  67         muted = false;
  68
  69         last_write_pts = G_MAXUINT64;
  70         last_current_pts = G_MAXUINT64;
  71
  72         channels = stream->GetOutputChannels ();
  73         sample_rate = stream->GetOutputSampleRate ();
  74         input_bytes_per_sample = stream->GetOutputBitsPerSample () / 8;
  75         output_bytes_per_sample = input_bytes_per_sample;
  76
  77         pthread_mutexattr_init (&attribs);
  78         pthread_mutexattr_settype (&attribs, PTHREAD_MUTEX_RECURSIVE);
  79         pthread_mutex_init (&mutex, &attribs);
  80         pthread_mutexattr_destroy (&attribs);
  81
  82
  83 #ifdef DUMP_AUDIO
  84         char *fname = g_strdup_printf ("/tmp/AudioSource-%iHz-%iChannels-%iBit.raw", sample_rate, channels, input_bytes_per_sample * 8);
  85         dump_fd = fopen (fname, "w+");
  86         printf ("AudioSource: Dumping pcm data to: %s, command line to play:\n", fname);
  87         printf ("play -s -t raw -%i -c %i --rate %i %s\n", input_bytes_per_sample, channels, sample_rate, fname);
  88         g_free (fname);
  89 #endif
  90 }
  91
  92 AudioSource::~AudioSource ()
  93 {
  94         pthread_mutex_destroy (&mutex);
  95
  96 #ifdef DUMP_AUDIO
  97         fclose (dump_fd);
  98 #endif
  99 }
 100
 101 void
 102 AudioSource::Dispose ()
 103 {
 104         IMediaStream *stream;
 105         MediaPlayer *mplayer;
 106         AudioFrame *current_frame;
 107
 108         Stop ();
 109
 110         Lock ();
 111         stream = this->stream;
 112         this->stream = NULL;
 113         mplayer = this->mplayer;
 114         this->mplayer = NULL;
 115         current_frame = this->current_frame;
 116         this->current_frame = NULL;
 117         Unlock ();
 118
 119         if (stream) {
 120                 stream->RemoveAllHandlers (this);
 121                 stream->unref ();
 122                 stream = NULL;
 123         }
 124
 125         if (mplayer) {
 126                 mplayer->unref ();
 127                 mplayer = NULL;
 128         }
 129
 130         if (current_frame) {
 131                 delete current_frame;
 132                 current_frame = NULL;
 133         }
 134
 135         EventObject::Dispose ();
 136 }
 137
 138 MediaPlayer *
 139 AudioSource::GetMediaPlayerReffed ()
 140 {
 141         MediaPlayer *result = NULL;
 142         Lock ();
 143         if (mplayer != NULL) {
 144                 result = mplayer;
 145                 result->ref ();
 146         }
 147         Unlock ();
 148         return result;
 149 }
 150
 151 void
 152 AudioSource::Lock ()
 153 {
 154         pthread_mutex_lock (&mutex);
 155 }
 156
 157 void
 158 AudioSource::Unlock ()
 159 {
 160         pthread_mutex_unlock (&mutex);
 161 }
 162
 163 AudioStream *
 164 AudioSource::GetAudioStream ()
 165 {
 166         AudioStream *result;
 167         Lock ();
 168         result = stream;
 169         Unlock ();
 170         return result;
 171 }
 172
 173 void
 174 AudioSource::SetAudioStream (AudioStream *value)
 175 {
 176         Lock ();
 177         if (stream)
 178                 stream->unref ();
 179         stream = value;
 180         if (stream)
 181                 stream->ref ();
 182         Unlock ();
 183 }
 184
 185 guint32
 186 AudioSource::GetInputBytesPerFrame ()
 187 {
 188         /* No locking required, this can only be set during initialization */
 189         return channels * input_bytes_per_sample;
 190 }
 191
 192 guint32
 193 AudioSource::GetInputBytesPerSample ()
 194 {
 195         /* No locking required, this can only be set during initialization */
 196         return input_bytes_per_sample;
 197 }
 198
 199 guint32
 200 AudioSource::GetOutputBytesPerFrame ()
 201 {
 202         /* No locking required, this can only be set during initialization */
 203         return channels * output_bytes_per_sample;
 204 }
 205
 206 guint32
 207 AudioSource::GetOutputBytesPerSample ()
 208 {
 209         /* No locking required, this can only be set during initialization */
 210         return output_bytes_per_sample;
 211 }
 212
 213 void
 214 AudioSource::SetOutputBytesPerSample (guint32 value)
 215 {
 216         /* No locking required, this can only be set during initialization */
 217         output_bytes_per_sample = value;
 218 }
 219
 220 AudioStream *
 221 AudioSource::GetStreamReffed ()
 222 {
 223         AudioStream *result;
 224         Lock ();
 225         result = stream;
 226         if (result)
 227                 result->ref ();
 228         Unlock ();
 229         return result;
 230 }
 231
 232 void
 233 AudioSource::SetFlag (AudioFlags flag, bool value)
 234 {
 235         Lock ();
 236         if (value) {
 237                 flags = (AudioFlags) (flag | flags);
 238         } else {
 239                 flags = (AudioFlags) (~flag & flags);
 240         }
 241         LOG_AUDIO_EX ("AudioSource::SetFlag (%i = %s, %i), resulting flags: %i = %s\n", flag, GetFlagNames (flag), value, flags, GetFlagNames (flags));
 242         Unlock ();
 243 }
 244
 245 bool
 246 AudioSource::GetFlag (AudioFlags flag)
 247 {
 248         return flags & flag;
 249 }
 250
 251 #if DEBUG
 252 char *
 253 AudioSource::GetFlagNames (AudioFlags flags)
 254 {
 255         const char *v [5];
 256         int i = 0;
 257         v [0] = v [1] = v [2] = v [3] = v [4] = NULL;
 258
 259         if (flags & AudioInitialized)
 260                 v [i++] = "Initialized";
 261
 262         if (flags & AudioEOF)
 263                 v [i++] = "EOF";
 264
 265         if (flags & AudioWaiting)
 266                 v [i++] = "Waiting";
 267
 268         if (flags & AudioEnded)
 269                 v [i++] = "Ended";
 270
 271         return (char *) g_strjoinv (",", (gchar **) v);
 272
 273 }
 274 #endif
 275
 276 const char *
 277 AudioSource::GetStateName (AudioState state)
 278 {
 279         switch (state) {
 280         case AudioNone: return "None";
 281         case AudioPlaying: return "Playing";
 282         case AudioPaused: return "Paused";
 283         case AudioError: return "Error";
 284         case AudioStopped: return "Stopped";
 285         default: return "Unknown";
 286         }
 287 }
 288
 289 AudioState
 290 AudioSource::GetState ()
 291 {
 292         AudioState result;
 293         Lock ();
 294         result = state;
 295         Unlock ();
 296         return result;
 297 }
 298
 299 void
 300 AudioSource::SetState (AudioState value)
 301 {
 302         AudioState old_state;
 303         bool changed = false;
 304         bool audio_failed = false;
 305
 306         Lock ();
 307         if (state != value) {
 308                 if (state == AudioError) {
 309                         LOG_AUDIO ("AudioSource::SetState (%s): Current state is Error, can't change that state\n", GetStateName (value));
 310                 } else {
 311                         old_state = state;
 312                         state = value;
 313                         changed = true;
 314                         if (value == AudioError)
 315                                 audio_failed = true;
 316                 }
 317         }
 318         Unlock ();
 319
 320         if (audio_failed) {
 321                 MediaPlayer *mplayer = GetMediaPlayerReffed ();
 322                 if (mplayer != NULL) {
 323                         mplayer->AudioFailed (this);
 324                         mplayer->unref ();
 325                 }
 326         }
 327
 328         LOG_AUDIO_EX ("AudioSource::SetState (%s), old state: %s, changed: %i\n", GetStateName (value), GetStateName (old_state), changed);
 329
 330         if (changed)
 331                 StateChanged (old_state);
 332 }
 333
 334 double
 335 AudioSource::GetBalance ()
 336 {
 337         double result;
 338         Lock ();
 339         result = balance;
 340         Unlock ();
 341         return result;
 342 }
 343
 344 void
 345 AudioSource::SetBalance (double value)
 346 {
 347         Lock ();
 348         balance = value;
 349         Unlock ();
 350 }
 351
 352 double
 353 AudioSource::GetVolume ()
 354 {
 355         double result;
 356         Lock ();
 357         result = volume;
 358         Unlock ();
 359         return result;
 360 }
 361
 362 void
 363 AudioSource::SetVolume (double value)
 364 {
 365         Lock ();
 366         volume = value;
 367         Unlock ();
 368 }
 369
 370 bool
 371 AudioSource::GetMuted ()
 372 {
 373         bool result;
 374         Lock ();
 375         result = muted;
 376         Unlock ();
 377         return result;
 378 }
 379
 380 void
 381 AudioSource::SetMuted (bool value)
 382 {
 383         Lock ();
 384         muted = value;
 385         Unlock ();
 386 }
 387
 388 guint32
 389 AudioSource::GetChannels ()
 390 {
 391         // This can only be set during initialization, so there's no need to lock here.
 392         return channels;
 393 }
 394
 395 guint32
 396 AudioSource::GetSampleRate ()
 397 {
 398         // This can only be set during initialization, so there's no need to lock here.
 399         return sample_rate;
 400 }
 401
 402 bool
 403 AudioSource::IsQueueEmpty ()
 404 {
 405         bool result;
 406         AudioStream *stream;
 407
 408         LOG_AUDIO_EX ("AudioSource::IsQueueEmpty ().\n");
 409
 410         stream = GetStreamReffed ();
 411
 412         if (stream == NULL) {
 413                 result = true;
 414         } else {
 415                 result = stream->IsQueueEmpty ();
 416                 stream->unref ();
 417         }
 418
 419         return result;
 420 }
 421
 422 void
 423 AudioSource::FirstFrameEnqueuedHandler (EventObject *sender, EventArgs *args)
 424 {
 425         LOG_AUDIO_EX ("AudioSource::FirstFrameEnqueuedHandler ().\n");
 426
 427         if (GetFlag (AudioWaiting)) {
 428                 SetFlag (AudioWaiting, false);
 429                 if (GetState () == AudioPlaying)
 430                         Play ();
 431         }
 432 }
 433
 434 guint64
 435 AudioSource::GetDelay ()
 436 {
 437         return GetDelayInternal ();
 438 }
 439
 440 guint64
 441 AudioSource::GetCurrentPts ()
 442 {
 443         guint64 delay = 0;
 444         guint64 current_pts = 0;
 445         guint64 result = 0;
 446
 447         if (GetState () != AudioPlaying) {
 448                 result = last_current_pts;
 449         } else {
 450                 Lock ();
 451                 current_pts = last_write_pts;
 452                 Unlock ();
 453
 454                 delay = GetDelay ();
 455
 456                 if (current_pts == G_MAXUINT64) {
 457                         result = current_pts;
 458                 } else if (delay == G_MAXUINT64 || GetState () != AudioPlaying) {
 459                         result = last_current_pts;
 460                 } else if (delay > current_pts) {
 461                         result = 0;
 462                 } else {
 463                         result = current_pts - delay;
 464                 }
 465         }
 466
 467         last_current_pts = result;
 468
 469         LOG_AUDIO_EX ("AudioSource::GetCurrentPts (): %" G_GUINT64_FORMAT " ms, delay: %" G_GUINT64_FORMAT ", last_write_pts: %" G_GUINT64_FORMAT "\n",
 470                 MilliSeconds_FromPts (result), MilliSeconds_FromPts (delay), MilliSeconds_FromPts (last_write_pts));
 471
 472         return result;
 473 }
 474
 475 void
 476 AudioSource::Stop ()
 477 {
 478         LOG_AUDIO ("AudioSource::Stop ()\n");
 479
 480         Lock ();
 481         SetState (AudioStopped);
 482         last_current_pts = G_MAXUINT64;
 483         last_write_pts = G_MAXUINT64;
 484         delete current_frame;
 485         current_frame = NULL;
 486         Unlock ();
 487         Stopped ();
 488 }
 489
 490 void
 491 AudioSource::Play ()
 492 {
 493         LOG_AUDIO ("AudioSource::Play ()\n");
 494
 495         SetState (AudioPlaying);
 496         SetFlag ((AudioFlags) (AudioEnded | AudioEOF | AudioWaiting), false);
 497         Played ();
 498 }
 499
 500 void
 501 AudioSource::Pause ()
 502 {
 503         LOG_AUDIO ("AudioSource::Pause ()\n");
 504
 505         SetState (AudioPaused);
 506         Paused ();
 507 }
 508
 509 void
 510 AudioSource::Underflowed ()
 511 {
 512         MediaPlayer *mplayer;
 513         LOG_AUDIO ("AudioSource::Underflowed (), state: %s, flags: %s\n", GetStateName (GetState ()), GetFlagNames (flags));
 514
 515         if (IsDisposed ())
 516                 return;
 517
 518         SetCurrentDeployment (false);
 519
 520         mplayer = GetMediaPlayerReffed ();
 521
 522         if (GetState () == AudioPlaying) {
 523                 if (GetFlag (AudioEOF)) {
 524                         Stop ();
 525                         SetFlag (AudioEnded, true);
 526                         if (mplayer != NULL)
 527                                 mplayer->AudioFinished ();
 528                 } else if (IsQueueEmpty ()) {
 529                         SetFlag (AudioWaiting, true);
 530                         if (mplayer != NULL)
 531                                 mplayer->SetBufferUnderflow ();
 532                 }
 533         }
 534
 535         if (mplayer != NULL)
 536                 mplayer->unref ();
 537 }
 538
 539 bool
 540 AudioSource::Initialize ()
 541 {
 542         bool result;
 543
 544         result = InitializeInternal ();
 545
 546         if (result) {
 547                 SetFlag (AudioInitialized, true);
 548         } else {
 549                 SetFlag (AudioInitialized, false);
 550                 SetState (AudioError);
 551         }
 552
 553         return result;
 554 }
 555
 556 void
 557 AudioSource::Close ()
 558 {
 559         CloseInternal ();
 560 }
 561
 562 guint32
 563 AudioSource::Write (void *dest, guint32 samples)
 564 {
 565         AudioData **data = (AudioData **) g_alloca (sizeof (AudioData *) * (channels + 1));
 566         guint32 result = 0;
 567
 568         for (unsigned int i = 0; i < channels; i++)
 569                 data [i] = (AudioData *) g_malloc (sizeof (AudioData));
 570
 571         data [0]->dest = dest;
 572         data [0]->distance = GetOutputBytesPerFrame ();
 573         // Interleaved multi-channel audio data
 574         for (unsigned int i = 1; i < channels; i++) {
 575                 data [i]->dest = ((char *) dest) + output_bytes_per_sample * i;
 576                 data [i]->distance = data [0]->distance;
 577         }
 578         data [channels] = NULL;
 579         result = WriteFull (data, samples);
 580
 581         for (int i = 0; data [i] != NULL; i++) {
 582                 g_free (data [i]);
 583         }
 584
 585         return result;
 586 }
 587
 588 guint32
 589 AudioSource::WriteFull (AudioData **channel_data, guint32 samples)
 590 {
 591         guint32 channels = GetChannels ();
 592         gint32 *volumes = (gint32 *) g_alloca (sizeof (gint32) * channels);
 593         gint32 volume;
 594         double balance;
 595         bool muted;
 596         gint16 **write_ptr = (gint16 **) g_alloca (sizeof (gint16 *) * channels);
 597         guint32 result = 0;
 598         guint32 bytes_per_frame = input_bytes_per_sample * channels;
 599         guint32 frames_to_write;
 600         guint32 bytes_available;
 601         guint32 bytes_written;
 602         gint32 value;
 603         guint64 last_frame_pts = 0; // The pts of the last frame which was used to write samples
 604         guint64 last_frame_samples = 0; // Samples written from the last frame
 605         IMediaStream *stream;
 606
 607         SetCurrentDeployment (false);
 608
 609         // Validate input
 610         if (channel_data == NULL) {
 611                 SetState (AudioError);
 612                 return 0;
 613         }
 614         for (guint32 i = 0; i < channels; i++) {
 615                 if (channel_data [i] == NULL) {
 616                         LOG_AUDIO ("AudioSource::WriteFull (%p, %u): channel data #%i is NULL\n", channel_data, samples, i );
 617                         SetState (AudioError);
 618                         return 0;
 619                 }
 620         }
 621         if (channel_data [channels] != NULL) {
 622                 SetState (AudioError);
 623                 return 0;
 624         }
 625
 626         stream = GetStreamReffed ();
 627         if (stream == NULL) {
 628                 LOG_AUDIO ("AudioSource::WriteFull (): no stream.\n");
 629                 return 0;
 630         }
 631
 632         Lock ();
 633
 634         volume = this->volume * 8192;
 635         balance = this->balance;
 636         muted = false; //this->muted;
 637
 638         // Set the per-channel volume
 639         if (channels > 2) {
 640                 // TODO: how does the balance work here?
 641                 // We probably need a channel map to figure out left and right
 642                 for (unsigned int i = 0; i < channels; i++) {
 643                         volumes [i] = muted ? 0.0 : volume;
 644                 }
 645         } else if (channels == 2) {
 646                 if (muted) {
 647                         volumes [0] = volumes [1] = 0;
 648                 } else  if (balance < 0.0) {
 649                         volumes [0] = volume;
 650                         volumes [1] = (1.0 + balance) * volume;
 651                 } else if (balance > 0.0) {
 652                         volumes [0] = (1.0 - balance) * volume;
 653                         volumes [1] = volume;
 654                 } else {
 655                         volumes [0] = volumes [1] = volume;
 656                 }
 657         } else if (channels == 1) {
 658                 if (muted) {
 659                         volumes [0] = 0;
 660                 } else {
 661                         volumes [0] = volume;
 662                 }
 663         } else {
 664                 SetState (AudioError);
 665                 goto cleanup;
 666         }
 667
 668         for (guint32 i = 0; i < channels; i++)
 669                 write_ptr [i] = (gint16 *) channel_data [i]->dest;
 670
 671         while (GetState () == AudioPlaying) {
 672                 if (current_frame == NULL) {
 673                         MediaFrame *frame = stream->PopFrame ();
 674                         if (frame != NULL) {
 675                                 current_frame = new AudioFrame (frame);
 676                                 frame->unref ();
 677                         }
 678                 }
 679
 680                 if (current_frame == NULL) {
 681                         if (stream->GetOutputEnded ()) {
 682                                 LOG_AUDIO ("AudioSource::WriteFull (): No more data and reached the end.\n");
 683                                 SetFlag (AudioWaiting, false);
 684                                 SetFlag ((AudioFlags) (AudioEOF | AudioEnded), true);
 685                         } else {
 686                                 LOG_AUDIO ("AudioSource::WriteFull (): No more data, starting to wait...\n");
 687                                 if (!GetFlag (AudioEOF) && !GetFlag (AudioEnded)) {
 688                                         SetFlag (AudioWaiting, true);
 689                                         SetFlag ((AudioFlags) (AudioEOF | AudioEnded), false);
 690                                 }
 691                         }
 692                         goto cleanup;
 693                 }
 694
 695                 bytes_available = current_frame->frame->buflen - current_frame->bytes_used;
 696
 697                 if (bytes_available < bytes_per_frame) {
 698                         LOG_AUDIO ("AudioSource::WriteFull (): incomplete packet, bytes_available: %u, buflen: %u, bytes_used: %u\n", bytes_available, current_frame->frame->buflen, current_frame->bytes_used);
 699                         delete current_frame;
 700                         current_frame = NULL;
 701                         continue;
 702                 }
 703
 704                 frames_to_write = MIN (bytes_available / bytes_per_frame, samples - result);
 705                 bytes_written = frames_to_write * bytes_per_frame;
 706
 707 #ifdef DUMP_AUDIO
 708                 fwrite ((((char *) current_frame->frame->buffer) + current_frame->bytes_used), 1, bytes_written, dump_fd);
 709 #endif
 710
 711                 switch (this->input_bytes_per_sample) {
 712                 case 2: {
 713                         switch (this->output_bytes_per_sample) {
 714                         case 2: {
 715                                 // 16bit audio -> 16bit audio
 716                                 gint16 *read_ptr = (gint16 *) (((char *) current_frame->frame->buffer) + current_frame->bytes_used);
 717
 718                                 for (guint32 i = 0; i < frames_to_write; i++) {
 719                                         for (guint32 channel = 0; channel < channels; channel++) {
 720                                                 value = ((*read_ptr) * volumes [channel]) >> 13;
 721                                                 *(write_ptr [channel]) = (gint16) CLAMP (value, -32768, 32767);
 722                                                 write_ptr [channel] = (gint16 *) (((char *) write_ptr [channel]) + channel_data [channel]->distance);
 723                                                 read_ptr++;
 724                                         }
 725                                 }
 726                                 break;
 727                         }
 728                         default: // implement others as needed
 729                                 LOG_AUDIO ("AudioSource::Write (): Invalid output_bytes_per_sample, expected 2, got: %i\n", this->output_bytes_per_sample);
 730                                 break;
 731                         }
 732                         break;
 733                 }
 734                 case 3: {
 735                         switch (this->output_bytes_per_sample) {
 736                         case 2: {
 737                                 // 24bit audio -> 16bit audio
 738                                 gint16 *read_ptr = (gint16 *) (((char *) current_frame->frame->buffer) + current_frame->bytes_used);
 739
 740                                 for (guint32 i = 0; i < frames_to_write; i++) {
 741                                         for (guint32 channel = 0; channel < channels; channel++) {
 742                                                 read_ptr = (gint16 *) (((gint8 *) read_ptr) + 1); // +1 byte
 743                                                 value = *read_ptr;
 744                                                 value = (gint16) CLAMP (((value * volumes [channel]) >> 13), -32768, 32767);
 745                                                 *write_ptr [channel] = value;
 746                                                 write_ptr [channel] = (gint16 *) (((char *) write_ptr [channel]) + channel_data [channel]->distance);
 747                                                 read_ptr += 1; // +2 bytes
 748                                         }
 749                                 }
 750                                 break;
 751                         }
 752                         // case 3: // 24bit audio -> 24bit audio, this is painful to both read and write.
 753                         case 4: {
 754                                 // 24bit audio -> 32bit audio
 755                                 gint32 *read_ptr = (gint32 *) (((char *) current_frame->frame->buffer) + current_frame->bytes_used);
 756
 757                                 for (guint32 i = 0; i < frames_to_write; i++) {
 758                                         for (guint32 channel = 0; channel < channels; channel++) {
 759                                                 if (false && i > 0) {
 760                                                         // can overread before, mask out the upper bits.
 761                                                         value = * (gint32 *) (((gint8 *) read_ptr) - 1);
 762                                                         value &= 0xFFFFFF00;
 763                                                 } else {
 764                                                         // can't overread before, use byte pointers
 765                                                         value = 0;
 766                                                         ((guint8 *) &value) [1] = (((guint8 *) read_ptr) [0]);
 767                                                         ((guint8 *) &value) [2] = (((guint8 *) read_ptr) [1]);
 768                                                         ((guint8 *) &value) [3] = (((guint8 *) read_ptr) [2]);
 769                                                 }
 770                                                 // not sure how to calculate volume here, this shifts down 13 bits
 771                                                 // and then multiply with volume. This loses the lowest 5 bits of information
 772                                                 // from the 24 bit sample. Not quite sure how to do this with 32bit math without
 773                                                 // losing information though.
 774                                                 value = (value >> 13) * (volumes [channel]);
 775                                                 *((gint32 *) write_ptr [channel]) = value;
 776                                                 write_ptr [channel] = (gint16 *) (((char *) write_ptr [channel]) + channel_data [channel]->distance);
 777                                                 read_ptr = (gint32 *) (((gint8 *) read_ptr) + 3); // += input_bytes_per_sample;
 778                                         }
 779                                 }
 780                                 break;
 781                         }
 782                         default: // implement others as needed
 783                                 LOG_AUDIO ("AudioSource::Write (): Invalid output_bytes_per_sample, expected 2 or 4, got: %i\n", this->output_bytes_per_sample);
 784                                 break;
 785                         }
 786                         break;
 787                 }
 788                 default:
 789                         LOG_AUDIO ("AudioSource::Write (): Invalid input_bytes_per_sample, can only be 2 or 3, but got: %i\n", this->input_bytes_per_sample);
 790                         SetState (AudioError);
 791                         break;
 792                 }
 793
 794                 result += frames_to_write;
 795                 current_frame->bytes_used += bytes_written;
 796
 797                 last_frame_samples = current_frame->bytes_used / GetInputBytesPerFrame ();
 798                 last_frame_pts = current_frame->frame->pts;
 799
 800                 if (current_frame->bytes_used == current_frame->frame->buflen) {
 801                         // We used the entire packet
 802                         delete current_frame;
 803                         current_frame = NULL;
 804                 } else {
 805                         // There is still audio data left in the packet, just leave it.
 806                 }
 807
 808                 if (result == samples) {
 809                         // We've written all we were requested to write
 810                         goto cleanup;
 811                 } else {
 812                         //printf ("AudioSource::WriteFull (): Written %u samples of %u requested samples, getting new packet (%i packets left)\n", result, samples, frames.Length ());
 813                 }
 814         }
 815
 816 cleanup:
 817         LOG_AUDIO_EX ("AudioSource::WriteFull (%p, %u): Wrote %u samples, current pts: %" G_GUINT64_FORMAT ", volume: %.2f\n", channel_data, samples, result, MilliSeconds_FromPts (GetCurrentPts ()), this->volume);
 818
 819         if (result > 0) {
 820                 last_write_pts = last_frame_pts + MilliSeconds_ToPts (last_frame_samples * 1000 / GetSampleRate ());
 821         }
 822
 823         Unlock ();
 824
 825         if (stream)
 826                 stream->unref ();
 827
 828         return result;
 829 }
 830
 831 /*
 832  * AudioListNode
 833  */
 834
 835 AudioListNode::AudioListNode (AudioSource *source)
 836 {
 837         this->source = source;
 838         this->source->ref ();
 839         generation = 0;
 840 }
 841
 842 AudioListNode::~AudioListNode ()
 843 {
 844         this->source->unref ();
 845 }
 846
 847 /*
 848  * AudioSources
 849  */
 850
 851 AudioSources::AudioSources ()
 852 {
 853         pthread_mutex_init (&mutex, NULL);
 854         current_generation = 0;
 855 }
 856
 857 AudioSources::~AudioSources ()
 858 {
 859         pthread_mutex_destroy (&mutex);
 860 }
 861
 862 void
 863 AudioSources::Lock ()
 864 {
 865         pthread_mutex_lock (&mutex);
 866 }
 867
 868 void
 869 AudioSources::Unlock ()
 870 {
 871         pthread_mutex_unlock (&mutex);
 872 }
 873
 874 void
 875 AudioSources::Add (AudioSource *source)
 876 {
 877         Lock ();
 878         list.Append (new AudioListNode (source));
 879         Unlock ();
 880 }
 881
 882 bool
 883 AudioSources::Remove (AudioSource *source)
 884 {
 885         AudioListNode *node;
 886         bool result = false;
 887
 888         Lock ();
 889         node = (AudioListNode *) list.First ();
 890         while (node != NULL) {
 891                 if (node->source == source) {
 892                         result = true;
 893                         if (last_node == node)
 894                                 last_node = (AudioListNode *) node->prev;
 895                         list.Remove (node);
 896                         source->unref ();
 897                         break;
 898                 }
 899                 node = (AudioListNode *) node->next;
 900         }
 901         last_node = NULL;
 902         Unlock ();
 903
 904         return result;
 905 }
 906
 907 void
 908 AudioSources::StartEnumeration ()
 909 {
 910         Lock ();
 911         current_generation++;
 912         last_node = NULL;
 913         Unlock ();
 914 }
 915
 916 AudioSource *
 917 AudioSources::GetNext (bool only_playing)
 918 {
 919         AudioListNode *node = NULL;
 920         AudioSource *result = NULL;
 921
 922         Lock ();
 923
 924         // Check the last node returned from GetNext
 925         if (last_node != NULL && last_node->next != NULL) {
 926                 node = (AudioListNode *) last_node->next;
 927                 if (node->generation != current_generation && (!only_playing || node->source->IsPlaying ()))
 928                         goto cleanup;
 929         }
 930
 931         // Loop through all the nodes looking for a node not in the
 932         // current generation.
 933         node = (AudioListNode *) list.First ();
 934         while (node != NULL && (node->generation == current_generation || (only_playing && !node->source->IsPlaying ()))) {
 935                 node = (AudioListNode *) node->next;
 936         }
 937
 938         // Its possible that the loop has started but nothing is playing, which without this guard would
 939         // return list.First () in an infinite loop while we're downloading / buffering.
 940         // (due to the while loop above not clearing out the first value (list.First ()) if the condition is false and there's no other
 941         // node which satifies the condition)
 942         if (only_playing && node != NULL && !node->source->IsPlaying ())
 943                 node = NULL;
 944
 945 cleanup:
 946         if (node) {
 947                 node->generation = current_generation;
 948                 last_node = node;
 949                 result = node->source;
 950                 result->SetCurrentDeployment (false);
 951                 result->ref ();
 952         } else {
 953                 Deployment::SetCurrent (NULL, false);
 954         }
 955
 956         Unlock ();
 957
 958         return result;
 959 }
 960
 961 AudioSource *
 962 AudioSources::GetHead ()
 963 {
 964         AudioSource *result = NULL;
 965         AudioListNode *node;
 966
 967         Lock ();
 968
 969         node = (AudioListNode *) list.First ();
 970         if (node != NULL) {
 971                 result = node->source;
 972                 result->SetCurrentDeployment (false);
 973                 result->ref ();
 974         }
 975
 976         Unlock ();
 977
 978         return result;
 979 }
 980
 981 #if DEBUG
 982 int
 983 AudioSources::Length ()
 984 {
 985         int result = 0;
 986
 987         Lock ();
 988         result = list.Length ();
 989         Unlock ();
 990
 991         return result;
 992 }
 993 #endif
 994
 995 /*
 996  * AudioPlayer
 997  */
 998
 999 AudioPlayer * AudioPlayer::instance = NULL;
1000 pthread_mutex_t AudioPlayer::instance_mutex = PTHREAD_MUTEX_INITIALIZER;
1001
1002 AudioPlayer::AudioPlayer ()
1003 {
1004         refcount = 1;
1005 }
1006
1007 void
1008 AudioPlayer::ref ()
1009 {
1010         g_atomic_int_inc (&refcount);
1011 }
1012
1013 void
1014 AudioPlayer::unref ()
1015 {
1016         int v = g_atomic_int_exchange_and_add (&refcount, -1) - 1;
1017
1018         if (v == 0) {
1019                 Dispose ();
1020                 delete this;
1021         }
1022 }
1023
1024 AudioPlayer *
1025 AudioPlayer::GetInstance ()
1026 {
1027         AudioPlayer *result;
1028         pthread_mutex_lock (&instance_mutex);
1029         result = instance;
1030         if (result)
1031                 result->ref ();
1032         pthread_mutex_unlock (&instance_mutex);
1033         return result;
1034 }
1035
1036 AudioSource *
1037 AudioPlayer::Add (MediaPlayer *mplayer, AudioStream *stream)
1038 {
1039         AudioPlayer *inst;
1040         AudioSource *result = NULL;
1041
1042         LOG_AUDIO ("AudioPlayer::Add (%p)\n", mplayer);
1043
1044         if (moonlight_flags & RUNTIME_INIT_DISABLE_AUDIO) {
1045                 LOG_AUDIO ("AudioPlayer: audio is disabled.\n");
1046                 return NULL;
1047         }
1048
1049         pthread_mutex_lock (&instance_mutex);
1050         if (instance == NULL) {
1051                 /* here we get a (global) ref which is unreffed in Shutdown () */
1052                 instance = CreatePlayer ();
1053         }
1054         inst = instance;
1055         if (inst)
1056                 inst->ref (); /* this is the ref we unref below */
1057         pthread_mutex_unlock (&instance_mutex);
1058
1059         if (inst != NULL) {
1060                 result = inst->AddImpl (mplayer, stream);
1061                 inst->unref ();
1062         }
1063
1064         return result;
1065 }
1066
1067 void
1068 AudioPlayer::Remove (AudioSource *source)
1069 {
1070         AudioPlayer *inst;
1071
1072         LOG_AUDIO ("AudioPlayer::Remove (%p)\n", source);
1073
1074         inst = GetInstance ();
1075         if (inst != NULL) {
1076                 inst->RemoveImpl (source);
1077                 inst->unref ();
1078         }
1079 }
1080
1081 void
1082 AudioPlayer::Shutdown ()
1083 {
1084         AudioPlayer *player = NULL;
1085
1086         LOG_AUDIO ("AudioPlayer::Shutdown ()\n");
1087
1088         pthread_mutex_lock (&instance_mutex);
1089         if (instance != NULL) {
1090                 player = instance;
1091                 instance = NULL;
1092         }
1093         pthread_mutex_unlock (&instance_mutex);
1094
1095         if (player != NULL)
1096                 player->unref ();
1097 }
1098
1099 AudioPlayer *
1100 AudioPlayer::CreatePlayer ()
1101 {
1102         bool overridden;
1103         AudioPlayer *result = NULL;
1104
1105         // If any of the flags are specified, we disable all players
1106         // and re-enable according to the flag.
1107
1108         overridden  = moonlight_flags & (RUNTIME_INIT_AUDIO_PULSE | RUNTIME_INIT_AUDIO_ALSA | RUNTIME_INIT_AUDIO_ALSA_MMAP | RUNTIME_INIT_AUDIO_ALSA_RW);
1109
1110 #if INCLUDE_PULSEAUDIO
1111         if (result != NULL) {
1112                 LOG_AUDIO ("AudioPlayer: Not checking for PulseAudio support, we already found support for another configuration.\n");
1113         } else if (overridden && !(moonlight_flags & RUNTIME_INIT_AUDIO_PULSE)) {
1114                 LOG_AUDIO ("AudioPlayer: PulseAudio disabled with environment variable (MOONLIGHT_OVERRIDES)\n");
1115         } else if (!PulsePlayer::IsInstalled ()) {
1116                 LOG_AUDIO ("AudioPlayer: PulseAudio is not installed or configured correctly.\n");
1117         } else {
1118                 printf ("AudioPlayer: Using PulseAudio.\n");
1119                 result = new PulsePlayer ();
1120         }
1121
1122         if (result != NULL) {
1123                 if (!result->Initialize ()) {
1124                         LOG_AUDIO ("AudioPlayer: Failed initialization.\n");
1125                         result->unref ();
1126                         result = NULL;
1127                 } else {
1128                         return result;
1129                 }
1130         }
1131 #else
1132         LOG_AUDIO ("AudioPlayer: Built without support for pulseaudio.\n");
1133 #endif
1134
1135 #if INCLUDE_ALSA
1136         if (result != NULL) {
1137                 LOG_AUDIO ("AudioPlayer: Not checking for Alsa support, we already found support for another configuration.\n");
1138         } else if (overridden && !(moonlight_flags & (RUNTIME_INIT_AUDIO_ALSA | RUNTIME_INIT_AUDIO_ALSA_MMAP | RUNTIME_INIT_AUDIO_ALSA_RW))) {
1139                 LOG_AUDIO ("AudioPlayer: Alsa disabled with environment variable (MOONLIGHT_OVERRIDES)\n");
1140         } else if (!AlsaPlayer::IsInstalled ()) {
1141                 LOG_AUDIO ("AudioPlayer: Alsa is not installed or configured correctly.\n");
1142         } else {
1143                 printf ("AudioPlayer: Using Alsa.\n");
1144                 result = new AlsaPlayer ();
1145         }
1146
1147         if (result != NULL) {
1148                 if (!result->Initialize ()) {
1149                         LOG_AUDIO ("AudioPlayer: Failed initialization.\n");
1150                         result->unref ();
1151                         result = NULL;
1152                 } else {
1153                         return result;
1154                 }
1155         }
1156 #else
1157         LOG_AUDIO ("AudioPlayer: Built without support for alsa.\n");
1158 #endif
1159
1160         return result;
1161 }
1162
1163 AudioSource *
1164 AudioPlayer::AddImpl (MediaPlayer *mplayer, AudioStream *stream)
1165 {
1166         AudioSource *result = CreateNode (mplayer, stream);
1167
1168         if (result->Initialize ()) {
1169                 sources.Add (result);
1170                 AddInternal (result);
1171         } else {
1172                 result->unref ();
1173                 result = NULL;
1174         }
1175
1176         return result;
1177 }
1178
1179 void
1180 AudioPlayer::RemoveImpl (AudioSource *node)
1181 {
1182         node->ref ();
1183         if (sources.Remove (node)) {
1184                 RemoveInternal (node);
1185                 node->Close ();
1186         }
1187         node->unref ();
1188 }
1189
1190 void
1191 AudioPlayer::Dispose ()
1192 {
1193         ShutdownImpl ();
1194 }
1195
1196 void
1197 AudioPlayer::ShutdownImpl ()
1198 {
1199         AudioSource *source;
1200
1201         PrepareShutdownInternal ();
1202
1203         // Remove all the sources.
1204         while ((source = sources.GetHead ()) != NULL) {
1205                 RemoveImpl (source);
1206                 source->unref ();
1207         }
1208
1209         FinishShutdownInternal ();
1210 }