Cinder

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 MovieBase {
 public:
    virtual     ~MovieBase() {} 
    
    bool        checkPlayable();
    
    int32_t     getWidth() const { return getObj()->mWidth; }
    int32_t     getHeight() const { return getObj()->mHeight; }
    float       getAspectRatio() const { return getObj()->mWidth / (float)getObj()->mHeight; }
    float       getDuration() const { return getObj()->mDuration; }
    float       getFramerate() const;
    int32_t     getNumFrames() const;
    bool        hasAlpha() const;

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

    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 std::string &path );
    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 : public MovieBase {
 public:
    MovieSurface() : MovieBase() {}
    MovieSurface( const std::string &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 = "" );

    Surface     getSurface();

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

  public:

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

class MovieGl : public MovieBase {
  public:
    MovieGl() : MovieBase() {}
    MovieGl( const std::string &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 = "" );

    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
    };
    
    shared_ptr<Obj>             mObj;
    virtual MovieBase::Obj*     getObj() const { return mObj.get(); }

  public:

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

class MovieLoader {
  public:
    MovieLoader() {}
    MovieLoader( const Url &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;
    };
    
    shared_ptr<Obj>     mObj;
    
  public:

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

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__ )