llmediaimplquicktime.cpp

Go to the documentation of this file.

#include "llmediaimplquicktime.h"

#if LL_QUICKTIME_ENABLED

#include "llmediamanager.h"
#include "llmediaimplregister.h"

#if LL_WINDOWS
#include <windows.h>
#endif

#include <iostream>
#include <sstream>

// register this impl with media manager factory
static LLMediaImplRegister sLLMediaImplQuickTimeReg( "LLMediaImplQuickTime", new LLMediaImplQuickTimeMaker() );

//
LLMediaImplQuickTimeMaker::LLMediaImplQuickTimeMaker()
{
        // Register to handle the scheme
        mSchema.push_back( "rtsp" );

        // Register to handle the category
        mMimeTypeCategories.push_back( "video" );
        mMimeTypeCategories.push_back( "audio" );
        mMimeTypeCategories.push_back( "image" );
}

//
LLMediaImplQuickTime::LLMediaImplQuickTime() :
        mMovieHandle( 0 ),
        mGWorldHandle( 0 ),
        mMovieController( 0 ),
        mMinWidth( 32 ),
        mMaxWidth( 2048 ),
        mMinHeight( 32 ),
        mMaxHeight( 2048 ),
        mCurVolume( 0 )
{
}

//
LLMediaImplQuickTime::~LLMediaImplQuickTime()
{
        unload();
}

// (static) super-initialization - called once at application startup
bool LLMediaImplQuickTime::startup( LLMediaManagerData* init_data )
{
#ifdef WIN32
        if ( InitializeQTML( 0L ) != noErr )
        {
                return false;
        };
#endif

        EnterMovies();

        return true;
}

// (static) super-uninitialization - called once at application closedown
bool LLMediaImplQuickTime::closedown()
{
        ExitMovies();

#ifdef WIN32
        TerminateQTML();
#endif

        return true;
}

// private
bool LLMediaImplQuickTime::load( const std::string url )
{
        if ( url.empty() )
                return false;

        Handle handle = NewHandleClear( ( Size )( url.length() + 1 ) );
    if ( NULL == handle )
                return false;

        BlockMove( url.c_str(), *handle, ( Size )( url.length() + 1 ) );

        //std::cout << "LLMediaImplQuickTime::load( " << url << " )" << std::endl;

        // TODO: supposed to use NewMovieFromDataParams now
        OSErr err = NewMovieFromDataRef( &mMovieHandle, newMovieActive | newMovieDontInteractWithUser | newMovieAsyncOK | newMovieIdleImportOK, nil, handle, URLDataHandlerSubType );
        DisposeHandle( handle );
        if ( noErr != err )
                return false;

        // do pre-roll actions (typically fired for streaming movies but not always)
        PrePrerollMovie( mMovieHandle, 0, GetMoviePreferredRate( mMovieHandle ), moviePrePrerollCompleteCallback, ( void * )this );

        // get movie rect (and check for min/max)
        Rect movie_rect;
        setMovieBoxEnhanced( &movie_rect );

        // make a new movie controller
        mMovieController = NewMovieController( mMovieHandle, &movie_rect, mcNotVisible | mcTopLeftMovie );

#if defined(__APPLE__) || defined(MACOSX)
        setMediaDepth( 4 );
#else
        setMediaDepth( 3 );
#endif

        // tell manager about the media size
        setMediaSize( movie_rect.right - movie_rect.left, movie_rect.bottom - movie_rect.top);

        // movie controller
        MCSetActionFilterWithRefCon( mMovieController, mcActionFilterCallBack, ( long )this );

        SetMoviePlayHints( mMovieHandle, hintsAllowDynamicResize, hintsAllowDynamicResize );

        // function that gets called when a frame is drawn
        SetMovieDrawingCompleteProc( mMovieHandle, movieDrawingCallWhenChanged, movieDrawingCompleteCallback, ( long )this );

        // emit an event to say that a media source was loaded
        LLMediaEvent event( this );
        mEventEmitter.update( &LLMediaObserver::onMediaLoaded, event );

        // set up inital state
        sizeChanged();

        return true;
}

// virtual
std::string LLMediaImplQuickTime::getVersion()
{
        long version;
        Gestalt( gestaltQuickTimeVersion, &version );

        std::ostringstream codec( "" );
        codec << "[";
        codec << sLLMediaImplQuickTimeReg.getImplName();
        codec << "] - ";
        codec << "QuickTime: " << std::hex << version;

        return codec.str();
}

