FCL/sf/mw/qt: comparison src/3rdparty/phonon/qt7/quicktimevideoplayer.mm

equal deleted inserted replaced

-:b72c6db6890b
+:5dc02b23752f
 #include "quicktimevideoplayer.h"
 #include "mediaobject.h"
 #include "videowidget.h"
 #include "audiodevice.h"
 #include "quicktimestreamreader.h"
-#include "quicktimemetadata.h"
 #include <QtCore/QCoreApplication>
 #include <QtCore/QEventLoop>
 #include <QtCore/QFileInfo>
 #include <QtCore/QUrl>
 QuickTimeVideoPlayer::QuickTimeVideoPlayer() : QObject(0)
 {
 m_state = NoMedia;
 m_mediaSource = MediaSource();
-m_metaData = new QuickTimeMetaData(this);
 m_QTMovie = 0;
 m_streamReader = 0;
 m_playbackRate = 1.0f;
 m_masterVolume = 1.0f;
 m_relativeVolume = 1.0f;
 m_currentTime = 0;
 m_mute = false;
 m_audioEnabled = false;
 m_hasVideo = false;
-m_staticFps = 0;
 m_playbackRateSat = false;
 m_isDrmProtected = false;
 m_isDrmAuthorized = true;
 	m_primaryRenderingTarget = 0;
 	m_primaryRenderingCIImage = 0;
 m_QImagePixelBuffer = 0;
-m_cachedCVTextureRef = 0;
-m_folderTracks = 0;
-m_currentTrack = 0;
 #ifdef QUICKTIME_C_API_AVAILABLE
 OSStatus err = EnterMovies();
 BACKEND_ASSERT2(err == noErr, "Could not initialize QuickTime", FATAL_ERROR)
 	createVisualContext();
 #endif
 }
 QuickTimeVideoPlayer::~QuickTimeVideoPlayer()
 {
-	PhononAutoReleasePool pool;
+unsetVideo();
-unsetCurrentMediaSource();
-delete m_metaData;
 [(NSObject*)m_primaryRenderingTarget release];
 m_primaryRenderingTarget = 0;
 #ifdef QUICKTIME_C_API_AVAILABLE
 if (m_visualContext)
 CFRelease(m_visualContext);
 #endif
-}
-void QuickTimeVideoPlayer::releaseImageCache()
-{
-if (m_cachedCVTextureRef){
-CVOpenGLTextureRelease(m_cachedCVTextureRef);
-m_cachedCVTextureRef = 0;
-}
-m_cachedQImage = QImage();
 }
 void QuickTimeVideoPlayer::createVisualContext()
 {
 #ifdef QUICKTIME_C_API_AVAILABLE
 		return true;
 if (!m_visualContext)
 		return false;
 QTVisualContextTask(m_visualContext);
-bool changed = QTVisualContextIsNewImageAvailable(m_visualContext, 0);
+return QTVisualContextIsNewImageAvailable(m_visualContext, 0);
-if (changed)
-releaseImageCache();
-return changed;
 #elif defined(QT_MAC_USE_COCOA)
 return true;
 #else
 CVOpenGLTextureRef QuickTimeVideoPlayer::currentFrameAsCVTexture()
 {
 #ifdef QUICKTIME_C_API_AVAILABLE
 if (!m_visualContext)
 return 0;
-if (!m_cachedCVTextureRef){
+CVOpenGLTextureRef texture = 0;
-OSStatus err = QTVisualContextCopyImageForTime(m_visualContext, 0, 0, &m_cachedCVTextureRef);
+OSStatus err = QTVisualContextCopyImageForTime(m_visualContext, 0, 0, &texture);
 BACKEND_ASSERT3(err == noErr, "Could not copy image for time in QuickTime player", FATAL_ERROR, 0)
-}
+return texture;
-return m_cachedCVTextureRef;
 #else
 return 0;
 #endif
 }
 QImage QuickTimeVideoPlayer::currentFrameAsQImage()
 {
-if (!m_cachedQImage.isNull())
-return m_cachedQImage;
 #ifdef QUICKTIME_C_API_AVAILABLE
 QGLContext *prevContext = const_cast<QGLContext *>(QGLContext::currentContext());
 CVOpenGLTextureRef texture = currentFrameAsCVTexture();
 GLenum target = CVOpenGLTextureGetTarget(texture);
 GLfloat lowerLeft[2], lowerRight[2], upperRight[2], upperLeft[2];
 glVertex2i(1, -1);
 glTexCoord2f(upperLeft[0], upperLeft[1]);
 glVertex2i(-1, -1);
 glEnd();
-m_cachedQImage = m_QImagePixelBuffer->toImage();
+QImage image = m_QImagePixelBuffer->toImage();
+CVOpenGLTextureRelease(texture);
 // Because of QuickTime, m_QImagePixelBuffer->doneCurrent() will fail.
 // So we store, and restore, the context our selves:
 prevContext->makeCurrent();
-return m_cachedQImage;
+return image;
 #else
 	CIImage *img = (CIImage *)currentFrameAsCIImage();
 	if (!img)
 		return QImage();
 	NSBitmapImageRep* bitmap = [[NSBitmapImageRep alloc] initWithCIImage:img];
 	CGRect bounds = [img extent];
 	QImage qImg([bitmap bitmapData], bounds.size.width, bounds.size.height, QImage::Format_ARGB32);
-	m_cachedQImage = qImg.rgbSwapped();
+	QImage swapped = qImg.rgbSwapped();
 	[bitmap release];
 	[img release];
-	return m_cachedQImage;
+	return swapped;
 #endif
 }
 void QuickTimeVideoPlayer::setPrimaryRenderingCIImage(void *ciImage)
 {
 #endif
 #ifdef QUICKTIME_C_API_AVAILABLE
 	CVOpenGLTextureRef cvImg = currentFrameAsCVTexture();
 	CIImage *img = [[CIImage alloc] initWithCVImageBuffer:cvImg];
-	return img;
+	CVOpenGLTextureRelease(cvImg);
+	return img;
 #else
 	return 0;
 #endif
 }
 glBindTexture(GL_TEXTURE_RECTANGLE_EXT, texName);
 glTexParameteri(GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MIN_FILTER,  GL_LINEAR);
 int samplesPerPixel = [bitmap samplesPerPixel];
 if (![bitmap isPlanar] && (samplesPerPixel == 3 || samplesPerPixel == 4)){
 glTexImage2D(GL_TEXTURE_RECTANGLE_EXT, 0,
 samplesPerPixel == 4 ? GL_RGBA8 : GL_RGB8,
 [bitmap pixelsWide], [bitmap pixelsHigh],
 0, samplesPerPixel == 4 ? GL_RGBA : GL_RGB,
 GL_UNSIGNED_BYTE, [bitmap bitmapData]);
 } else {
 void QuickTimeVideoPlayer::setVolume(float masterVolume, float relativeVolume)
 {
 m_masterVolume = masterVolume;
 m_relativeVolume = relativeVolume;
 if (!m_QTMovie || !m_audioEnabled || m_mute)
 return;
 [m_QTMovie setVolume:(m_masterVolume * m_relativeVolume)];
 }
 void QuickTimeVideoPlayer::setMute(bool mute)
 {
 m_mute = mute;
 if (!m_QTMovie || m_state != Playing || !m_audioEnabled)
 return;
 // Work-around bug that happends if you set/unset mute
 // before movie is playing, and audio is not played
 // through graph. Then audio is delayed.
 [m_QTMovie setMuted:mute];
 [m_QTMovie setVolume:(mute ? 0 : m_masterVolume * m_relativeVolume)];
 }
 m_audioEnabled = enable;
 if (!m_QTMovie || m_state != Playing)
 return;
 // Work-around bug that happends if you set/unset mute
 // before movie is playing, and audio is not played
 // through graph. Then audio is delayed.
 [m_QTMovie setMuted:(!enable || m_mute)];
 [m_QTMovie setVolume:((!enable || m_mute) ? 0 : m_masterVolume * m_relativeVolume)];
 }
 return false;
 #ifdef QUICKTIME_C_API_AVAILABLE
 // The following code will not work for some media codecs that
 // typically mingle audio/video frames (e.g mpeg).
 CFStringRef idString = PhononCFString::toCFStringRef(AudioDevice::deviceUID(id));
 QTAudioContextRef context;
 QTAudioContextCreateForAudioDevice(kCFAllocatorDefault, idString, 0, &context);
 OSStatus err = SetMovieAudioContext([m_QTMovie quickTimeMovie], context);
 CFRelease(context);
 if (err != noErr)
 // 0 is default value for the colors
 // in phonon, so adjust scale:
 contrast += 1;
 saturation += 1;
-if (m_brightness == brightness
-&& m_contrast == contrast
-&& m_hue == hue
-&& m_saturation == saturation)
-return;
 	m_brightness = brightness;
 	m_contrast = contrast;
 	m_hue = hue;
 	m_saturation = saturation;
 #ifdef QUICKTIME_C_API_AVAILABLE
 Float32 value;
 value = brightness;
 SetMovieVisualBrightness([m_QTMovie quickTimeMovie], value, 0);
 value = contrast;
 value = hue;
 SetMovieVisualHue([m_QTMovie quickTimeMovie], value, 0);
 value = saturation;
 SetMovieVisualSaturation([m_QTMovie quickTimeMovie], value, 0);
 #endif
-releaseImageCache();
 }
 QRect QuickTimeVideoPlayer::videoRect() const
 {
 if (!m_QTMovie)
 	PhononAutoReleasePool pool;
 NSSize size = [[m_QTMovie attributeForKey:@"QTMovieCurrentSizeAttribute"] sizeValue];
 return QRect(0, 0, size.width, size.height);
 }
