include/cinder/qtime/QuickTime.h

Go to the documentation of this file.

/*
 Copyright (c) 2010, The Barbarian Group
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification, are permitted provided that
 the following conditions are met:

    * Redistributions of source code must retain the above copyright notice, this list of conditions and
    the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
    the following disclaimer in the documentation and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
*/

#pragma once

// None of this works in 64 bit on the mac or Windows. We'll need to move to QTKit on the mac.
#if ! defined( __LP64__ )

#include "cinder/Cinder.h"
#include "cinder/gl/gl.h"
#include "cinder/Surface.h"
#include "cinder/gl/Texture.h"
#include "cinder/Display.h"
#include "cinder/Url.h"
#include "cinder/DataSource.h"
#include "cinder/Thread.h"

#include <string>

#if defined( CINDER_MAC )
    #include <QuickTime/QuickTime.h>
    #if defined( __OBJC__ )
        @class QTMovie;
    #else
        class QTMovie;
    #endif
#endif


// these are forward-declared to avoid bringing all of QuickTime into the global namespace on Windows
#if defined( CINDER_MSW )
    typedef struct MovieType**              Movie;
    typedef struct OpaqueQTVisualContext*   QTVisualContextRef;
    typedef long                            TimeValue;
    typedef struct QTAudioFrequencyLevels   QTAudioFrequencyLevels;
    typedef unsigned long                   FourCharCode;
    typedef struct __CVBuffer*              CVBufferRef;
    typedef CVBufferRef                     CVImageBufferRef;
#endif

namespace cinder { namespace qtime {

class MovieLoader;
typedef std::shared_ptr<MovieLoader>    MovieLoaderRef;

class MovieBase {
 public:
    virtual     ~MovieBase() {} 
    
    bool        checkPlayable();
    
    int32_t     getWidth() const { return getObj()->mWidth; }
    int32_t     getHeight() const { return getObj()->mHeight; }
    Vec2i       getSize() const { return Vec2i( getWidth(), getHeight() ); }    
    float       getAspectRatio() const { return getObj()->mWidth / (float)getObj()->mHeight; }
    Area        getBounds() const { return Area( 0, 0, getWidth(), getHeight() ); }
    float       getPixelAspectRatio() const;
    float       getDuration() const { return getObj()->mDuration; }
    float       getFramerate() const;
    int32_t     getNumFrames() const;
    bool        hasAlpha() const;

    bool        hasVisuals() const;
    bool        hasAudio() const;

    bool        checkNewFrame();

    float       getCurrentTime() const;
    void        seekToTime( float seconds );
    void        seekToFrame( int frame );
    void        seekToStart();
    void        seekToEnd();
    void        setActiveSegment( float startTime, float duration );
    void        resetActiveSegment();

    void        setLoop( bool loop = true, bool palindrome = false );
    void        stepForward();
    void        stepBackward();
    void        setRate( float rate );

    void        setVolume( float volume );
    float       getVolume() const;

    void        setupMonoFft( uint32_t numBands );
    void        setupStereoFft( uint32_t numBands );
    void        setupMultiChannelFft( uint32_t numBands );  
    
    float*      getFftData() const;
    uint32_t    getNumFftBands() const;
    uint32_t    getNumFftChannels() const;  

    bool    isPlaying() const;
    bool    isDone() const;
    void    play();
    void    stop();

    void    setNewFrameCallback( void(*aNewFrameCallback)( long, void * ), void *aNewFrameCallbackRefcon );

    ::Movie getMovieHandle() const { return getObj()->mMovie; }

 protected:
    MovieBase() {}
    void            init();
    void            updateFrame();
    void            updateLoadState();

    void            setupFft( FourCharCode code, uint32_t bandNum, uint8_t channelNum );

    static int32_t      countFrames( ::Movie theMovie );
    TimeValue           getStartTimeOfFirstSample() const;

