qtliveutils.cpp

最新osg包

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2007 Robert Osfield 
 *
 * This library is open source and may be redistributed and/or modified under  
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 * OpenSceneGraph Public License for more details.
*/


#include <cstdio>
#include <cstdlib>
#include <string>
#include <sstream>

#include "osg/Image"
#include "osg/Notify"
#include "osg/Geode"
#include "osg/GL"

#include "osgDB/FileNameUtils"
#include "osgDB/Registry"
#include "osgDB/FileUtils"

#ifdef __APPLE__
    #include <QuickTime/QuickTime.h>
    #include <Carbon/Carbon.h>
    #define QT_HANDLE_IMAGES_ALSO
#else
    #include <QTML.h>
    #include <Movies.h>
    #include <Quickdraw.h>
    #include <QDOffscreen.h>
    #include <QuicktimeComponents.h>
    #include <FixMath.h>
    #include <CGBitmapContext.h>
    #include <CGImage.h>
    #include <CGColorSpace.h>
    #include <ImageCompression.h>
    #include <TextUtils.h>
#endif

#include "QTLiveUtils.h"


// Utils
char* pstr_printable(StringPtr src_pstr)
{
    char* dst_cstr = new char[256];
    p2cstrcpy(dst_cstr, src_pstr);
    return dst_cstr;
}


void initialize_quicktime_qtml()
{
    osg::notify(osg::NOTICE) << "QT QTML: Starting up... " << std::endl;
    OSErr err;
#ifndef __APPLE__
    err = InitializeQTML(0);
    if (err!=0)
        osg::notify(osg::FATAL) << "Error while initializing quicktime QTML: " << err << std::endl; 
    else
        osg::notify(osg::NOTICE) << "QT QTML: initialized successfully"  << std::endl;
#endif
}

void terminite_quicktime_qtml()
{
    osg::notify(osg::NOTICE) << "QT QTML: Closing down... " << std::endl;
#ifndef __APPLE__
    TerminateQTML();
#endif
    osg::notify(osg::NOTICE) << "QT QTML: Closed successfully"  << std::endl;    
}

void enter_quicktime_movies()
{
    osg::notify(osg::NOTICE) << "QT Movies: Starting up... " << std::endl;
    OSErr err;
    err = EnterMovies();
    if (err!=0)
        osg::notify(osg::FATAL) << "Error while initializing Movies: " << err << std::endl; 
    else
        osg::notify(osg::NOTICE) << "QT Movies: initialized successfully"  << std::endl;
}

void leave_quicktime_movies()
{
    osg::notify(osg::NOTICE) << "QT Movies: Closing down... " << std::endl;
#ifndef __APPLE__
    ExitMovies();
#endif
    osg::notify(osg::NOTICE) << "QT Movies: closed successfully"  << std::endl;    
}

#if TARGET_OS_MAC
void enter_quicktime_movies_mt()
{
    osg::notify(osg::NOTICE) << "QT Movies MT: Starting up... " << std::endl;
    OSErr err;
    err = EnterMoviesOnThread(0);
    if (err!=0)
        osg::notify(osg::FATAL) << "Error while initializing Movies MT: " << err << std::endl; 
    else
        osg::notify(osg::NOTICE) << "QT Movies MT: initialized successfully"  << std::endl;
}

void leave_quicktime_movies_mt()
{
    osg::notify(osg::NOTICE) << "QT Movies MT: Closing down... " << std::endl;
#ifndef __APPLE__
    ExitMoviesOnThread();
#endif
    osg::notify(osg::NOTICE) << "QT Movies MT: closed successfully"  << std::endl;    
}
#endif



QTScopedQTMLInitialiser::QTScopedQTMLInitialiser()
{
    initialize_quicktime_qtml();
}
QTScopedQTMLInitialiser::~QTScopedQTMLInitialiser()
{
    terminite_quicktime_qtml();
}


QTScopedMovieInitialiser::QTScopedMovieInitialiser()
{
    enter_quicktime_movies();
}
QTScopedMovieInitialiser::~QTScopedMovieInitialiser()
{
    leave_quicktime_movies();
}


#if TARGET_OS_MAC
QTScopedMovieInitialiser_MT::QTScopedMovieInitialiser_MT()
{
    enter_quicktime_movies_mt();
}
QTScopedMovieInitialiser_MT::~QTScopedMovieInitialiser_MT()
{
    leave_quicktime_movies_mt();
}
#endif


// DigitizerInfo input/output Capability checker
bool supports_capability( long input_flags, long option_flags )
{
    long result_l = (input_flags & option_flags);
    return result_l == option_flags;
}