-void QuickTimeVideoPlayer::unsetCurrentMediaSource()
+void QuickTimeVideoPlayer::unsetVideo()
 {
 if (!m_QTMovie)
 return;
 [m_QTMovie release];
 m_streamReader = 0;
 m_currentTime = 0;
 m_state = NoMedia;
 m_isDrmProtected = false;
 m_isDrmAuthorized = true;
-m_hasVideo = false;
-m_staticFps = 0;
 m_mediaSource = MediaSource();
-m_movieCompactDiscPath.clear();
 	[(CIImage *)m_primaryRenderingCIImage release];
 	m_primaryRenderingCIImage = 0;
 delete m_QImagePixelBuffer;
 m_QImagePixelBuffer = 0;
-releaseImageCache();
-[m_folderTracks release];
-m_folderTracks = 0;
 }
 QuickTimeVideoPlayer::State QuickTimeVideoPlayer::state() const
 {
 return m_state;
 }
 void QuickTimeVideoPlayer::setMediaSource(const MediaSource &mediaSource)
 {
 PhononAutoReleasePool pool;
-unsetCurrentMediaSource();
+unsetVideo();
 m_mediaSource = mediaSource;
 if (mediaSource.type() == MediaSource::Empty || mediaSource.type() == MediaSource::Invalid){
 m_state = NoMedia;
 return;
 }
 openMovieFromCurrentMediaSource();
 if (errorOccured()){
-unsetCurrentMediaSource();
+unsetVideo();
 return;
 }
-prepareCurrentMovieForPlayback();
-}
-void QuickTimeVideoPlayer::prepareCurrentMovieForPlayback()
-{
 #ifdef QUICKTIME_C_API_AVAILABLE
 if (m_visualContext)
 SetMovieVisualContext([m_QTMovie quickTimeMovie], m_visualContext);
 #endif
 waitStatePlayable();
 if (errorOccured()){
-unsetCurrentMediaSource();
+unsetVideo();
 return;
 }
 readProtection();
 preRollMovie();
 if (errorOccured()){
-unsetCurrentMediaSource();
+unsetVideo();
 return;
 }
 if (!m_playbackRateSat)
 m_playbackRate = prefferedPlaybackRate();
 checkIfVideoAwailable();
-calculateStaticFps();
 enableAudio(m_audioEnabled);
 setMute(m_mute);
 setVolume(m_masterVolume, m_relativeVolume);
-m_metaData->update();
 pause();
 }
 void QuickTimeVideoPlayer::openMovieFromCurrentMediaSource()
 {
 break;
 case MediaSource::Url:
 openMovieFromUrl();
 break;
 case MediaSource::Disc:
-openMovieFromCompactDisc();
+CASE_UNSUPPORTED("Could not open media source.", FATAL_ERROR)
 break;
 case MediaSource::Stream:
 openMovieFromStream();
 break;
 case MediaSource::Empty:
 {
 // It turns out to be better to just try the standard file types rather
 // than using e.g [QTMovie movieFileTypes:QTIncludeCommonTypes]. Some
 // codecs *think* they can decode the stream, and crash...
 #define TryOpenMovieWithCodec(type) gClearError(); \
-openMovieFromData(data, (char *)"."type); \
+openMovieFromData(data, "."type); \
 if (m_QTMovie) return;
 TryOpenMovieWithCodec("avi");
 TryOpenMovieWithCodec("mp4");
 TryOpenMovieWithCodec("m4p");
 if (!m_streamReader->readAllData())
 return;
 openMovieFromDataGuessType(m_streamReader->pointerToData());
 }
-typedef void (*qt_sighandler_t)(int);
-static void sigtest(int) {
-qApp->exit(0);
-}
-void QuickTimeVideoPlayer::openMovieFromCompactDisc()
-{
-// Interrupting the application while the device is open
-// causes the application to hang. So we need to handle
-// this in a more graceful way:
-qt_sighandler_t hndl = signal(SIGINT, sigtest);
-if (hndl)
-signal(SIGINT, hndl);
-PhononAutoReleasePool pool;
-NSString *cd = 0;
-QString devName = m_mediaSource.deviceName();
-if (devName.isEmpty()) {
-cd = pathToCompactDisc();
-if (!cd) {
-SET_ERROR("Could not open media source.", NORMAL_ERROR)
-return;
-}
-m_movieCompactDiscPath = PhononCFString::toQString(reinterpret_cast<CFStringRef>(cd));
-} else {
-if (!QFileInfo(devName).isAbsolute())
-devName = QLatin1String("/Volumes/") + devName;
-cd = [reinterpret_cast<const NSString *>(PhononCFString::toCFStringRef(devName)) autorelease];
-if (!isCompactDisc(cd)) {
-SET_ERROR("Could not open media source.", NORMAL_ERROR)
-return;
-}
-m_movieCompactDiscPath = devName;
-}
-m_folderTracks = [scanFolder(cd) retain];
-setCurrentTrack(0);
-}
-QString QuickTimeVideoPlayer::movieCompactDiscPath() const
-{
-return m_movieCompactDiscPath;
-}
 MediaSource QuickTimeVideoPlayer::mediaSource() const
 {
 return m_mediaSource;
 }
 if (!m_QTMovie)
 return 0;
 	PhononAutoReleasePool pool;
 return [[m_QTMovie attributeForKey:@"QTMovieTimeScaleAttribute"] longValue];
-}
-float QuickTimeVideoPlayer::staticFps()
-{
-return m_staticFps;
-}
-void QuickTimeVideoPlayer::calculateStaticFps()
-{
-if (!m_hasVideo){
-m_staticFps = 0;
-return;
-}
-#ifdef QT_ALLOW_QUICKTIME
-Boolean isMpeg = false;
-Track videoTrack = GetMovieIndTrackType([m_QTMovie quickTimeMovie], 1,
-FOUR_CHAR_CODE('vfrr'), // 'vfrr' means: has frame rate
-movieTrackCharacteristic | movieTrackEnabledOnly);
-Media media = GetTrackMedia(videoTrack);
-MediaHandler mediaH = GetMediaHandler(media);
-MediaHasCharacteristic(mediaH, FOUR_CHAR_CODE('mpeg'), &isMpeg);
-if (isMpeg){
-MHInfoEncodedFrameRateRecord frameRate;
-Size frameRateSize = sizeof(frameRate);
-MediaGetPublicInfo(mediaH, kMHInfoEncodedFrameRate, &frameRate, &frameRateSize);
-m_staticFps = float(Fix2X(frameRate.encodedFrameRate));
-} else {
-Media media = GetTrackMedia(videoTrack);
-long sampleCount = GetMediaSampleCount(media);
-TimeValue64 duration = GetMediaDisplayDuration(media);
-TimeValue64 timeScale = GetMediaTimeScale(media);
-m_staticFps = float((double)sampleCount * (double)timeScale / (double)duration);
-}
-#else
-m_staticFps = 30.0f;
-#endif
 }
 QString QuickTimeVideoPlayer::timeToString(quint64 ms)
 {
 int sec = ms/1000;
 if (!isDrmAuthorized)
 m_isDrmAuthorized = false;
 }
 }
