Changeset 9771

Show
Ignore:
Timestamp:
02/11/09 18:42:17 (5 years ago)
Author:
robert
Message:

From Riccardo Corsi, "in attach you'll find a patch to cleanup a little bit the (de)initialization code of QuickTime?? environment from the quickTime pluging.
It basically removes the static init() and exit() functions,and move them inside the observer class (the one that cleans everything up when the last media is unloaded).

It also add an extra check to clean up on exit if the QuickTime?? env is initialized, but no media is succesfully loaded / written (it might happens with streaming resources).

I tested it under WinXP with zero, one and multiple videos. "

Merged from svn/trunk using:

svn merge -r 9768:9769 http://www.openscenegraph.org/svn/osg/OpenSceneGraph/trunk

Location:
OpenSceneGraph/branches/OpenSceneGraph-2.8/src/osgPlugins/quicktime
Files:
4 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/branches/OpenSceneGraph-2.8/src/osgPlugins/quicktime/QTImportExport.cpp

    r8712 r9771  
    3535    _lastError("") 
    3636{ 
    37     initQuicktime(); 
    3837} 
    3938 
  • OpenSceneGraph/branches/OpenSceneGraph-2.8/src/osgPlugins/quicktime/QTUtils.cpp

    r8806 r9771  
    1616using namespace std; 
    1717 
    18  
    19  
    20     class QuicktimeInitializer : public osg::Referenced { 
    21         public: 
    22             QuicktimeInitializer() :osg::Referenced() { 
    23                 
    24                  #ifndef __APPLE__ 
    25                      InitializeQTML(0); 
    26                  #endif 
    27                  OSErr err = EnterMovies(); 
    28                  if (err!=0) 
    29                     osg::notify(osg::FATAL) << "Error while initializing quicktime: " << err << endl;  
    30                  else 
    31                     osg::notify(osg::DEBUG_INFO) << "Quicktime initialized successfully"  << endl; 
    32  
    33                  static bool registered = false; 
    34  
    35                  if (!registered){ 
    36                      registerQTReader();  
    37                      registered = true;     
    38                  }                  
    39             } 
    40              
    41             ~QuicktimeInitializer() { 
    42                 #ifndef __APPLE__ 
    43                     ExitMovies(); 
    44                 #endif 
    45                 //osg::notify(osg::DEBUG_INFO) << "Quicktime deinitialized successfully"  << endl; 
    46             } 
    47  
    48     protected: 
    49         void registerQTReader() { 
    50             osgDB::Registry* r = osgDB::Registry::instance(); 
    51          r->addFileExtensionAlias("mov",  "qt"); 
    52  
    53          #ifdef QT_HANDLE_IMAGES_ALSO 
    54             r->addFileExtensionAlias("jpg",  "qt"); 
    55             r->addFileExtensionAlias("jpe",  "qt"); 
    56             r->addFileExtensionAlias("jpeg", "qt"); 
    57             r->addFileExtensionAlias("tif",  "qt"); 
    58             r->addFileExtensionAlias("tiff", "qt"); 
    59             r->addFileExtensionAlias("gif",  "qt"); 
    60             r->addFileExtensionAlias("png",  "qt"); 
    61             r->addFileExtensionAlias("psd",  "qt"); 
    62             r->addFileExtensionAlias("tga",  "qt"); 
    63             r->addFileExtensionAlias("mov",  "qt"); 
    64             r->addFileExtensionAlias("avi",  "qt"); 
    65             r->addFileExtensionAlias("mpg",  "qt"); 
    66             r->addFileExtensionAlias("mpv",  "qt"); 
    67             r->addFileExtensionAlias("dv",   "qt"); 
    68             r->addFileExtensionAlias("mp4",  "qt"); 
    69             r->addFileExtensionAlias("m4v",  "qt");          
    70          #endif 
    71         } 
    72                  
    73     }; 
    74      
    75     void initQuicktime(bool erase) { 
    76  
    77         static osg::ref_ptr<QuicktimeInitializer> s_qt_init = new QuicktimeInitializer(); 
    78         if (erase) { 
    79             s_qt_init = NULL; 
    80         } else if (!s_qt_init.valid()) 
    81         { 
    82             s_qt_init = new QuicktimeInitializer(); 
    83         } 
    84     } 
    85  
    86      
    87     void exitQuicktime() { 
    88         initQuicktime(true); 
    89     } 
    90  
    91  
    92      
    9318 
    9419    // --------------------------------------------------------------------------- 
  • OpenSceneGraph/branches/OpenSceneGraph-2.8/src/osgPlugins/quicktime/QTUtils.h

    r8797 r9771  
    5050 
    5151#endif 
    52  
    53  
    54     /** 
    55      * inits Quicktime, if erase = true, the Quicktime-stuff gets cleaned, call it before your app exits 
    56      * @param erase true, if you want to cleanup quicktime-related stuff 
    57      */ 
    58     void initQuicktime(bool erase = false); 
    59      
    60     /** cleans up all quicktime-related stuff */ 
    61     void exitQuicktime(); 
    6252     
    6353    /** constructs an FSSpec out of an path */ 
  • OpenSceneGraph/branches/OpenSceneGraph-2.8/src/osgPlugins/quicktime/ReaderWriterQT.cpp

    r8972 r9771  
    3737using namespace osg; 
    3838 
    39 // This class is used as a helper to de-initialize 
    40 // properly quicktime, when the last media loaded  
    41 // with the quicktime plugin is released.  
    42 // All loaded media must be added to the observer  
    43 // (see ReaderWriterQT::readImage() function)  
    44 class QuicktimeExitObserver : public osg::Observer 
    45 { 
    46 public: 
    47  
    48    QuicktimeExitObserver () : _instanceCount(0) 
    49    { 
    50    } 
    51    virtual ~QuicktimeExitObserver() 
    52    { 
    53    }; 
    54  
    55    void addMedia(Image* ptr) 
    56    { 
    57       ptr->addObserver(this); 
    58       ++ _instanceCount; 
    59    } 
    60     
    61    virtual void objectDeleted(void*)  
    62    { 
    63       -- _instanceCount; 
    64       if(_instanceCount== 0) 
    65          exitQuicktime(); 
    66    } 
    67  
    68 private: 
    69    unsigned int _instanceCount; 
    70 }; 
    71  
    72  
    7339 
    7440class ReaderWriterQT : public osgDB::ReaderWriter 
    7541{ 
    7642public: 
     43 
     44 
     45    // This class is used as a helper to de-initialize 
     46    // properly quicktime, when the last media loaded  
     47    // with the quicktime plugin is released.  
     48    // All loaded media must be added to the observer  
     49    // (see ReaderWriterQT::readImage() function)  
     50    class QuicktimeInitializer : public osg::Observer 
     51    { 
     52    public: 
     53 
     54       QuicktimeInitializer ():  
     55          _instanceCount(0), 
     56             _setup(false) 
     57          {} 
     58 
     59          virtual ~QuicktimeInitializer() 
     60          { 
     61             // When we get here, the exit() function  
     62             // should have been called, when last media was released.  
     63             // In case no media has been added after initialization,  
     64             // let's perform an extra check 
     65             if (_setup && _instanceCount == 0) 
     66             { 
     67                exit(); 
     68             } 
     69          }; 
     70 
     71          void addMedia(Image* ptr) 
     72          { 
     73             ptr->addObserver(this); 
     74             ++ _instanceCount; 
     75          } 
     76 
     77          virtual void objectDeleted(void*)  
     78          { 
     79             -- _instanceCount; 
     80             if(_instanceCount== 0) 
     81                exit(); 
     82          } 
     83 
     84          void init() 
     85          { 
     86             if (!_setup) 
     87             { 
     88                #ifndef __APPLE__ 
     89                InitializeQTML(0); 
     90                #endif 
     91 
     92                OSErr err = EnterMovies(); 
     93                if (err!=0) 
     94                   osg::notify(osg::FATAL) << "Error while initializing quicktime: " << err << std::endl;  
     95                else 
     96                   osg::notify(osg::DEBUG_INFO) << "Quicktime initialized successfully"  << std::endl;             
     97 
     98                _setup = true;             
     99             } 
     100          } 
     101 
     102          void exit() 
     103          { 
     104             #ifndef __APPLE__ 
     105             ExitMovies(); 
     106             #endif 
     107 
     108             _setup = false; 
     109          } 
     110 
     111    private: 
     112       unsigned int _instanceCount; 
     113       bool _setup; 
     114 
     115    }; 
     116 
     117 
     118 
     119 
     120 
    77121    ReaderWriterQT::ReaderWriterQT() 
    78122    { 
     123 
     124       registerQtReader(); 
     125 
     126 
    79127        supportsExtension("mov","Movie format"); 
    80128        supportsExtension("mpg","Movie format"); 
     
    229277                  // and before any image or movie is loaded.  
    230278                  // After the first call the function does nothing.  
    231                   // The cleaning up is left to the QuicktimeExitObserver (see below) 
    232                   initQuicktime(); 
     279                  // The cleaning up is left to the QuicktimeInitializer (see below) 
     280                  _qtExitObserver.init(); 
     281 
    233282                  // 
    234283                  QuicktimeLiveImageStream* p_qt_image_stream = new QuicktimeLiveImageStream(osgDB::getNameLessExtension(file)); 
     
    253302      // and before any image or movie is loaded.  
    254303      // After the first call the function does nothing.  
    255       // The cleaning up is left to the QuicktimeExitObserver (see below) 
    256       initQuicktime(); 
     304      // The cleaning up is left to the QuicktimeInitializer (see below) 
     305      _qtExitObserver.init(); 
    257306 
    258307 
     
    317366            } 
    318367        } 
     368 
     369        _qtExitObserver.init(); 
    319370         
    320371        QuicktimeImportExport importer; 
     
    335386        if (!acceptsExtension(ext)) return WriteResult::FILE_NOT_HANDLED; 
    336387 
    337         initQuicktime(); 
     388        _qtExitObserver.init(); 
    338389 
    339390        //Buidl map  of extension <-> osFileTypes 
     
    387438        } 
    388439         
     440        _qtExitObserver.init(); 
     441 
    389442        QuicktimeImportExport exporter; 
    390443        exporter.writeToStream(os, const_cast<osg::Image*>(&img), filename); 
     
    396449    } 
    397450 
    398  
    399     mutable QuicktimeExitObserver _qtExitObserver; 
     451protected: 
     452 
     453   //internal utils 
     454   void registerQtReader() const 
     455   { 
     456      osgDB::Registry* r = osgDB::Registry::instance(); 
     457      r->addFileExtensionAlias("mov",  "qt"); 
     458 
     459      #ifdef QT_HANDLE_IMAGES_ALSO 
     460      r->addFileExtensionAlias("jpg",  "qt"); 
     461      r->addFileExtensionAlias("jpe",  "qt"); 
     462      r->addFileExtensionAlias("jpeg", "qt"); 
     463      r->addFileExtensionAlias("tif",  "qt"); 
     464      r->addFileExtensionAlias("tiff", "qt"); 
     465      r->addFileExtensionAlias("gif",  "qt"); 
     466      r->addFileExtensionAlias("png",  "qt"); 
     467      r->addFileExtensionAlias("psd",  "qt"); 
     468      r->addFileExtensionAlias("tga",  "qt"); 
     469      r->addFileExtensionAlias("mov",  "qt"); 
     470      r->addFileExtensionAlias("avi",  "qt"); 
     471      r->addFileExtensionAlias("mpg",  "qt"); 
     472      r->addFileExtensionAlias("mpv",  "qt"); 
     473      r->addFileExtensionAlias("dv",   "qt"); 
     474      r->addFileExtensionAlias("mp4",  "qt"); 
     475      r->addFileExtensionAlias("m4v",  "qt");          
     476      #endif 
     477   } 
     478 
     479    mutable QuicktimeInitializer _qtExitObserver; 
    400480}; 
    401481