 protected:
    void    initFromPath( const fs::path &filePath );
    void    initFromLoader( const class MovieLoader &loader );
    void    initFromMemory( const void *data, size_t dataSize, const std::string &fileNameHint, const std::string &mimeTypeHint );
    void    initFromDataSource( DataSourceRef dataSource, const std::string &mimeTypeHint );
 
    struct Obj {
        Obj();
        virtual ~Obj();
    
        void prepareForDestruction();
    
        void lock() { mMutex.lock(); }
        void unlock() { mMutex.unlock(); }

        // because the MovieBase* might change over time, but the MovieBase::Obj* will not, we need our callbacks to take an Obj* as a refcon
        // which in turn means this functionality must be in the Obj, not the MovieBase
        virtual void        releaseFrame() = 0;
        virtual void        newFrame( CVImageBufferRef cvImage ) = 0;
                
        int32_t                     mWidth, mHeight;
        int32_t                     mFrameCount;
        float                       mDuration;
        bool                        mLoaded, mPlayable;
        bool                        mPlayingForward, mLoop, mPalindrome;

        QTAudioFrequencyLevels      *mFFTData;
        FourCharCode                mFFTFourCharCode;
        uint32_t                    mFFTNumBandLevels;
        uint32_t                    mFFTNumChannels;
        QTVisualContextRef          mVisualContext;
        ::Movie                     mMovie;

        void        (*mNewFrameCallback)(long timeValue, void *refcon);
        void        *mNewFrameCallbackRefcon;           

        std::mutex                  mMutex; 
        DataSourceRef               mDataSource; // sometimes used to retain a reference to a data source so that it doesn't go away before we do
    };
    
    virtual Obj*        getObj() const = 0;
};

class MovieSurface;
typedef std::shared_ptr<MovieSurface>   MovieSurfaceRef;

class MovieSurface : public MovieBase {
 public:
    MovieSurface() : MovieBase() {}
    MovieSurface( const fs::path &path );
    MovieSurface( const class MovieLoader &loader );

    MovieSurface( const void *data, size_t dataSize, const std::string &fileNameHint, const std::string &mimeTypeHint = "" );
    MovieSurface( DataSourceRef dataSource, const std::string mimeTypeHint = "" );

    static MovieSurfaceRef create( const fs::path &path ) { return std::shared_ptr<MovieSurface>( new MovieSurface( path ) ); }
    static MovieSurfaceRef create( const MovieLoaderRef &loader );
    static MovieSurfaceRef create( const void *data, size_t dataSize, const std::string &fileNameHint, const std::string &mimeTypeHint = "" )
         { return std::shared_ptr<MovieSurface>( new MovieSurface( data, dataSize, fileNameHint, mimeTypeHint ) ); }
    static MovieSurfaceRef create( DataSourceRef dataSource, const std::string mimeTypeHint = "" )
         { return std::shared_ptr<MovieSurface>( new MovieSurface( dataSource, mimeTypeHint ) ); }

    Surface     getSurface();

 protected:
    void                allocateVisualContext();
 
    struct Obj : public MovieBase::Obj {
        virtual ~Obj();
        
        virtual void        releaseFrame(); 
        virtual void        newFrame( CVImageBufferRef cvImage );
    
        Surface             mSurface;
    };
    
    std::shared_ptr<Obj>        mObj;
    virtual MovieBase::Obj*     getObj() const { return mObj.get(); }

  public:

    typedef std::shared_ptr<Obj> MovieSurface::*unspecified_bool_type;
    operator unspecified_bool_type() const { return ( mObj.get() == 0 ) ? 0 : &MovieSurface::mObj; }
    void reset() { mObj.reset(); }
};

class MovieGl;
typedef std::shared_ptr<MovieGl>    MovieGlRef;
class MovieGl : public MovieBase {
  public:
    MovieGl() : MovieBase() {}
    MovieGl( const fs::path &path );
    MovieGl( const class MovieLoader &loader );