// virtual
bool LLMediaImplQuickTime::navigateTo( const std::string url )
{
        // tell engine what we're doing
        setStatus( LLMediaBase::STATUS_NAVIGATING );

        // remove the movie we were looking at
        unload();

        // load the new one (no real 'go to this url' function in QT)
        load( url );

        return true;
}

// virtual
bool LLMediaImplQuickTime::sizeChanged()
{
        if ( ! mMovieHandle )
                return false;

        // sanitize size of movie
        Rect movie_rect;
        setMovieBoxEnhanced( &movie_rect );

        // we need this later
        int width = ( movie_rect.right - movie_rect.left );
        int height = ( movie_rect.bottom - movie_rect.top );

        std::cout << "LLMEDIA> size changed to " << width << " x " << height << std::endl;

        setMediaSize( width, height );

        // media depth won't change
        int depth_bits = getMediaDepth() * 8;

        GWorldPtr old_gworld_handle = mGWorldHandle;

        if (old_gworld_handle)
        {
                GWorldFlags result = UpdateGWorld( &mGWorldHandle, depth_bits, &movie_rect, NULL, NULL, 0 );
                if ( gwFlagErr == result )
                {
                        // TODO: unrecoverable?? throw exception?  return something?
                        return false;
                }
        }
        else
        {
                OSErr result = NewGWorld( &mGWorldHandle, depth_bits, &movie_rect, NULL, NULL, keepLocal | pixelsLocked );
                if ( noErr != result )
                {
                        // ATODO: unrecoverable??  throw exception?  return something?
                        return false;
                }

                // clear memory in GWorld to avoid random screen visual fuzz from uninitialized texture data
                if ( mGWorldHandle )
                {
                        PixMapHandle pix_map_handle = GetGWorldPixMap( mGWorldHandle );
                        unsigned char* ptr = ( unsigned char* )GetPixBaseAddr( pix_map_handle );
                        memset( ptr, 0x00, height * QTGetPixMapHandleRowBytes( pix_map_handle ) );
                }
        }

        // point movie at GWorld if it's new
        if ( mMovieHandle && ! old_gworld_handle )
        {
                SetMovieGWorld( mMovieHandle, mGWorldHandle, GetGWorldDevice ( mGWorldHandle ) );
        }

        // update movie controller
        if ( mMovieController )
        {
                MCSetControllerPort( mMovieController, mGWorldHandle );
                MCPositionController( mMovieController, &movie_rect, &movie_rect,
                                                          mcTopLeftMovie | mcPositionDontInvalidate );
                MCMovieChanged( mMovieController, mMovieHandle );
        }

        // Emit event with size change so the calling app knows about it too
        LLMediaEvent event( this );
        mEventEmitter.update( &LLMediaObserver::onMediaSizeChange, event );

        return true;
}

// static
Boolean LLMediaImplQuickTime::mcActionFilterCallBack( MovieController mc, short action, void *params, long ref )
{
        Boolean result = false;

        LLMediaImplQuickTime* self = ( LLMediaImplQuickTime* )ref;

        switch( action )
        {
                // handle window resizing
                case mcActionControllerSizeChanged:
                        self->sizeChanged();
                        break;

                // Block any movie controller actions that open URLs.
                case mcActionLinkToURL:
                case mcActionGetNextURL:
                case mcActionLinkToURLExtended:
                        // Prevent the movie controller from handling the message
                        result = true;
                        break;

                default:
                        break;
        };

        return result;
}

// private
bool LLMediaImplQuickTime::unload()
{
        if ( mMovieHandle )
        {
                StopMovie( mMovieHandle );
                if ( mMovieController )
                {
                        MCMovieChanged( mMovieController, mMovieHandle );
                };
        };

        if ( mMovieController )
        {
                MCSetActionFilterWithRefCon( mMovieController, NULL, (long)this );
                DisposeMovieController( mMovieController );
                mMovieController = NULL;
        };

        if ( mMovieHandle )
        {
                SetMovieDrawingCompleteProc( mMovieHandle, movieDrawingCallWhenChanged, nil, ( long )this );
                DisposeMovie ( mMovieHandle );
                mMovieHandle = NULL;
        };

        if ( mGWorldHandle )
        {
                DisposeGWorld( mGWorldHandle );
                mGWorldHandle = NULL;
        };

        return true;
}

