Ticket #9247: theora-sync.diff

engines/sword25/fmv/theora_decoder.cpp

@@ -329 +329 @@
         reset();
 }
 
+double TheoraDecoder::getTime() {
+        uint32 now = g_system->getMillis();
+        uint32 elapsedTime;
+
+        if (_audStream) {
+                elapsedTime = _mixer->getElapsedTime(*_audHandle).msecs();
+        } else {
+                // no audio timer to worry about, we can just use the system clock
+                // only one complication: If the process is suspended, we should
+                // reset timing to account for the gap in play time. Do it the
+                // easy/hack way
+                elapsedTime = now - _startTime;
+        }
+
+        return elapsedTime * .001;
+}
+
+// The Theora example decoder seems to have this fancy adaptive timing
+// thingamajig, but it also has the advantage of owning the decoder process
+// completely. We, on the other hand, are at the mercy of the game engine,
+// which calls this function whenever it feels like it.
+
+Graphics::Surface *TheoraDecoder::decode() {
+        bool endMovie = false;
+
+        if (_startTime == 0) {
+                _startTime = g_system->getMillis();
+        }
+
+        int32 oldFrame = _curFrame;
+
+        // Ensure that we always have something to sync against
+        // TODO: This should probably try to grab as much audio data as possible
+        // because I believe I'm getting sound underruns...
+        if (_audStream) {
+                uint32 oldQueue = _audStream->numQueuedStreams();
+
+                while (!endMovie && _audStream->numQueuedStreams() == oldQueue) {
+                        if (!decodePacket())
+                                endMovie = true;
+                }
+        }
+
+        // Advance to the appropriate video frame
+
+        while (!endMovie && _videobufTime < getTime()) {
+                if (!decodePacket())
+                        endMovie = true;
+        }
+
+        if (_surface && _curFrame != oldFrame) {
+                th_ycbcr_buffer yuv;
+
+                th_decode_ycbcr_out(_theoraDecode, yuv);
+
+                // Convert YUV data to RGB data
+                YUVtoBGRA::translate(yuv, _theoraInfo, (byte *)_surface->getBasePtr(0, 0), _surface->pitch * _surface->h);
+                
+                switch (_theoraInfo.pixel_fmt) {
+                case TH_PF_420:
+                        break;
+                case TH_PF_422:
+                        break;
+                case TH_PF_444:
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        return endMovie ? NULL : _surface;
+}
+
 Graphics::Surface *TheoraDecoder::decodeNextFrame() {
+        error("TheoraDecoder: Use decode() instead of decodeNextFrame()");
+        return _surface;
+}
+
+Graphics::Surface *TheoraDecoder::decodePacket() {
         int i, j;
 
 //      _stateFlag = false; // playback has not begun
@@ -394 +472 @@
                                 _videobufTime = th_granule_time(_theoraDecode, _videobufGranulePos);
                                 _curFrame++;
 
+#if 1
+                                // is it already too old to be useful? This is only actually
+                                // useful cosmetically after a SIGSTOP. Note that we have to
+                                // decode the frame even if we don't show it (for now) due to
+                                // keyframing. Soon enough libtheora will be able to deal
+                                // with non-keyframe seeks.
+
+                                if (_videobufTime >= getTime())
+                                        _videobufReady = true;
+                                else {
+                                        // If we are too slow, reduce the pp level.
+                                        _ppInc = (_ppLevel > 0) ? -1 : 0;
+                                }
+#else
                                 _videobufReady = true;
+#endif
                         }
                 } else
                         break;
@@ -425 +518 @@
 
         // are we at or past time for this video frame?
         if (_stateFlag && _videobufReady) {
-                th_ycbcr_buffer yuv;
-
-                th_decode_ycbcr_out(_theoraDecode, yuv);
-
-                // Convert YUV data to RGB data
-                YUVtoBGRA::translate(yuv, _theoraInfo, (byte *)_surface->getBasePtr(0, 0), _surface->pitch * _surface->h);
-                
-                switch (_theoraInfo.pixel_fmt) {
-                case TH_PF_420:
-                        break;
-                case TH_PF_422:
-                        break;
-                case TH_PF_444:
-                        break;
-                default:
-                        break;
-                }
-
                 _videobufReady = false;
         }
 
+        // TODO
+        // If we have lots of extra time, increase the post-processing level
+
         // if our buffers either don't exist or are ready to go,
         // we can begin playback
         if ((!_theoraPacket || _videobufReady) &&
@@ -468 +546 @@
         _videobufReady = false;
         _videobufGranulePos = -1;
         _videobufTime = 0;
+        _startTime = 0;
 
         _audiobufFill = 0;
         _audiobufReady = false;
@@ -484 +563 @@
         return !isVideoLoaded();
 }
 
-
 uint32 TheoraDecoder::getElapsedTime() const {
         if (_audStream && _mixer)
                 return _mixer->getSoundElapsedTime(*_audHandle);

engines/sword25/fmv/movieplayer.cpp

@@ -124 +124 @@
 
 void MoviePlayer::update() {
         if (_decoder.isVideoLoaded()) {
-                Graphics::Surface *s = _decoder.decodeNextFrame();
+                Graphics::Surface *s = _decoder.decode();
                 if (s) {
                         // Transfer the next frame
                         assert(s->bytesPerPixel == 4);

engines/sword25/fmv/theora_decoder.h

@@ -63 +63 @@
         void reset();
 
         /**
-         * Decode the next frame and return the frame's surface
+         * Decode the appropriate amount of data and return the frame's surface
          * @note the return surface should *not* be freed
          * @note this may return 0, in which case the last frame should be kept on screen
          */
+        Graphics::Surface *decode();
         Graphics::Surface *decodeNextFrame();
 
         bool isVideoLoaded() const {
@@ -105 +106 @@
         void queuePage(ogg_page *page);
         int bufferData();
         Audio::QueuingAudioStream *createAudioStream();
+        double getTime();
+        Graphics::Surface *decodePacket();
 
 private:
         Common::SeekableReadStream *_fileStream;
@@ -139 +142 @@
         int _ppLevel;
         int _ppInc;
 
+        uint32 _startTime;
+
         // single frame video buffering
         bool _videobufReady;
         ogg_int64_t  _videobufGranulePos;