source: trunk/src/3rdparty/phonon/qt7/videowidget.mm

Last change on this file was 2, checked in by Dmitry A. Kuminov, 17 years ago

Initially imported qt-all-opensource-src-4.5.1 from Trolltech.
File size: 24.3 KB
Line 
1/* This file is part of the KDE project.
2
3 Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4
5 This library is free software: you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation, either version 2.1 or 3 of the License.
8
9 This library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public License
15 along with this library. If not, see <http://www.gnu.org/licenses/>.
16*/
17
18#include <QtCore/qglobal.h>
19#ifdef QT_MAC_USE_COCOA
20#import <QTKit/QTMovieLayer.h>
21#endif
22
23#include "videowidget.h"
24#include "backendheader.h"
25#include "quicktimevideoplayer.h"
26#include "medianode.h"
27#include "medianodeevent.h"
28#include "mediaobject.h"
29
30#include <QtOpenGL/QGLWidget>
31#include <QtCore/QTime>
32#include <QtCore/QEvent>
33#include <QtCore/QCoreApplication>
34
35#import <AppKit/NSImage.h>
36#import <QTKit/QTMovieView.h>
37
38/////////////////////////////////////////////////////////////////////////////////////////
39
40#ifdef QT_MAC_USE_COCOA // Rendering to a QTMovieView can only be done in Cocoa
41
42#define VIDEO_TRANSPARENT(m) -(void)m:(NSEvent *)e{[[self superview] m:e];}
43
44@interface SharedQTMovieView : QTMovieView
45{
46@private
47 Phonon::QT7::QuickTimeVideoPlayer *m_player;
48 QList<QWidget *> *m_parents;
49 QWidget *m_window;
50 QRect *m_drawRect;
51 bool m_newImageReady;
52 bool m_usingWindow;
53}
54
55- (SharedQTMovieView *) init;
56- (void) registerParent:(QWidget *)parent;
57- (void) unregisterParent:(QWidget *)parent;
58- (void) setDrawRect:(QRect &)rect;
59- (void) drawVideoFrame:(Phonon::QT7::VideoFrame &)frame forWidget:(QWidget *)widget shareImages:(bool)share;
60- (void) useOffscreenWindow:(bool)offscreen;
61- (void) applyDrawRectOnSelf;
62@end
63
64/////////////////////////////////////////////////////////////////////////////////////////
65
66@implementation SharedQTMovieView
67
68- (SharedQTMovieView *) init
69{
70 self = [super initWithFrame:NSZeroRect];
71 if (self){
72 [self setControllerVisible:NO];
73 m_parents = new QList<QWidget *>();
74 m_drawRect = new QRect(0, 0, 1, 1);
75 [self applyDrawRectOnSelf];
76 m_usingWindow = false;
77 }
78 return self;
79}
80
81- (void) dealloc
82{
83 Phonon::QT7::PhononAutoReleasePool pool;
84 delete m_window;
85 delete m_drawRect;
86 delete m_parents;
87 [super dealloc];
88}
89
90- (void) applyDrawRectOnSelf
91{
92 NSRect nsrect;
93 nsrect.origin.x = m_drawRect->x();
94 nsrect.origin.y = m_drawRect->y();
95 nsrect.size.width = m_drawRect->width();
96 nsrect.size.height = m_drawRect->height();
97 [self setFrame:nsrect];
98}
99
100- (void) setDrawRect:(QRect &)rect
101{
102 *m_drawRect = rect;
103 if (!m_usingWindow)
104 [self applyDrawRectOnSelf];
105}
106
107- (void) waitForFrame
108{
109 if (m_usingWindow){
110 QTMovie *movie = [self movie];
111 if (movie){
112 // CIImages are expected, but not received.
113 // Try to wait a couple of seconds for them:
114 m_newImageReady = false;
115 float rate = [movie rate];
116 if (!rate)
117 [movie setRate:1];
118 QTime t; t.start();
119 while (!m_newImageReady && t.elapsed() < 2000)
120 ;
121 [movie setRate:rate];
122 }
123 }
124}
125
126- (void) useOffscreenWindow:(bool)offscreen
127{
128 if (offscreen == m_usingWindow)
129 return;
130 if (offscreen){
131 if (!m_window){
132 m_window = new QWidget;
133 m_window->setWindowOpacity(0.0);
134 m_window->show();
135 m_window->hide();
136 }
137 m_usingWindow = true;
138 [self setDelegate:self];
139 [self waitForFrame];
140 foreach(QWidget *w, *m_parents)
141 w->repaint();
142 qApp->processEvents();
143 [self removeFromSuperview];
144 [(NSView *)m_window->winId() addSubview:self];
145 } else if (!m_parents->isEmpty()){
146 m_usingWindow = false;
147 [self removeFromSuperview];
148 [(NSView*)m_parents->first()->winId() addSubview:self];
149 [self setDelegate:0];
150 [self setDrawRect:*m_drawRect];
151 }
152}
153
154- (void) drawVideoFrame:(Phonon::QT7::VideoFrame &)frame forWidget:(QWidget *)widget shareImages:(bool)share;
155{
156 // Detect if the video that produces the frame has changed:
157 Phonon::QT7::QuickTimeVideoPlayer *player = frame.videoPlayer();
158 if (player && player->qtMovie() != [self movie]){
159 m_player = player;
160 [self setMovie:player->qtMovie()];
161 [self waitForFrame];
162 }
163
164 [self useOffscreenWindow:(share || m_parents->size() > 1)];
165 if (m_usingWindow)
166 widget->update();
167}
168
169// Override this method so that the movie doesn't stop if
170// the window becomes invisible
171- (void)viewWillMoveToWindow:(NSWindow *)newWindow
172{
173 Q_UNUSED(newWindow);
174}
175
176- (CIImage *) view:(QTMovieView *)view willDisplayImage:(CIImage *)img
177{
178 // This method is called from QTMovieView just
179 // before the image will be drawn.
180 Q_UNUSED(view);
181 m_player->setPrimaryRenderingCIImage(img);
182 m_newImageReady = true;
183 return img;
184}
185
186- (void) registerParent:(QWidget *)parent
187{
188 if (m_parents->contains(parent))
189 return;
190 m_parents->append(parent);
191 if (m_parents->size() == 1){
192 Phonon::QT7::PhononAutoReleasePool pool;
193 m_usingWindow = true;
194 [self applyDrawRectOnSelf];
195 [self useOffscreenWindow:NO];
196 }
197}
198
199- (void) unregisterParent:(QWidget *)parent
200{
201 m_parents->removeAll(parent);
202 if (m_parents->size() == 1)
203 [self applyDrawRectOnSelf];
204}
205
206VIDEO_TRANSPARENT(mouseDown);
207VIDEO_TRANSPARENT(mouseDragged);
208VIDEO_TRANSPARENT(mouseUp);
209VIDEO_TRANSPARENT(mouseMoved);
210VIDEO_TRANSPARENT(mouseEntered);
211VIDEO_TRANSPARENT(mouseExited);
212VIDEO_TRANSPARENT(rightMouseDown);
213VIDEO_TRANSPARENT(rightMouseDragged);
214VIDEO_TRANSPARENT(rightMouseUp);
215VIDEO_TRANSPARENT(otherMouseDown);
216VIDEO_TRANSPARENT(otherMouseDragged);
217VIDEO_TRANSPARENT(otherMouseUp);
218VIDEO_TRANSPARENT(keyDown);
219VIDEO_TRANSPARENT(keyUp);
220VIDEO_TRANSPARENT(scrollWheel)
221
222@end
223
224#endif // QT_MAC_USE_COCOA
225
226/////////////////////////////////////////////////////////////////////////////////////////
227
228QT_BEGIN_NAMESPACE
229
230namespace Phonon
231{
232namespace QT7
233{
234
235class IVideoRenderDrawWidget
236{
237public:
238 virtual ~IVideoRenderDrawWidget(){}
239 virtual void setVideoFrame(VideoFrame &) = 0;
240 virtual void setDrawFrameRect(const QRect &) = 0;
241 virtual void updateVideoOutputCount(int){}
242 virtual void setMovieIsPaused(bool){}
243};
244
245/////////////////////////////////////////////////////////////////////////////////////////
246
247QGLWidget *PhononSharedQGLWidget(){
248 static QGLWidget *glWidget = 0;
249 if (!glWidget)
250 glWidget = new QGLWidget();
251 return glWidget;
252}
253
254/////////////////////////////////////////////////////////////////////////////////////////
255
256class RenderOpenGL : public QGLWidget, public IVideoRenderDrawWidget
257{
258public:
259 VideoFrame m_currentFrame;
260 QRect m_drawFrameRect;
261
262 RenderOpenGL(QWidget *parent, const QGLFormat &format, const QSize &size) : QGLWidget(format, parent, PhononSharedQGLWidget())
263 {
264 resize(size);
265 setAutoFillBackground(false);
266 show();
267 }
268
269 void initializeGL()
270 {
271 glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
272 }
273
274 void resizeGL(int w, int h)
275 {
276 glMatrixMode(GL_MODELVIEW);
277 glLoadIdentity();
278 glMatrixMode(GL_PROJECTION);
279 glLoadIdentity();
280 glViewport(0, 0, GLsizei(w), GLsizei(h));
281 gluOrtho2D(0, GLsizei(w), 0, GLsizei(h));
282 updateGL();
283 }
284
285 void paintGL()
286 {
287 glClear(GL_COLOR_BUFFER_BIT);
288 m_currentFrame.drawCVTexture(m_drawFrameRect);
289 }
290
291 void setVideoFrame(VideoFrame &frame)
292 {
293 m_currentFrame = frame;
294 makeCurrent();
295 paintGL();
296 swapBuffers();
297 }
298
299 void setDrawFrameRect(const QRect &rect)
300 {
301 m_drawFrameRect = rect;
302 }
303};
304
305/////////////////////////////////////////////////////////////////////////////////////////
306
307class RenderQTMovieView : public QWidget, public IVideoRenderDrawWidget
308{
309public:
310#if defined(QT_MAC_USE_COCOA)
311 QRect m_drawRect;
312 VideoFrame m_videoFrame;
313 SharedQTMovieView *m_currentView;
314 bool m_setDrawRectPending;
315 bool m_share;
316
317 RenderQTMovieView(bool share, QWidget *parent, const QSize &size=QSize()) : QWidget(parent), m_currentView(0)
318 {
319 m_setDrawRectPending = true;
320 m_share = share;
321 setAutoFillBackground(false);
322 if (share){
323 // In 'share' mode, this widget will only make sure
324 // that CIIImages are produced, and not actually
325 // draw anything:
326 hide();
327 } else {
328 resize(size);
329 show();
330 }
331 }
332
333 ~RenderQTMovieView()
334 {
335 [m_currentView unregisterParent:this];
336 }
337
338 void showEvent(QShowEvent *)
339 {
340 if (m_share)
341 return;
342 [m_currentView registerParent:this];
343 }
344
345 void hideEvent(QHideEvent *)
346 {
347 if (m_share)
348 return;
349 [m_currentView unregisterParent:this];
350 }
351
352 void paintEvent(QPaintEvent *)
353 {
354 if (m_share)
355 return;
356 QPainter p(this);
357 p.fillRect(rect(), Qt::black);
358 m_videoFrame.drawCIImage(m_drawRect);
359 }
360
361 void updateVideoOutputCount(int count)
362 {
363 Q_UNUSED(count);
364 }
365
366 void setMovieIsPaused(bool paused)
367 {
368 Q_UNUSED(paused);
369 }
370
371 void setVideoFrame(VideoFrame &frame)
372 {
373 m_videoFrame = frame;
374
375 if (!m_videoFrame.isEmpty()){
376 Phonon::QT7::QuickTimeVideoPlayer *player = m_videoFrame.videoPlayer();
377 if (!player->m_primaryRenderingTarget){
378 // First movie view. Create the shared resource:
379 SharedQTMovieView *view = [[[SharedQTMovieView alloc] init] autorelease];
380 player->setPrimaryRenderingTarget(view);
381 }
382
383 SharedQTMovieView *view = static_cast<SharedQTMovieView *>(player->m_primaryRenderingTarget);
384 if (!m_share && view != m_currentView){
385 [m_currentView unregisterParent:this];
386 m_currentView = view;
387 [m_currentView registerParent:this];
388 }
389
390 [view drawVideoFrame:m_videoFrame forWidget:this shareImages:m_share || m_videoFrame.hasColorAdjustments()];
391
392 if (m_setDrawRectPending){
393 m_setDrawRectPending = false;
394 [view setDrawRect:m_drawRect];
395 }
396 }
397 }
398
399 void setDrawFrameRect(const QRect &rect)
400 {
401 m_drawRect = rect;
402 Phonon::QT7::QuickTimeVideoPlayer *player = m_videoFrame.videoPlayer();
403 if (player && player->m_primaryRenderingTarget){
404 SharedQTMovieView *view = static_cast<SharedQTMovieView *>(player->m_primaryRenderingTarget);
405 [view setDrawRect:m_drawRect];
406 } else
407 m_setDrawRectPending = true;
408 }
409
410#else // QT_MAC_USE_COCOA == false
411 RenderQTMovieView(bool, QWidget *, const QSize& = QSize()){}
412 void setVideoFrame(VideoFrame &){}
413 void setDrawFrameRect(const QRect &){}
414#endif
415};
416
417/////////////////////////////////////////////////////////////////////////////////////////
418
419class RenderQTMovieLayer : public QWidget, public IVideoRenderDrawWidget
420{
421public:
422#ifdef QT_MAC_USE_COCOA
423 QTMovieLayer *m_movieLayer;
424
425 RenderQTMovieLayer(QWidget *parent, const QSize&) : QWidget(parent)
426 {
427 PhononAutoReleasePool pool;
428 setAutoFillBackground(false);
429 m_movieLayer = 0;
430 [(NSView *)winId() setWantsLayer:YES];
431 }
432
433 void setVideoFrame(VideoFrame &frame)
434 {
435 QuickTimeVideoPlayer *player = frame.videoPlayer();
436 if (!player || player->qtMovie() == [m_movieLayer movie])
437 return;
438
439 if (m_movieLayer)
440 [m_movieLayer setMovie:player->qtMovie()];
441 else {
442 m_movieLayer = [QTMovieLayer layerWithMovie:player->qtMovie()];
443 [(NSView *)winId() setLayer:m_movieLayer];
444 }
445 }
446
447 void setDrawFrameRect(const QRect &rect)
448 {
449 m_movieLayer.frame.origin.x = rect.x();
450 m_movieLayer.frame.origin.y = rect.y();
451 m_movieLayer.frame.size.width = rect.width();
452 m_movieLayer.frame.size.height = rect.height();
453 }
454
455#else // QT_MAC_USE_COCOA == false
456 RenderQTMovieLayer(QWidget *, const QSize&){}
457 void setVideoFrame(VideoFrame &){}
458 void setDrawFrameRect(const QRect &){}
459#endif
460};
461
462/////////////////////////////////////////////////////////////////////////////////////////
463
464class VideoRenderWidget : public QWidget
465{
466public:
467 enum RenderSystem { RS_NoRendering = 0,
468 RS_QGLWidget = 1,
469 RS_QPainter = 2,
470 RS_CIImage = 3,
471 RS_CVTexture = 4,
472 RS_QImage = 5,
473 RS_QTMovieView = 6,
474 RS_QTMovieLayer = 7
475 } m_renderSystem;
476
477 VideoFrame m_currentFrame;
478 QRect m_movieFrameRect;
479 QRect m_drawFrameRect;
480 Phonon::VideoWidget::ScaleMode m_scaleMode;
481 Phonon::VideoWidget::AspectRatio m_aspect;
482 IVideoRenderDrawWidget *m_renderDrawWidget;
483
484 qreal m_brightness;
485 qreal m_contrast;
486 qreal m_hue;
487 qreal m_saturation;
488 qreal m_opacity;
489
490 VideoRenderWidget() : QWidget(0),
491 m_scaleMode(Phonon::VideoWidget::FitInView), m_aspect(Phonon::VideoWidget::AspectRatioAuto)
492 {
493 PhononAutoReleasePool pool;
494 m_brightness = 0;
495 m_contrast = 0;
496 m_hue = 0;
497 m_saturation = 0;
498 m_opacity = 1;
499 m_renderDrawWidget = 0;
500 m_renderSystem = RS_NoRendering;
501
502 setAutoFillBackground(false);
503 updateDrawFrameRect();
504 }
505
506 RenderSystem selectBestRenderSystem(){
507 if (!isVisible())
508 return RS_NoRendering;
509 else if (window() && window()->testAttribute(Qt::WA_DontShowOnScreen))
510 return RS_QPainter;
511 else {
512#ifdef QUICKTIME_C_API_AVAILABLE
513 return RS_QGLWidget;
514#else
515 return RS_QTMovieView;
516#endif
517 }
518 }
519
520 void setRenderSystem(RenderSystem renderSystem){
521 PhononAutoReleasePool pool;
522 static QString userSystem = qgetenv("PHONON_RENDER_SYSTEM");
523 if (!userSystem.isEmpty())
524 renderSystem = RenderSystem(userSystem.toInt());
525
526 if (m_renderSystem == renderSystem)
527 return;
528
529 m_renderSystem = renderSystem;
530 if (m_renderDrawWidget){
531 delete m_renderDrawWidget;
532 m_renderDrawWidget = 0;
533 }
534
535 switch (m_renderSystem){
536 case RS_QGLWidget:{
537 QGLFormat format = QGLFormat::defaultFormat();
538 format.setSwapInterval(1); // Vertical sync (avoid tearing)
539 m_renderDrawWidget = new RenderOpenGL(this, format, size());
540 break;}
541 case RS_QTMovieView:{
542 m_renderDrawWidget = new RenderQTMovieView(false, this, size());
543 break;}
544 case RS_QTMovieLayer:{
545 m_renderDrawWidget = new RenderQTMovieLayer(this, size());
546 break;}
547 case RS_QPainter:
548 case RS_CIImage:
549 case RS_CVTexture:
550 case RS_QImage:
551#ifndef QUICKTIME_C_API_AVAILABLE
552 // On cocoa-64, let QTMovieView produce
553 // video frames for us:
554 m_renderDrawWidget = new RenderQTMovieView(true, this);
555#endif
556 break;
557 case RS_NoRendering:
558 break;
559 }
560
561 if (m_renderDrawWidget){
562 m_renderDrawWidget->setVideoFrame(m_currentFrame);
563 m_renderDrawWidget->setDrawFrameRect(m_drawFrameRect);
564 }
565 }
566
567 QSize sizeHint() const
568 {
569 return m_movieFrameRect.size();
570 }
571
572 bool event(QEvent *event)
573 {
574 switch (event->type()){
575 // Try to detect if one of this objects
576 // anchestors might have changed:
577 case QEvent::Resize:{
578 PhononAutoReleasePool pool;
579 updateDrawFrameRect();
580 if (m_renderDrawWidget)
581 dynamic_cast<QWidget *>(m_renderDrawWidget)->resize(size());
582 break; }
583 case QEvent::Paint:{
584 PhononAutoReleasePool pool;
585 float opacity = parentWidget() ? parentWidget()->windowOpacity() : 1;
586 switch (m_renderSystem){
587 case RS_QPainter:{
588 QPainter p(this);
589 p.fillRect(rect(), Qt::black);
590 if (p.paintEngine()->type() == QPaintEngine::OpenGL)
591 m_currentFrame.drawCVTexture(m_drawFrameRect, opacity);
592 else
593 m_currentFrame.drawQImage(&p, m_drawFrameRect);
594 break; }
595 case RS_CIImage:
596 m_currentFrame.drawCIImage(m_drawFrameRect, opacity);
597 break;
598 case RS_CVTexture:
599 m_currentFrame.drawCVTexture(m_drawFrameRect, opacity);
600 break;
601 case RS_QImage:{
602 QPainter p(this);
603 p.fillRect(rect(), Qt::black);
604 m_currentFrame.drawQImage(&p, m_drawFrameRect);
605 break; }
606 case RS_QGLWidget:
607 case RS_QTMovieView:
608 case RS_QTMovieLayer:
609 // draw in separate widget
610 break;
611 case RS_NoRendering:
612 QPainter p(this);
613 p.fillRect(rect(), Qt::black);
614 break;
615 }
616 break; }
617 default:
618 break;
619 }
620
621 return QWidget::event(event);
622 }
623
624 void setVideoFrame(VideoFrame &frame)
625 {
626 PhononAutoReleasePool pool;
627 m_currentFrame = frame;
628 m_currentFrame.setColors(m_brightness, m_contrast, m_hue, m_saturation);
629
630 if (m_renderDrawWidget)
631 m_renderDrawWidget->setVideoFrame(m_currentFrame);
632
633 setRenderSystem(selectBestRenderSystem());
634 switch (m_renderSystem){
635 case RS_QGLWidget:
636 case RS_QTMovieView:
637 case RS_QTMovieLayer:
638 case RS_NoRendering:
639 break;
640 case RS_CIImage:
641 case RS_CVTexture:
642 case RS_QImage:
643 case RS_QPainter:
644 repaint();
645 break;
646 }
647 }
648
649 void updateVideoFrame()
650 {
651 setVideoFrame(m_currentFrame);
652 }
653
654 void setMovieRect(const QRect &mrect)
655 {
656 if (mrect == m_movieFrameRect)
657 return;
658 m_movieFrameRect = mrect;
659 updateDrawFrameRect();
660 updateGeometry();
661 if (isVisible())
662 qApp->processEvents(QEventLoop::ExcludeUserInputEvents | QEventLoop::ExcludeSocketNotifiers);
663 }
664
665 void setScaleMode(Phonon::VideoWidget::ScaleMode scaleMode)
666 {
667 m_scaleMode = scaleMode;
668 updateDrawFrameRect();
669 updateVideoFrame();
670 repaint();
671 }
672
673 void setAspectRatio(Phonon::VideoWidget::AspectRatio aspect)
674 {
675 m_aspect = aspect;
676 updateDrawFrameRect();
677 updateVideoFrame();
678 repaint();
679 }
680
681 void updateVideoOutputCount(int count)
682 {
683 if (m_renderDrawWidget)
684 m_renderDrawWidget->updateVideoOutputCount(count);
685 }
686
687 void setMovieIsPaused(bool paused)
688 {
689 if (m_renderDrawWidget)
690 m_renderDrawWidget->setMovieIsPaused(paused);
691 }
692
693 void updateDrawFrameRect()
694 {
695 if (m_movieFrameRect.width() <= 0 || m_movieFrameRect.height() <= 0)
696 m_movieFrameRect = QRect(0, 0, 640, 480);
697
698 // Set m_drawFrameRect to be the size of the smallest possible
699 // rect conforming to the aspect and containing the whole frame:
700 switch(m_aspect){
701 case Phonon::VideoWidget::AspectRatioWidget:
702 m_drawFrameRect = rect();
703 break;
704 case Phonon::VideoWidget::AspectRatio4_3:
705 m_drawFrameRect = scaleToAspect(m_movieFrameRect, 4, 3);
706 break;
707 case Phonon::VideoWidget::AspectRatio16_9:
708 m_drawFrameRect = scaleToAspect(m_movieFrameRect, 16, 9);
709 break;
710 case Phonon::VideoWidget::AspectRatioAuto:
711 default:
712 m_drawFrameRect = m_movieFrameRect;
713 break;
714 }
715
716 // Scale m_drawFrameRect to fill the widget
717 // without breaking aspect:
718 int widgetWidth = rect().width();
719 int widgetHeight = rect().height();
720 int frameWidth = widgetWidth;
721 int frameHeight = m_drawFrameRect.height() * float(widgetWidth) / float(m_drawFrameRect.width());
722
723 switch(m_scaleMode){
724 case Phonon::VideoWidget::ScaleAndCrop:
725 if (frameHeight < widgetHeight){
726 frameWidth *= float(widgetHeight) / float(frameHeight);
727 frameHeight = widgetHeight;
728 }
729 break;
730 case Phonon::VideoWidget::FitInView:
731 default:
732 if (frameHeight > widgetHeight){
733 frameWidth *= float(widgetHeight) / float(frameHeight);
734 frameHeight = widgetHeight;
735 }
736 break;
737 }
738
739 m_drawFrameRect.setSize(QSize(frameWidth, frameHeight));
740 m_drawFrameRect.moveTo((widgetWidth - frameWidth) / 2.0f, (widgetHeight - frameHeight) / 2.0f);
741
742 if (m_renderDrawWidget)
743 m_renderDrawWidget->setDrawFrameRect(m_drawFrameRect);
744 }
745
746 QRect scaleToAspect(QRect srcRect, int w, int h)
747 {
748 int width = srcRect.width();
749 int height = srcRect.width() * (float(h) / float(w));
750 if (height > srcRect.height()){
751 height = srcRect.height();
752 width = srcRect.height() * (float(w) / float(h));
753 }
754 return QRect(0, 0, width, height);
755 }
756};
757
758/////////////////////////////////////////////////////////////////////////////////////////
759
760VideoWidget::VideoWidget(QObject *parent) : MediaNode(VideoSink, parent)
761{
762 m_videoRenderWidget = new VideoRenderWidget();
763}
764
765VideoWidget::~VideoWidget()
766{
767 delete m_videoRenderWidget;
768}
769
770QWidget *VideoWidget::widget()
771{
772 IMPLEMENTED;
773 return m_videoRenderWidget;
774}
775
776Phonon::VideoWidget::AspectRatio VideoWidget::aspectRatio() const
777{
778 IMPLEMENTED;
779 return m_videoRenderWidget->m_aspect;
780}
781
782void VideoWidget::setAspectRatio(Phonon::VideoWidget::AspectRatio aspect)
783{
784 IMPLEMENTED;
785 m_videoRenderWidget->setAspectRatio(aspect);
786}
787
788Phonon::VideoWidget::ScaleMode VideoWidget::scaleMode() const
789{
790 IMPLEMENTED;
791 return m_videoRenderWidget->m_scaleMode;
792}
793
794void VideoWidget::setScaleMode(Phonon::VideoWidget::ScaleMode scaleMode)
795{
796 IMPLEMENTED;
797 m_videoRenderWidget->setScaleMode(scaleMode);
798}
799
800qreal VideoWidget::brightness() const
801{
802 IMPLEMENTED;
803 return m_videoRenderWidget->m_brightness;
804}
805
806void VideoWidget::setBrightness(qreal value)
807{
808 IMPLEMENTED;
809 m_videoRenderWidget->m_brightness = value;
810 if (m_owningMediaObject && m_owningMediaObject->state() == Phonon::PausedState)
811 m_videoRenderWidget->updateVideoFrame();
812}
813
814qreal VideoWidget::contrast() const
815{
816 IMPLEMENTED;
817 return m_videoRenderWidget->m_contrast;
818}
819
820void VideoWidget::setContrast(qreal value)
821{
822 IMPLEMENTED;
823 m_videoRenderWidget->m_contrast = value;
824 if (m_owningMediaObject && m_owningMediaObject->state() == Phonon::PausedState)
825 m_videoRenderWidget->updateVideoFrame();
826}
827
828qreal VideoWidget::hue() const
829{
830 IMPLEMENTED;
831 return m_videoRenderWidget->m_hue;
832}
833
834void VideoWidget::setHue(qreal value)
835{
836 IMPLEMENTED;
837 m_videoRenderWidget->m_hue = value;
838 if (m_owningMediaObject && m_owningMediaObject->state() == Phonon::PausedState)
839 m_videoRenderWidget->updateVideoFrame();
840}
841
842qreal VideoWidget::saturation() const
843{
844 IMPLEMENTED;
845 return m_videoRenderWidget->m_saturation;
846}
847
848void VideoWidget::setSaturation(qreal value)
849{
850 IMPLEMENTED;
851 m_videoRenderWidget->m_saturation = value;
852 if (m_owningMediaObject && m_owningMediaObject->state() == Phonon::PausedState)
853 m_videoRenderWidget->updateVideoFrame();
854}
855
856void VideoWidget::mediaNodeEvent(const MediaNodeEvent *event)
857{
858 switch (event->type()){
859 case MediaNodeEvent::VideoFrameSizeChanged:
860 m_videoRenderWidget->setMovieRect(*static_cast<QRect *>(event->data()));
861 break;
862 case MediaNodeEvent::VideoOutputCountChanged:
863 m_videoRenderWidget->updateVideoOutputCount(*static_cast<int *>(event->data()));
864 break;
865 case MediaNodeEvent::MediaPlaying:
866 m_videoRenderWidget->setMovieIsPaused(!(*static_cast<bool *>(event->data())));
867 break;
868 default:
869 break;
870 }
871}
872
873void VideoWidget::updateVideo(VideoFrame &frame){
874 PhononAutoReleasePool pool;
875 m_videoRenderWidget->setVideoFrame(frame);
876 MediaNode::updateVideo(frame);
877}
878
879}} // namespace Phonon::QT7
880
881QT_END_NAMESPACE
882
883#include "moc_videowidget.cpp"
Note: See TracBrowser for help on using the repository browser.