content/media/video/src/nsOggDecoder.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent: */
   3 /* ***** BEGIN LICENSE BLOCK *****
   4  * Version: ML 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Mozilla code.
  17  *
  18  * The Initial Developer of the Original Code is the Mozilla Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 2007
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *  Chris Double <chris.double@double.co.nz>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38 #include "prlog.h"
  39 #include "prmem.h"
  40 #include "nsIFrame.h"
  41 #include "nsIDocument.h"
  42 #include "nsThreadUtils.h"
  43 #include "nsIDOMHTMLMediaElement.h"
  44 #include "nsNetUtil.h"
  45 #include "nsAudioStream.h"
  46 #include "nsChannelReader.h"
  47 #include "nsHTMLVideoElement.h"
  48 #include "nsIObserver.h"
  49 #include "nsIObserverService.h"
  50 #include "nsAutoLock.h"
  51 #include "nsIRenderingContext.h"
  52 #include "gfxContext.h"
  53 #include "gfxImageSurface.h"
  54 #include "nsPresContext.h"
  55 #include "nsOggDecoder.h"
  56
  57 /*
  58    The maximum height and width of the video. Used for
  59    sanitizing the memory allocation of the RGB buffer
  60 */
  61 #define MAX_VIDEO_WIDTH  2000
  62 #define MAX_VIDEO_HEIGHT 2000
  63
  64 // The number of entries in oggplay buffer list. This value
  65 // is the one used by the oggplay examples.
  66 #define OGGPLAY_BUFFER_SIZE 20
  67
  68 // The number of frames to read before audio callback is called.
  69 // This value is the one used by the oggplay examples.
  70 #define OGGPLAY_FRAMES_PER_CALLBACK 2048
  71
  72 // Offset into Ogg buffer containing audio information. This value
  73 // is the one used by the oggplay examples.
  74 #define OGGPLAY_AUDIO_OFFSET 250L
  75
  76 // Maximum mumber of milliseconds to pause while buffering video data
  77 // on a slow connection. The DATA_WAIT is used to compute the maximum
  78 // amount of data to wait for based on the current bytes/second
  79 // download rate. The TIME_WAIT is the total maximum time to wait in
  80 // case the bytes/second rate slows down.
  81 #define MAX_BUFFERING_DATA_WAIT_MS 15000
  82 #define MAX_BUFFERING_TIME_WAIT_MS 30000
  83
  84 // An Event that uses an nsOggDecoder object. It provides a
  85 // way to inform the event that the decoder object is no longer
  86 // valid, so queued events can safely ignore it.
  87 class nsDecoderEvent : public nsRunnable {
  88 public:
  89   nsDecoderEvent(nsOggDecoder* decoder) :
  90     mLock(nsnull),
  91     mDecoder(decoder)
  92   {
  93   }
  94
  95   PRBool Init()
  96   {
  97     mLock = PR_NewLock();
  98     return mLock != nsnull;
  99   }
 100
 101   virtual ~nsDecoderEvent()
 102   {
 103     if (mLock) {
 104       PR_DestroyLock(mLock);
 105       mLock = nsnull;
 106     }
 107   }
 108
 109   void Revoke()
 110   {
 111     nsAutoLock lock(mLock);
 112     mDecoder = nsnull;
 113   }
 114
 115   void Lock()
 116   {
 117     PR_Lock(mLock);
 118   }
 119
 120   void Unlock()
 121   {
 122     PR_Unlock(mLock);
 123   }
 124
 125   NS_IMETHOD Run() {
 126     nsAutoLock lock(mLock);
 127     return RunWithLock();
 128   }
 129
 130 protected:
 131   virtual nsresult RunWithLock() = 0;
 132
 133   PRLock* mLock;
 134   nsOggDecoder* mDecoder;
 135 };
 136
 137 // This handles the Ogg decoding loop. It blocks waiting for
 138 // ogg data, decodes that data, and then goes back to blocking.
 139 // It is synchronised with the nsVideoPresentationEvent internally
 140 // by OggPlay so that it doesn't go to far ahead or behind the
 141 // display of the video frame data.
 142 class nsVideoDecodeEvent : public nsDecoderEvent
 143 {
 144 public:
 145   nsVideoDecodeEvent(nsOggDecoder* decoder) :
 146     nsDecoderEvent(decoder)
 147   {
 148   }
 149
 150 protected:
 151   nsresult RunWithLock()
 152   {
 153     if (mDecoder && mDecoder->StepDecoding()) {
 154       NS_GetCurrentThread()->Dispatch(this, NS_DISPATCH_NORMAL);
 155     }
 156     else {
 157       LOG(PR_LOG_DEBUG, ("Decoding thread completed"));
 158     }
 159     return NS_OK;
 160   }
 161
 162 private:
 163   // PR_TRUE if we are actively decoding
 164   PRPackedBool mDecoding;
 165 };
 166
 167 class nsVideoPresentationEvent : public nsDecoderEvent
 168 {
 169 public:
 170   nsVideoPresentationEvent(nsOggDecoder* decoder) :
 171     nsDecoderEvent(decoder)
 172   {
 173   }
 174
 175   // Stop the invalidation timer. When we aren't decoding
 176   // video frames we stop the timer since it takes a fair
 177   // amount of CPU on some platforms.
 178   void StopInvalidating()
 179   {
 180     if (mDecoder) {
 181       // Stop the invalidation timer
 182       nsCOMPtr<nsIRunnable> event =
 183         NS_NEW_RUNNABLE_METHOD(nsOggDecoder, mDecoder, StopInvalidating);
 184
 185       if (event) {
 186         NS_DispatchToMainThread(event, NS_DISPATCH_NORMAL);
 187       }
 188     }
 189   }
 190
 191   nsresult RunWithLock() {
 192     if (mDecoder && !mDecoder->IsPaused() && mDecoder->StepDisplay()) {
 193       NS_GetCurrentThread()->Dispatch(this, NS_DISPATCH_NORMAL);
 194     }
 195     else {
 196       LOG(PR_LOG_DEBUG, ("Presentation thread completed"));
 197       StopInvalidating();
 198     }
 199     return NS_OK;
 200   }
 201 };
 202
 203 NS_IMPL_THREADSAFE_ISUPPORTS1(nsOggDecoder, nsIObserver)
 204
 205 void nsOggDecoder::Pause()
 206 {
 207   if (!mPresentationThread)
 208     return;
 209
 210   mPaused = PR_TRUE;
 211   nsCOMPtr<nsIRunnable> event =
 212     NS_NEW_RUNNABLE_METHOD(nsOggDecoder, this, DoPause);
 213   if (event)
 214     mPresentationThread->Dispatch(event, NS_DISPATCH_NORMAL);
 215 }
 216
 217 void nsOggDecoder::DoPause()
 218 {
 219   mPaused = PR_TRUE;
 220   if (mAudioStream) {
 221     mAudioStream->Pause();
 222   }
 223   mSystemSyncSeconds = double(PR_IntervalToMilliseconds(PR_IntervalNow()))/1000.0;
 224 }
 225
 226 float nsOggDecoder::GetVolume()
 227 {
 228   float volume = 0.0;
 229   if (mAudioStream) {
 230     mAudioStream->GetVolume(&volume);
 231   }
 232   else {
 233     volume = mInitialVolume;
 234   }
 235
 236   return volume;
 237 }
 238
 239 void nsOggDecoder::SetVolume(float volume)
 240 {
 241   if (mAudioStream) {
 242     mAudioStream->SetVolume(volume);
 243   }
 244   else {
 245     mInitialVolume = volume;
 246   }
 247 }
 248
 249 float nsOggDecoder::GetDuration()
 250 {
 251   // Currently not implemented. Video Spec says to return
 252   // NaN if unknown.
 253   // TODO: return NaN
 254   return 0.0;
 255 }
 256
 257 nsOggDecoder::nsOggDecoder() :
 258   nsVideoDecoder(),
 259   mBytesDownloaded(0),
 260   mVideoNextFrameTime(0.0),
 261   mLoadInProgress(PR_FALSE),
 262   mPlayAfterLoad(PR_FALSE),
 263   mNotifyOnShutdown(PR_FALSE),
 264   mVideoCurrentFrameTime(0.0),
 265   mInitialVolume(1.0),
 266   mAudioRate(0),
 267   mAudioChannels(0),
 268   mAudioTrack(-1),
 269   mVideoTrack(-1),
 270   mPlayer(0),
 271   mReader(0),
 272   mPaused(PR_TRUE),
 273   mFirstFrameLoaded(PR_FALSE),
 274   mFirstFrameCondVar(nsnull),
 275   mFirstFrameLock(nsnull),
 276   mSystemSyncSeconds(0.0),
 277   mResourceLoaded(PR_FALSE),
 278   mMetadataLoaded(PR_FALSE)
 279 {
 280 }
 281
 282 PRBool nsOggDecoder::Init()
 283 {
 284   mFirstFrameLock = PR_NewLock();
 285   mFirstFrameCondVar = mFirstFrameLock ? PR_NewCondVar(mFirstFrameLock) : nsnull ;
 286
 287   mDecodeEvent = new nsVideoDecodeEvent(this);
 288   mPresentationEvent = new nsVideoPresentationEvent(this);
 289
 290   return mFirstFrameLock &&
 291     mFirstFrameCondVar &&
 292     mDecodeEvent && mDecodeEvent->Init() &&
 293     mPresentationEvent && mPresentationEvent->Init() &&
 294     nsVideoDecoder::Init();
 295 }
 296
 297 void nsOggDecoder::Shutdown()
 298 {
 299   if (mDecodeEvent) {
 300     // Must prepare oggplay for close to stop the decode event from
 301     // waiting on oggplay's semaphore. Without this, revoke deadlocks.
 302     if (mPlayer) {
 303       oggplay_prepare_for_close(mPlayer);
 304     }
 305
 306     mDecodeEvent->Revoke();
 307     mDecodeEvent = nsnull;
 308   }
 309   if (mPresentationEvent) {
 310     mPresentationEvent->Revoke();
 311     mPresentationEvent = nsnull;
 312   }
 313
 314   Stop();
 315   nsVideoDecoder::Shutdown();
 316 }
 317
 318 nsOggDecoder::~nsOggDecoder()
 319 {
 320   Shutdown();
 321   if (mFirstFrameCondVar) {
 322     PR_DestroyCondVar(mFirstFrameCondVar);
 323     mFirstFrameCondVar = nsnull;
 324   }
 325   if (mFirstFrameLock) {
 326     PR_DestroyLock(mFirstFrameLock);
 327     mFirstFrameLock = nsnull;
 328   }
 329 }
 330
 331 nsIntSize nsOggDecoder::GetVideoSize(nsIntSize defaultSize)
 332 {
 333   return (mRGBWidth == -1 || mRGBHeight == -1) ? defaultSize : nsIntSize(mRGBWidth, mRGBHeight);
 334 }
 335
 336 double nsOggDecoder::GetVideoFramerate() {
 337   return mFramerate;
 338 }
 339
 340 PRBool nsOggDecoder::IsPaused()
 341 {
 342   return mPaused;
 343 }
 344
 345 PRBool nsOggDecoder::StepDecoding()
 346 {
 347   PRBool stop = PR_TRUE;
 348   if (mPlayer && mDecodeThread) {
 349     OggPlayErrorCode r = oggplay_step_decoding(mPlayer);
 350     if (r != E_OGGPLAY_CONTINUE &&
 351         r != E_OGGPLAY_USER_INTERRUPT &&
 352         r != E_OGGPLAY_TIMEOUT) {
 353       stop = PR_TRUE;
 354       // Inform the element that we've ended the video
 355       nsCOMPtr<nsIRunnable> event =
 356         NS_NEW_RUNNABLE_METHOD(nsOggDecoder, this, PlaybackCompleted);
 357
 358       if (event) {
 359         NS_DispatchToMainThread(event, NS_DISPATCH_NORMAL);
 360       }
 361     }
 362     else {
 363       stop = PR_FALSE;
 364
 365       if (r == E_OGGPLAY_CONTINUE)
 366         BufferData();
 367     }
 368   }
 369   return !stop;
 370 }
 371
 372 void nsOggDecoder::BufferData()
 373 {
 374   if (!mPaused && mReader && mMetadataLoaded && !mResourceLoaded) {
 375     double bps = mReader->BytesPerSecond();
 376     PRUint32 bytes = static_cast<PRUint32>((bps * MAX_BUFFERING_DATA_WAIT_MS)/1000.0);
 377
 378     // Buffer if it looks like we'll starve for data during
 379     // MAX_BUFFERING_DATA_WAIT_MS time period.
 380     if (mReader->Available() < bytes) {
 381       PRIntervalTime start = PR_IntervalNow();
 382       if (mElement) {
 383         nsCOMPtr<nsIRunnable> event =
 384           NS_NEW_RUNNABLE_METHOD(nsOggDecoder, this, BufferingStarted);
 385         if (event)
 386           // The pause event must be processed before the
 387           // buffering loop occurs. Otherwise the loop exits
 388           // immediately as it checks to see if the user chose
 389           // to unpause.
 390           NS_DispatchToMainThread(event, NS_DISPATCH_SYNC);
 391       }
 392
 393       // Sleep to allow more data to be downloaded. Note that we are
 394       // sleeping the decode thread, not the main thread. We stop
 395       // sleeping when the resource is completely loaded, or the user
 396       // explicitly chooses to continue playing, or an arbitary time
 397       // period has elapsed or we've downloaded enough bytes to
 398       // continue playing at the current download rate.
 399       while (!mResourceLoaded &&
 400              mPaused &&
 401              (PR_IntervalToMilliseconds(PR_IntervalNow() - start) < MAX_BUFFERING_TIME_WAIT_MS) &&
 402              mReader->Available() < bytes) {
 403         LOG(PR_LOG_DEBUG,
 404             ("Buffering data until %d bytes available or %d milliseconds",
 405              (long)(bytes - mReader->Available()),
 406              MAX_BUFFERING_TIME_WAIT_MS - (PR_IntervalToMilliseconds(PR_IntervalNow() - start))));
 407
 408         PR_Sleep(PR_MillisecondsToInterval(1000));
 409
 410         bps = mReader->BytesPerSecond();
 411         bytes = static_cast<PRUint32>((bps * (MAX_BUFFERING_DATA_WAIT_MS))/1000.0);
 412       }
 413
 414       if (mElement) {
 415         nsCOMPtr<nsIRunnable> event =
 416           NS_NEW_RUNNABLE_METHOD(nsOggDecoder, this, BufferingStopped);
 417         if (event)
 418           NS_DispatchToMainThread(event, NS_DISPATCH_NORMAL);
 419       }
 420     }
 421   }
 422 }
 423
 424 nsresult nsOggDecoder::Load(nsIURI* aURI)
 425 {
 426   nsresult rv;
 427   Stop();
 428   mURI = aURI;
 429
 430   mReader = new nsChannelReader();
 431   NS_ENSURE_TRUE(mReader, NS_ERROR_OUT_OF_MEMORY);
 432
 433   rv = mReader->Init(this, aURI);
 434   NS_ENSURE_SUCCESS(rv, rv);
 435
 436   rv = NS_NewThread(getter_AddRefs(mDecodeThread));
 437   NS_ENSURE_SUCCESS(rv, rv);
 438   rv = NS_NewThread(getter_AddRefs(mPresentationThread));
 439   NS_ENSURE_SUCCESS(rv, rv);
 440
 441   mLoadInProgress = PR_TRUE;
 442   nsCOMPtr<nsIRunnable> event =
 443     NS_NEW_RUNNABLE_METHOD(nsOggDecoder, this, LoadOggHeaders);
 444   NS_ENSURE_TRUE(event, NS_ERROR_OUT_OF_MEMORY);
 445
 446   rv = mDecodeThread->Dispatch(event, NS_DISPATCH_NORMAL);
 447   NS_ENSURE_SUCCESS(rv, rv);
 448
 449   StartProgress();
 450
 451   return NS_OK;
 452 }
 453
 454 nsresult nsOggDecoder::Play()
 455 {
 456   mPaused = PR_FALSE;
 457   if (mLoadInProgress) {
 458     mPlayAfterLoad = PR_TRUE;
 459     return NS_OK;
 460   }
 461   else if (!mPlayer) {
 462     Load(mURI);
 463   }
 464   else {
 465     StartPlaybackThreads();
 466   }
 467
 468   if (!mNotifyOnShutdown) {
 469     nsCOMPtr<nsIObserverService> observerService =
 470       do_GetService("@mozilla.org/observer-service;1");
 471     if (observerService) {
 472       mNotifyOnShutdown =
 473         NS_SUCCEEDED(observerService->AddObserver(this,
 474                                                   NS_XPCOM_SHUTDOWN_OBSERVER_ID,
 475                                                   PR_FALSE));
 476     }
 477     else {
 478       NS_WARNING("Could not get an observer service. Video decoding events may not shutdown cleanly.");
 479     }
 480   }
 481
 482   return NS_OK;
 483 }
 484
 485 nsresult nsOggDecoder::Seek(float time)
 486 {
 487   return NS_ERROR_NOT_IMPLEMENTED;
 488 }
 489
 490 nsresult nsOggDecoder::PlaybackRateChanged()
 491 {
 492   return NS_ERROR_NOT_IMPLEMENTED;
 493 }
 494
 495 void nsOggDecoder::Stop()
 496 {
 497   mLoadInProgress = PR_FALSE;
 498   StopInvalidating();
 499   StopProgress();
 500   if (mDecodeThread) {
 501     if (mPlayer) {
 502       oggplay_prepare_for_close(mPlayer);
 503     }
 504     mDecodeThread->Shutdown();
 505     mDecodeThread = nsnull;
 506   }
 507   if (mPresentationThread) {
 508     if (!mFirstFrameLoaded) {
 509       nsAutoLock lock(mFirstFrameLock);
 510       mFirstFrameLoaded = PR_TRUE;
 511       PR_NotifyAllCondVar(mFirstFrameCondVar);
 512     }
 513
 514     mPresentationThread->Shutdown();
 515     mPresentationThread = nsnull;
 516   }
 517   CloseAudioStream();
 518   if (mPlayer){
 519     oggplay_close(mPlayer);
 520     mPlayer = nsnull;
 521   }
 522   mPaused = PR_TRUE;
 523   mVideoCurrentFrameTime = 0.0;
 524
 525   if (mNotifyOnShutdown) {
 526     nsCOMPtr<nsIObserverService> observerService =
 527       do_GetService("@mozilla.org/observer-service;1");
 528     if (observerService) {
 529       mNotifyOnShutdown = PR_FALSE;
 530       observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
 531     }
 532   }
 533 }
 534
 535 void nsOggDecoder::HandleVideoData(int track_num, OggPlayVideoData* video_data) {
 536   int y_width;
 537   int y_height;
 538   oggplay_get_video_y_size(mPlayer, track_num, &y_width, &y_height);
 539
 540   int uv_width;
 541   int uv_height;
 542   oggplay_get_video_uv_size(mPlayer, track_num, &uv_width, &uv_height);
 543
 544   if (y_width >= MAX_VIDEO_WIDTH || y_height >= MAX_VIDEO_HEIGHT)
 545     return;
 546
 547   {
 548     nsAutoLock lock(mVideoUpdateLock);
 549
 550     SetRGBData(y_width, y_height, mFramerate, nsnull);
 551
 552     // If there is not enough memory to allocate the RGB buffer,
 553     // don't display it, but continue without error. When enough
 554     // memory is available the display will start working again.
 555     if (mRGB) {
 556       OggPlayYUVChannels yuv;
 557       OggPlayRGBChannels rgb;
 558
 559       yuv.ptry = video_data->y;
 560       yuv.ptru = video_data->u;
 561       yuv.ptrv = video_data->v;
 562       yuv.uv_width = uv_width;
 563       yuv.uv_height = uv_height;
 564       yuv.y_width = y_width;
 565       yuv.y_height = y_height;
 566
 567       rgb.ptro = mRGB.get();
 568       rgb.rgb_width = mRGBWidth;
 569       rgb.rgb_height = mRGBHeight;
 570
 571       oggplay_yuv2bgr(&yuv, &rgb);
 572     }
 573   }
 574 }
 575
 576 void nsOggDecoder::HandleAudioData(OggPlayAudioData* audio_data, int size) {
 577   if (mAudioStream) {
 578     // 'size' is number of samples. Multiply by number of channels
 579     // to get the actual number of floats being sent.
 580     nsresult rv = mAudioStream->Write(reinterpret_cast<float*>(audio_data), size * mAudioChannels);
 581     if (!NS_SUCCEEDED(rv)) {
 582       LOG(PR_LOG_ERROR, ("Could not write audio data to pipe"));
 583     }
 584   }
 585 }
 586
 587 double nsOggDecoder::GetSyncTime()
 588 {
 589   double time = 0.0;
 590   if (mAudioStream && mAudioTrack != -1) {
 591     mAudioStream->GetTime(&time);
 592   }
 593   else {
 594     // No audio stream, or audio track. Sync to system clock.
 595     time =
 596       (mSystemSyncSeconds == 0.0) ?
 597       0.0 :
 598       double(PR_IntervalToMilliseconds(PR_IntervalNow()))/1000.0 - mSystemSyncSeconds;
 599   }
 600
 601   return time;
 602 }
 603
 604 void nsOggDecoder::OpenAudioStream()
 605 {
 606   mAudioStream = new nsAudioStream();
 607   if (!mAudioStream) {
 608     LOG(PR_LOG_ERROR, ("Could not create audio stream"));
 609   }
 610   else {
 611     mAudioStream->Init(mAudioChannels, mAudioRate);
 612     mAudioStream->SetVolume(mInitialVolume);
 613   }
 614 }
 615
 616 void nsOggDecoder::CloseAudioStream()
 617 {
 618   if (mAudioStream) {
 619     mAudioStream->Shutdown();
 620     mAudioStream = nsnull;
 621   }
 622 }
 623
 624 void nsOggDecoder::LoadOggHeaders()
 625 {
 626   LOG(PR_LOG_DEBUG, ("Loading Ogg Headers"));
 627   mPlayer = oggplay_open_with_reader((OggPlayReader*)mReader);
 628   if (mPlayer) {
 629     LOG(PR_LOG_DEBUG, ("There are %d tracks", oggplay_get_num_tracks(mPlayer)));
 630
 631     for (int i = 0; i < oggplay_get_num_tracks(mPlayer); ++i) {
 632       LOG(PR_LOG_DEBUG, ("Tracks %d: %s", i, oggplay_get_track_typename(mPlayer, i)));
 633       if (mVideoTrack == -1 && oggplay_get_track_type(mPlayer, i) == OGGZ_CONTENT_THEORA) {
 634         oggplay_set_callback_num_frames(mPlayer, i, 1);
 635         mVideoTrack = i;
 636         int fpsd, fpsn;
 637         oggplay_get_video_fps(mPlayer, i, &fpsd, &fpsn);
 638         mFramerate = fpsd == 0 ? 0.0 : double(fpsn)/double(fpsd);
 639         LOG(PR_LOG_DEBUG, ("Frame rate: %f", mFramerate));
 640       }
 641       else if (mAudioTrack == -1 && oggplay_get_track_type(mPlayer, i) == OGGZ_CONTENT_VORBIS) {
 642         mAudioTrack = i;
 643         oggplay_set_offset(mPlayer, i, OGGPLAY_AUDIO_OFFSET);
 644         oggplay_get_audio_samplerate(mPlayer, i, &mAudioRate);
 645         oggplay_get_audio_channels(mPlayer, i, &mAudioChannels);
 646         LOG(PR_LOG_DEBUG, ("samplerate: %d, channels: %d", mAudioRate, mAudioChannels));
 647       }
 648
 649       if (oggplay_set_track_active(mPlayer, i) < 0)
 650         LOG(PR_LOG_ERROR, ("Could not set track %d active", i));
 651     }
 652
 653     if (mVideoTrack == -1) {
 654       oggplay_set_callback_num_frames(mPlayer, mAudioTrack, OGGPLAY_FRAMES_PER_CALLBACK);
 655     }
 656
 657     oggplay_use_buffer(mPlayer, OGGPLAY_BUFFER_SIZE);
 658
 659     // Inform the element that we've loaded the Ogg metadata
 660     nsCOMPtr<nsIRunnable> metadataLoadedEvent =
 661       NS_NEW_RUNNABLE_METHOD(nsOggDecoder, this, MetadataLoaded);
 662
 663     if (metadataLoadedEvent) {
 664       NS_DispatchToMainThread(metadataLoadedEvent, NS_DISPATCH_NORMAL);
 665     }
 666
 667     // Load the first frame of data
 668     nsCOMPtr<nsIRunnable> firstFrameEvent =
 669       NS_NEW_RUNNABLE_METHOD(nsOggDecoder, this, LoadFirstFrame);
 670
 671     if (firstFrameEvent) {
 672       NS_GetCurrentThread()->Dispatch(firstFrameEvent, NS_DISPATCH_NORMAL);
 673     }
 674   }
 675 }
 676
 677 // This is always run in the decoder thread
 678 void nsOggDecoder::LoadFirstFrame()
 679 {
 680   if (StepDecoding()) {
 681     // Inform the element that we've loaded the first frame of data
 682     nsCOMPtr<nsIRunnable> frameLoadedEvent =
 683       NS_NEW_RUNNABLE_METHOD(nsOggDecoder, this, FirstFrameLoaded);
 684
 685     if (frameLoadedEvent) {
 686       NS_DispatchToMainThread(frameLoadedEvent, NS_DISPATCH_NORMAL);
 687     }
 688     nsCOMPtr<nsIRunnable> displayEvent =
 689       NS_NEW_RUNNABLE_METHOD(nsOggDecoder, this, DisplayFirstFrame);
 690     if (displayEvent) {
 691       mPresentationThread->Dispatch(displayEvent, NS_DISPATCH_NORMAL);
 692     }
 693
 694     // Notify waiting presentation thread that it can start playing
 695     {
 696       nsAutoLock lock(mFirstFrameLock);
 697
 698       mFirstFrameLoaded = PR_TRUE;
 699       PR_NotifyAllCondVar(mFirstFrameCondVar);
 700     }
 701     mDecodeThread->Dispatch(mDecodeEvent, NS_DISPATCH_NORMAL);
 702   }
 703 }
 704
 705 void nsOggDecoder::StartPresentationThread()
 706 {
 707   {
 708     nsAutoLock lock(mFirstFrameLock);
 709
 710     while (!mFirstFrameLoaded)
 711       PR_WaitCondVar(mFirstFrameCondVar, PR_INTERVAL_NO_TIMEOUT);
 712   }
 713
 714   if (mAudioStream) {
 715     mAudioStream->Resume();
 716   }
 717   else {
 718     OpenAudioStream();
 719   }
 720
 721   mSystemSyncSeconds = double(PR_IntervalToMilliseconds(PR_IntervalNow()))/1000.0;
 722   mPresentationThread->Dispatch(mPresentationEvent, NS_DISPATCH_NORMAL);
 723 }
 724
 725 float nsOggDecoder::GetCurrentTime()
 726 {
 727   return mVideoCurrentFrameTime;
 728 }
 729
 730 void nsOggDecoder::GetCurrentURI(nsIURI** aURI)
 731 {
 732   NS_IF_ADDREF(*aURI = mURI);
 733 }
 734
 735
 736 void nsOggDecoder::DisplayFirstFrame()
 737 {
 738   // Step through the decoded frames, allowing display of the first frame
 739   // of video.
 740   StepDisplay();
 741 }
 742
 743 void nsOggDecoder::ProcessTrack(int aTrackNumber, OggPlayCallbackInfo* aTrackInfo)
 744 {
 745   OggPlayDataType type = oggplay_callback_info_get_type(aTrackInfo);
 746   OggPlayDataHeader ** headers = oggplay_callback_info_get_headers(aTrackInfo);
 747   switch(type) {
 748   case OGGPLAY_INACTIVE:
 749     {
 750       break;
 751     }
 752
 753   case OGGPLAY_YUV_VIDEO:
 754     {
 755       double video_time = ((double)oggplay_callback_info_get_presentation_time(headers[0]))/1000.0;
 756       mVideoCurrentFrameTime = video_time;
 757
 758       OggPlayVideoData* video_data = oggplay_callback_info_get_video_data(headers[0]);
 759       HandleVideoData(aTrackNumber, video_data);
 760     }
 761     break;
 762   case OGGPLAY_FLOATS_AUDIO:
 763     {
 764       int required = oggplay_callback_info_get_required(aTrackInfo);
 765       for (int j = 0; j < required; ++j) {
 766         int size = oggplay_callback_info_get_record_size(headers[j]);
 767         OggPlayAudioData* audio_data = oggplay_callback_info_get_audio_data(headers[j]);
 768         HandleAudioData(audio_data, size);
 769       }
 770       break;
 771     }
 772   case OGGPLAY_CMML:
 773     {
 774       if (oggplay_callback_info_get_required(aTrackInfo) > 0)
 775         LOG(PR_LOG_DEBUG, ("CMML: %s", oggplay_callback_info_get_text_data(headers[0])));
 776       break;
 777     }
 778   default:
 779     break;
 780   }
 781 }
 782
 783 PRBool nsOggDecoder::StepDisplay()
 784 {
 785   if (!mPlayer/* || !mDecodeThread */) {
 786     return PR_FALSE;
 787   }
 788
 789   int num_tracks = oggplay_get_num_tracks(mPlayer);
 790   OggPlayCallbackInfo  ** track_info = oggplay_buffer_retrieve_next(mPlayer);
 791
 792   if (track_info) {
 793    double audio_time = GetSyncTime();
 794     PRInt32 millis = PRInt32((mVideoNextFrameTime-audio_time) * 1000.0);
 795     // LOG(PR_LOG_DEBUG, ("Sleep: %d %f %f", millis, audio_time, mVideoNextFrameTime));
 796     mVideoNextFrameTime += 1.0/mFramerate;
 797
 798     if (millis > 0) {
 799       PR_Sleep(PR_MillisecondsToInterval(millis));
 800     }
 801
 802    if (mVideoTrack != -1 && num_tracks > mVideoTrack)  {
 803       ProcessTrack(mVideoTrack, track_info[mVideoTrack]);
 804    }
 805
 806    if (mAudioTrack != -1 && num_tracks > mAudioTrack) {
 807       ProcessTrack(mAudioTrack, track_info[mAudioTrack]);
 808    }
 809
 810    oggplay_buffer_release(mPlayer, track_info);
 811   }
 812   else {
 813     PR_Sleep(PR_MillisecondsToInterval(10));
 814   }
 815
 816   return PR_TRUE;
 817 }
 818
 819 void nsOggDecoder::StartPlaybackThreads()
 820 {
 821   StartInvalidating(mFramerate);
 822
 823   nsCOMPtr<nsIRunnable> event =
 824     NS_NEW_RUNNABLE_METHOD(nsOggDecoder, this, StartPresentationThread);
 825   if (event)
 826     mPresentationThread->Dispatch(event, NS_DISPATCH_NORMAL);
 827 }
 828
 829 void nsOggDecoder::MetadataLoaded()
 830 {
 831   mMetadataLoaded = PR_TRUE;
 832   if (mElement) {
 833     mElement->MetadataLoaded();
 834   }
 835
 836   if (mPlayAfterLoad) {
 837     mPlayAfterLoad = PR_FALSE;
 838     StartPlaybackThreads();
 839   }
 840   mLoadInProgress = PR_FALSE;
 841 }
 842
 843 void nsOggDecoder::FirstFrameLoaded()
 844 {
 845   StartInvalidating(mFramerate);
 846   if (mElement) {
 847     mElement->FirstFrameLoaded();
 848   }
 849 }
 850
 851 void nsOggDecoder::ResourceLoaded()
 852 {
 853   mResourceLoaded = PR_TRUE;
 854   if (mElement) {
 855     mElement->ResourceLoaded();
 856   }
 857   StopProgress();
 858 }
 859
 860 void nsOggDecoder::PlaybackCompleted()
 861 {
 862   if (mElement) {
 863     mElement->PlaybackCompleted();
 864   }
 865 }
 866
 867 NS_IMETHODIMP nsOggDecoder::Observe(nsISupports *aSubjet,
 868                                       const char *aTopic,
 869                                       const PRUnichar *someData)
 870 {
 871   if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
 872     Shutdown();
 873   }
 874
 875   return NS_OK;
 876 }
 877
 878 PRUint32 nsOggDecoder::GetBytesLoaded()
 879 {
 880   return mBytesDownloaded;
 881 }
 882
 883 PRUint32 nsOggDecoder::GetTotalBytes()
 884 {
 885   // TODO: Need to compute this for ogg files
 886   return 0;
 887 }
 888
 889 void nsOggDecoder::UpdateBytesDownloaded(PRUint32 aBytes)
 890 {
 891   mBytesDownloaded = aBytes;
 892 }
 893
 894 void nsOggDecoder::BufferingStopped()
 895 {
 896   if (mElement) {
 897     mElement->ChangeReadyState(nsIDOMHTMLMediaElement::CAN_SHOW_CURRENT_FRAME);
 898     mElement->Play();
 899   }
 900 }
 901
 902 void nsOggDecoder::BufferingStarted()
 903 {
 904   if (mElement) {
 905     mElement->Pause();
 906     mElement->ChangeReadyState(nsIDOMHTMLMediaElement::DATA_UNAVAILABLE);
 907   }
 908 }