// static
OSErr LLMediaImplQuickTime::movieDrawingCompleteCallback( Movie call_back_movie, long ref )
{
        LLMediaImplQuickTime* self = ( LLMediaImplQuickTime* )ref;

        // IMPORTANT: typically, a consumer who is observing this event will set a flag
        // when this event is fired then render later. Be aware that the media stream
        // can change during this period - dimensions, depth, format etc.
        LLMediaEvent event( self );
        self->mEventEmitter.update( &LLMediaObserver::onMediaContentsChange, event );

        return noErr;
}

// static
void LLMediaImplQuickTime::moviePrePrerollCompleteCallback( Movie movie, OSErr preroll_err, void *ref )
{
        LLMediaImplQuickTime* self = ( LLMediaImplQuickTime* )ref;

        LLMediaEvent event( self );
        self->mEventEmitter.update( &LLMediaObserver::onMediaPreroll, event );
}

// used for stop / loop
void LLMediaImplQuickTime::rewind()
{
        GoToBeginningOfMovie ( mMovieHandle );

        MCMovieChanged( mMovieController, mMovieHandle );
}

//
bool LLMediaImplQuickTime::processState()
{
        // start stream
        if ( nextCommand() == LLMediaBase::COMMAND_START )
        {
                // valid when we are in these states
                if ( getStatus() == LLMediaBase::STATUS_NAVIGATING|| getStatus() == LLMediaBase::STATUS_STOPPED || getStatus() == LLMediaBase::STATUS_PAUSED )
                {
                        // it appears that the movie must be in a loaded state before we do this command
                        if ( GetMovieLoadState( mMovieHandle ) >= kMovieLoadStatePlaythroughOK )
                        {
                                MCDoAction( mMovieController, mcActionPrerollAndPlay, (void*)GetMoviePreferredRate( mMovieHandle ) );

                                MCDoAction( mMovieController, mcActionSetVolume, (void*)mCurVolume );

                                setStatus( LLMediaBase::STATUS_STARTED );

                                clearCommand();
                        }
                }
        }
        else
        if ( nextCommand() == LLMediaBase::COMMAND_STOP )
        {
                // valid when we are in these states
                if ( getStatus() == LLMediaBase::STATUS_NAVIGATING || getStatus() == LLMediaBase::STATUS_STARTED || getStatus() == LLMediaBase::STATUS_PAUSED )
                {
                        // it appears that the movie must be in a loaded state before we do this command
                        if ( GetMovieLoadState( mMovieHandle ) >= kMovieLoadStatePlaythroughOK )
                        {
                                // stop playing
                                Fixed rate = X2Fix( 0.0 );
                                MCDoAction( mMovieController, mcActionPlay, (void*)rate );

                                // go back to start
                                rewind();

                                setStatus( LLMediaBase::STATUS_STOPPED );
                                clearCommand();
                        };
                };
        }
        else
        if ( nextCommand() == LLMediaBase::COMMAND_PAUSE )
        {
                // valid when we are in these states
                if ( getStatus() == LLMediaBase::STATUS_NAVIGATING || getStatus() == LLMediaBase::STATUS_STARTED || getStatus() == LLMediaBase::STATUS_STOPPED )
                {
                        // it appears that the movie must be in a loaded state before we do this command
                        if ( GetMovieLoadState( mMovieHandle ) >= kMovieLoadStatePlaythroughOK )
                        {
                                // stop playing
                                Fixed rate = X2Fix( 0.0 );
                                MCDoAction( mMovieController, mcActionPlay, (void*)rate );

                                setStatus( LLMediaBase::STATUS_PAUSED );
                                clearCommand();
                        };
                };
        };

        return true;
}

// virtual
bool LLMediaImplQuickTime::setMovieBoxEnhanced( Rect* rect )
{
        // get movie rect
        GetMovieNaturalBoundsRect( mMovieHandle, rect );

        int natural_width  = ( rect->right - rect->left );
        int natural_height = ( rect->bottom - rect->top );

        int width  = natural_width;
        int height = natural_height;
        
        // if the user has requested a specific size, use it:
        if ((mMediaRequestedWidth != 0) && (mMediaRequestedHeight != 0))
        {
                width = mMediaRequestedWidth;
                height = mMediaRequestedHeight;
        }

        // if the user has requested, resize media to exactly fit texture
        if (mAutoScaled)
        {
                width = LLMediaManager::textureWidthFromMediaWidth( width );
                height = LLMediaManager::textureHeightFromMediaHeight( height );
        }

        // make sure it falls in valid range
        if ( width < mMinWidth )
                width = mMinWidth;

        if ( width > mMaxWidth )
                width = mMaxWidth;

        if ( height < mMinHeight )
                height = mMinHeight;

        if ( height > mMaxHeight )
                height = mMaxHeight;

        
        // scale movie to fit rect and invert vertically to match opengl image format
        MatrixRecord transform;
        SetIdentityMatrix( &transform );        // transforms are additive so start from identify matrix
        double scaleX = (double) width / natural_width;
        double scaleY = -1.0 * (double) height / natural_height;
        double centerX = width / 2.0;
        double centerY = height / 2.0;
        ScaleMatrix( &transform, X2Fix ( scaleX ), X2Fix ( scaleY ), X2Fix ( centerX ), X2Fix ( centerY ) );
        SetMovieMatrix( mMovieHandle, &transform );

        // return the new rect
        rect->right = width;
        rect->bottom = height;
        rect->left = 0;
        rect->top = 0;

        return true;
}