// Capability
void print_video_component_capability(VideoDigitizerComponent aComponent)
{
    // Returns capability and status information about a specified video digitizer component.
    VideoDigitizerError vid_err;
    DigitizerInfo       vid_info;
    // Capability flags
    osg::notify(osg::NOTICE) << std::endl;
    vid_err = VDGetDigitizerInfo(aComponent, &vid_info);
    if (vid_err) osg::notify(osg::NOTICE) << "VDGetDigitizerInfo(aComponent, &vid_info) - ERROR" << std::endl;
    else
    {
        osg::notify(osg::NOTICE) << "DigitizerInfo:" << std::endl;
        short vdigType = vid_info.vdigType;
        if (vdigType == vdTypeBasic) osg::notify(osg::NOTICE) << "Digitizer Type : Basic (no clipping)" << std::endl;
        if (vdigType == vdTypeAlpha) osg::notify(osg::NOTICE) << "Digitizer Type : Alpha clipping" << std::endl;
        if (vdigType == vdTypeMask)  osg::notify(osg::NOTICE) << "Digitizer Type : Mask Plane clipping" << std::endl;
        if (vdigType == vdTypeKey)   osg::notify(osg::NOTICE) << "Digitizer Type : Key Color(s) clipping" << std::endl;
        short vdigSlot = vid_info.slot;
        osg::notify(osg::NOTICE) << "Hardwre Slot : " << vdigSlot << std::endl;
        osg::notify(osg::NOTICE) << "Input Capability:" << std::endl << std::boolalpha;
        long inputCapabilityFlags = vid_info.inputCapabilityFlags;
        osg::notify(osg::NOTICE) << "    NTSC      : " << supports_capability(inputCapabilityFlags, digiInDoesNTSC) << std::endl;
        osg::notify(osg::NOTICE) << "    PAL       : " << supports_capability(inputCapabilityFlags, digiInDoesPAL)  << std::endl;
        osg::notify(osg::NOTICE) << "    Composite : " << supports_capability(inputCapabilityFlags, digiInDoesComposite) << std::endl;
        osg::notify(osg::NOTICE) << "    Component : " << supports_capability(inputCapabilityFlags, digiInDoesComponent) << std::endl;
        osg::notify(osg::NOTICE) << "    SVideo    : " << supports_capability(inputCapabilityFlags, digiInDoesSVideo) << std::endl;
        osg::notify(osg::NOTICE) << "Input Current:" << std::endl;
        long inputCurrentFlags = vid_info.inputCurrentFlags;
        osg::notify(osg::NOTICE) << "    NTSC      : " << supports_capability(inputCurrentFlags, digiInDoesNTSC) << std::endl;
        osg::notify(osg::NOTICE) << "    PAL       : " << supports_capability(inputCurrentFlags, digiInDoesPAL)  << std::endl;
        osg::notify(osg::NOTICE) << "    Composite : " << supports_capability(inputCurrentFlags, digiInDoesComposite) << std::endl;
        osg::notify(osg::NOTICE) << "    Component : " << supports_capability(inputCurrentFlags, digiInDoesComponent) << std::endl;
        osg::notify(osg::NOTICE) << "    SVideo    : " << supports_capability(inputCurrentFlags, digiInDoesSVideo) << std::endl;
        // Heights
        short minDestHeight = vid_info.minDestHeight;
        short minDestWidth  = vid_info.minDestWidth;
        short maxDestWidth  = vid_info.maxDestWidth;
        short maxDestHeight = vid_info.maxDestHeight;
        osg::notify(osg::NOTICE) << "Min destination width,height :  " << minDestWidth << "  " << minDestHeight << std::endl;
        osg::notify(osg::NOTICE) << "Max destination width,height :  " << maxDestWidth << "  " << maxDestHeight << std::endl;
        // Current Status
        long inputFlags, outputFlags;
        vid_err = VDGetCurrentFlags(aComponent, &inputFlags, &outputFlags);
        osg::notify(osg::NOTICE) << "    NTSC          : " << supports_capability(inputFlags, digiInDoesNTSC) << std::endl;
        osg::notify(osg::NOTICE) << "    PAL           : " << supports_capability(inputFlags, digiInDoesPAL)  << std::endl;
        osg::notify(osg::NOTICE) << "    Composite     : " << supports_capability(inputFlags, digiInDoesComposite) << std::endl;
        osg::notify(osg::NOTICE) << "    Component     : " << supports_capability(inputFlags, digiInDoesComponent) << std::endl;
        osg::notify(osg::NOTICE) << "    SVideo        : " << supports_capability(inputFlags, digiInDoesSVideo) << std::endl;