    MovieGl( const void *data, size_t dataSize, const std::string &fileNameHint, const std::string &mimeTypeHint = "" );
    MovieGl( DataSourceRef dataSource, const std::string mimeTypeHint = "" );

    static MovieGlRef create( const fs::path &path ) { return std::shared_ptr<MovieGl>( new MovieGl( path ) ); }
    static MovieGlRef create( const MovieLoaderRef &loader );
    static MovieGlRef create( const void *data, size_t dataSize, const std::string &fileNameHint, const std::string &mimeTypeHint = "" )
         { return std::shared_ptr<MovieGl>( new MovieGl( data, dataSize, fileNameHint, mimeTypeHint ) ); }
    static MovieGlRef create( DataSourceRef dataSource, const std::string mimeTypeHint = "" )
         { return std::shared_ptr<MovieGl>( new MovieGl( dataSource, mimeTypeHint ) ); }

    const gl::Texture   getTexture();

  protected:
    void                allocateVisualContext();

    struct Obj : public MovieBase::Obj {
        Obj();
        ~Obj();

        virtual void        releaseFrame();
        virtual void        newFrame( CVImageBufferRef cvImage );
        
        gl::Texture         mTexture;
#if defined( CINDER_MSW )
        gl::TextureCache    mTextureCache;
#endif
    };
    
    std::shared_ptr<Obj>                mObj;
    virtual MovieBase::Obj*     getObj() const { return mObj.get(); }

  public:

    typedef std::shared_ptr<Obj> MovieGl::*unspecified_bool_type;
    operator unspecified_bool_type() const { return ( mObj.get() == 0 ) ? 0 : &MovieGl::mObj; }
    void reset() { mObj.reset(); }
};

class MovieLoader {
  public:
    MovieLoader() {}
    MovieLoader( const Url &url );

    static MovieLoaderRef   create( const Url &url ) { return std::shared_ptr<MovieLoader>( new MovieLoader( url ) ); }

    bool    checkLoaded() const;
    bool    checkPlayable() const;
    bool    checkPlaythroughOk() const;

    void    waitForLoaded() const;
    void    waitForPlayable() const;
    void    waitForPlaythroughOk() const;

    const Url&      getUrl() const { return mObj->mUrl; }

    ::Movie getMovieHandle() const { return mObj->mMovie; }

    ::Movie transferMovieHandle() const { mObj->mOwnsMovie = false; return mObj->mMovie; }
    
  protected:
    void    updateLoadState() const;
 
    struct Obj {
        Obj( const Url &url );
        ~Obj();
        
        mutable bool    mOwnsMovie;
        ::Movie         mMovie;
        Url             mUrl;
        mutable bool    mLoaded, mPlayable, mPlaythroughOK;
    };
    
    std::shared_ptr<Obj>        mObj;
    
  public:

    typedef std::shared_ptr<Obj> MovieLoader::*unspecified_bool_type;
    operator unspecified_bool_type() const { return ( mObj.get() == 0 ) ? 0 : &MovieLoader::mObj; }
    void reset() { mObj.reset(); }
};

inline int32_t floatToFixed( float fl ) { return ((int32_t)((float)(fl) * ((int32_t) 0x00010000L))); }

void startQuickTime();
extern int32_t getQuickTimeVersion();
extern std::string getQuickTimeVersionString();

extern void quickTimeTask();

class QuickTimeExc : public std::exception {
};

class QuickTimePathInvalidExc : public QuickTimeExc {
};

class QuickTimeFileInvalidExc : public QuickTimeExc {
};

class QuickTimeExcUrlInvalid : public QuickTimeExc {
};

class QuickTimeErrorLoadingExc : public QuickTimeExc {
};

class QuickTimeExcFft : public QuickTimeExc {
};

} /* namespace qtime */ } /* namespace cinder */
#endif // ! defined( __LP64__ )