comparison data/fileio/QuickTimeFileReader.cpp @ 285:20028c634494

* change some QStrings to std::strings etc

     Movie                        movie;
     size_t                       blockSize;
 };
 
 
-QuickTimeFileReader::QuickTimeFileReader(QString path,
+QuickTimeFileReader::QuickTimeFileReader(std::string path,
                                          DecodeMode decodeMode,
                                          CacheMode mode) :
     CodedAudioFileReader(mode),
     m_path(path),
     m_d(new D),

 #ifdef WIN32
     InitializeQTML(0); // FIXME should check QT version
 #else
     m_d->err = Gestalt(gestaltQuickTime,&QTversion);
     if ((m_d->err != noErr) || (QTversion < 0x07000000)) {
-        m_error = QString("Failed to find compatible version of QuickTime (version 7 or above required)");
+        setError("Failed to find compatible version of QuickTime (version 7 or above required)");
         return;
     }
 #endif 
 
     EnterMovies();

 //    m_d->err = QTNewDataReferenceFromURLCFString
     m_d->err = QTNewDataReferenceFromCFURL
         (url, 0, &dataRef, &dataRefType);
 
     if (m_d->err) { 
-        m_error = QString("Error creating data reference for QuickTime decoder: code %1").arg(m_d->err);
+        setError("Error creating data reference for QuickTime decoder", m_d->err);
         return;
     }
     
     short fileID = movieInDataForkResID; 
     short flags = 0; 
     m_d->err = NewMovieFromDataRef
         (&m_d->movie, flags, &fileID, dataRef, dataRefType);
 
     DisposeHandle(dataRef);
     if (m_d->err) { 
-        m_error = QString("Error creating new movie for QuickTime decoder: code %1").arg(m_d->err); 
+        setError("Error creating new movie for QuickTime decoder", m_d->err); 
         return;
     }
 
     Boolean isProtected = 0;
     Track aTrack = GetMovieIndTrackType

     } else {
         m_d->err = 1;
     }
 	
     if (m_d->err && m_d->err != kQTPropertyNotSupportedErr) { 
-        m_error = QString("Error checking for DRM in QuickTime decoder: code %1").arg(m_d->err);
+        setError("Error checking for DRM in QuickTime decoder", m_d->err);
         return;
     } else if (!m_d->err && isProtected) { 
-        m_error = QString("File is protected with DRM");
+        setError("File is protected with DRM");
         return;
     } else if (m_d->err == kQTPropertyNotSupportedErr && !isProtected) {
         std::cerr << "QuickTime: File is not protected with DRM" << std::endl;
     }
 
     if (m_d->movie) {
         SetMovieActive(m_d->movie, TRUE);
         m_d->err = GetMoviesError();
         if (m_d->err) {
-            m_error = QString("Error in QuickTime decoder activation: code %1").arg(m_d->err);
+            setError("Error in QuickTime decoder activation", m_d->err);
             return;
         }
     } else {
-	m_error = QString("Error in QuickTime decoder: Movie object not valid");
+	setError("Error in QuickTime decoder: Movie object not valid");
 	return;
     }
     
     m_d->err = MovieAudioExtractionBegin
         (m_d->movie, 0, &m_d->extractionSessionRef);
     if (m_d->err) {
-        m_error = QString("Error in QuickTime decoder extraction init: code %1").arg(m_d->err);
+        setError("Error in QuickTime decoder extraction init", m_d->err);
         return;
     }
 
     m_d->err = MovieAudioExtractionGetProperty
         (m_d->extractionSessionRef,

          sizeof(m_d->asbd),
          &m_d->asbd,
          nil);
 
     if (m_d->err) {
-        m_error = QString("Error in QuickTime decoder property get: code %1").arg(m_d->err);
+        setError("Error in QuickTime decoder property get", m_d->err);
         return;
     }
 	
     m_channelCount = m_d->asbd.mChannelsPerFrame;
     m_sampleRate = m_d->asbd.mSampleRate;

          kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription,
          sizeof(m_d->asbd),
          &m_d->asbd);
 
     if (m_d->err) {
-        m_error = QString("Error in QuickTime decoder property set: code %1").arg(m_d->err);
+        setError("Error in QuickTime decoder property set", m_d->err);
         return;
     }
 
     m_d->buffer.mNumberBuffers = 1;
     m_d->buffer.mBuffers[0].mNumberChannels = m_channelCount;

     initialiseDecodeCache();
 
     if (decodeMode == DecodeAtOnce) {
 
 	m_progress = new QProgressDialog
-	    (QObject::tr("Decoding %1...").arg(QFileInfo(path).fileName()),
+	    (QObject::tr("Decoding %1...").arg(QFileInfo(path.c_str()).fileName()),
 	     QObject::tr("Stop"), 0, 100);
 	m_progress->hide();
 
         while (1) {
             

             UInt32 extractionFlags = 0;
             m_d->err = MovieAudioExtractionFillBuffer
                 (m_d->extractionSessionRef, &framesRead, &m_d->buffer,
                  &extractionFlags);
             if (m_d->err) {
-                m_error = QString("Error in QuickTime decoding: code %1")
-                    .arg(m_d->err);
+                setError("Error in QuickTime decoding", m_d->err);
                 break;
             }
 
 //    std::cerr << "Read " << framesRead << " frames (block size " << m_d->blockSize << ")" << std::endl;
 

         
         finishDecodeCache();
 
         m_d->err = MovieAudioExtractionEnd(m_d->extractionSessionRef);
         if (m_d->err) {
-            m_error = QString("Error ending QuickTime extraction session: code %1").arg(m_d->err);
+            setError("Error ending QuickTime extraction session", m_d->err);
         }
 
         m_completion = 100;
 
         delete m_progress;

             m_decodeThread = new DecodeThread(this);
             m_decodeThread->start();
         }
     }
 
-    std::cerr << "QuickTimeFileReader::QuickTimeFileReader: frame count is now " << getFrameCount() << ", error is \"\"" << m_error.toStdString() << "\"" << std::endl;
+    std::cerr << "QuickTimeFileReader::QuickTimeFileReader: frame count is now " << getFrameCount() << ", error is \"\"" << m_error << "\"" << std::endl;
 }
 
 QuickTimeFileReader::~QuickTimeFileReader()
 {
     std::cerr << "QuickTimeFileReader::~QuickTimeFileReader" << std::endl;

         UInt32 extractionFlags = 0;
         m_reader->m_d->err = MovieAudioExtractionFillBuffer
             (m_reader->m_d->extractionSessionRef, &framesRead,
              &m_reader->m_d->buffer, &extractionFlags);
         if (m_reader->m_d->err) {
-            m_reader->m_error = QString("Error in QuickTime decoding: code %1")
-                .arg(m_reader->m_d->err);
+            m_reader->setError("Error in QuickTime decoding",
+                               m_reader->m_d->err);
             break;
         }
        
         m_reader->m_frameCount += framesRead;
  

         
     m_reader->finishDecodeCache();
     
     m_reader->m_d->err = MovieAudioExtractionEnd(m_reader->m_d->extractionSessionRef);
     if (m_reader->m_d->err) {
-        m_reader->m_error = QString("Error ending QuickTime extraction session: code %1").arg(m_reader->m_d->err);
+        m_reader->setError("Error ending QuickTime extraction session", m_reader->m_d->err);
     }
     
     m_reader->m_completion = 100;
 } 
 
 void
-QuickTimeFileReader::getSupportedExtensions(std::set<QString> &extensions)
+QuickTimeFileReader::getSupportedExtensions(std::set<std::string> &extensions)
 {
     extensions.insert("aiff");
     extensions.insert("au");
     extensions.insert("avi");
     extensions.insert("m4a");