// virtual
bool LLMediaImplQuickTime::updateMedia()
{
        if ( ! mMovieHandle )
                return false;

        if ( ! mMovieController )
                return false;

        if ( ! mGWorldHandle )
                return false;

        // service QuickTime
        MoviesTask( mMovieHandle, 0 );
        MCIdle( mMovieController );

        // update state machine (deals with transport controls for example)
        processState();

        // special code for looping - need to rewind at the end of the movie

        if ( isLooping() )
        {
                // QT call to see if we are at the end - can't do with controller
                if ( IsMovieDone( mMovieHandle ) )
                {
                        // go back to start
                        rewind();

                        // kick off new play
                        MCDoAction( mMovieController, mcActionPrerollAndPlay, (void*)GetMoviePreferredRate( mMovieHandle ) );

                        // set the volume
                        MCDoAction( mMovieController, mcActionSetVolume, (void*)mCurVolume );
                }
        }

        return true;
}

// virtual
unsigned char* LLMediaImplQuickTime::getMediaData()
{
        unsigned char* ptr = NULL;

        if ( mGWorldHandle )
        {
                PixMapHandle pix_map_handle = GetGWorldPixMap( mGWorldHandle );

                ptr = ( unsigned char* )GetPixBaseAddr( pix_map_handle );
        };

        return ptr;
}

// virtual
int LLMediaImplQuickTime::getMediaDataWidth() const
{
        if ( mGWorldHandle )
        {
                int depth = getMediaDepth();

                if (depth < 1)
                        depth = 1;

                // ALWAYS use the row bytes from the PixMap if we have a GWorld because
                // sometimes it's not the same as mMediaDepth * mMediaWidth !
                PixMapHandle pix_map_handle = GetGWorldPixMap( mGWorldHandle );
                return QTGetPixMapHandleRowBytes( pix_map_handle ) / depth;
        }
        else
        {
                return LLMediaImplCommon::getMediaDataWidth();
        }
}

// virtual
int LLMediaImplQuickTime::getTextureFormatPrimary() const
{
#if defined(__APPLE__) || defined(MACOSX)
        return LL_MEDIA_BGRA;
#else
        return LL_MEDIA_RGB;
#endif
}

// virtual
int LLMediaImplQuickTime::getTextureFormatType() const
{
#if defined(__APPLE__) || defined(MACOSX)
        #ifdef __BIG_ENDIAN__
                return LL_MEDIA_UNSIGNED_INT_8_8_8_8_REV;
        #else
                return LL_MEDIA_UNSIGNED_INT_8_8_8_8;
        #endif
#else
        return LL_MEDIA_UNSIGNED_BYTE;
#endif
}

// virtual
bool LLMediaImplQuickTime::seek( double time )
{
        if ( mMovieController )
        {
                TimeRecord when;
                when.scale = GetMovieTimeScale( mMovieHandle );
                when.base = 0;

                // 'time' is in (floating point) seconds.  The timebase time will be in 'units', where
                // there are 'scale' units per second.
                SInt64 raw_time = ( SInt64 )( time * (double)( when.scale ) );

                when.value.hi = ( SInt32 )( raw_time >> 32 );
                when.value.lo = ( SInt32 )( ( raw_time & 0x00000000FFFFFFFF ) );

                MCDoAction( mMovieController, mcActionGoToTime, &when );

                return true;
        }

        return false;
}

// virtual
bool LLMediaImplQuickTime::setVolume( float volume )
{
        mCurVolume = (short)(volume * ( double ) 0x100 );

        if ( mMovieController )
        {
                MCDoAction( mMovieController, mcActionSetVolume, (void*)mCurVolume );

                return true;
        }

        return false;
}

#endif // _3DNOW_InstructionExtensions/ LL_QUICKTIME_ENABLED

---