-QMultiMap<QString, QString> QuickTimeVideoPlayer::metaData()
-{
-return m_metaData->metaData();
-}
-int QuickTimeVideoPlayer::trackCount() const
-{
-if (!m_folderTracks)
-return 0;
-return [m_folderTracks count];
-}
-int QuickTimeVideoPlayer::currentTrack() const
-{
-return m_currentTrack;
-}
-QString QuickTimeVideoPlayer::currentTrackPath() const
-{
-if (!m_folderTracks)
-return QString();
-PhononAutoReleasePool pool;
-NSString *trackPath = [m_folderTracks objectAtIndex:m_currentTrack];
-return PhononCFString::toQString(reinterpret_cast<CFStringRef>(trackPath));
-}
-NSString* QuickTimeVideoPlayer::pathToCompactDisc()
-{
-PhononAutoReleasePool pool;
-NSArray *devices = [[NSWorkspace sharedWorkspace] mountedRemovableMedia];
-for (unsigned int i=0; i<[devices count]; ++i) {
-NSString *dev = [devices objectAtIndex:i];
-if (isCompactDisc(dev))
-return [dev retain];
-}
-return 0;
-}
-bool QuickTimeVideoPlayer::isCompactDisc(NSString *path)
-{
-PhononAutoReleasePool pool;
-NSString *type = [NSString string];
-[[NSWorkspace sharedWorkspace] getFileSystemInfoForPath:path
-isRemovable:0
-isWritable:0
-isUnmountable:0
-description:0
-type:&type];
-return [type hasPrefix:@"cdd"];
-}
-NSArray* QuickTimeVideoPlayer::scanFolder(NSString *path)
-{
-NSMutableArray *tracks = [NSMutableArray arrayWithCapacity:20];
-if (!path)
-return tracks;
-NSDirectoryEnumerator *enumerator = [[NSFileManager defaultManager] enumeratorAtPath:path];
-while (NSString *track = [enumerator nextObject]) {
-if (![track hasPrefix:@"."])
-[tracks addObject:[path stringByAppendingPathComponent:track]];
-}
-return tracks;
-}
-void QuickTimeVideoPlayer::setCurrentTrack(int track)
-{
-PhononAutoReleasePool pool;
-[m_QTMovie release];
-	m_QTMovie = 0;
-m_currentTime = 0;
-m_currentTrack = track;
-if (!m_folderTracks)
-return;
-if (track < 0 || track >= (int)[m_folderTracks count])
-return;
-NSString *trackPath = [m_folderTracks objectAtIndex:track];
-QTDataReference *dataRef = [QTDataReference dataReferenceWithReferenceToFile:trackPath];
-State currentState = m_state;
-openMovieFromDataRef(dataRef);
-prepareCurrentMovieForPlayback();
-if (currentState == Playing)
-play();
-}
 }}
 QT_END_NAMESPACE

changeset 30	5dc02b23752f
parent 0	1918ee327afb