← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/webkit/WebCore/platform/graphics/qt/MediaPlayerPrivatePhonon.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/webkit/WebCore/platform/graphics/qt/MediaPlayerPrivatePhonon.cpp
1
1
/*
2
2
    Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
 
3
    Copyright (C) 2009 Apple Inc. All rights reserved.
3
4
 
4
5
    This library is free software; you can redistribute it and/or
5
6
    modify it under the terms of the GNU Library General Public
26
27
#include "FrameView.h"
27
28
#include "GraphicsContext.h"
28
29
#include "NotImplemented.h"
 
30
#include "TimeRanges.h"
29
31
#include "Widget.h"
30
32
#include <wtf/HashSet.h>
31
33
 
35
37
#include <QMetaEnum>
36
38
#include <QUrl>
37
39
#include <QEvent>
38
 
#include <phonon>
 
40
 
 
41
#if defined (__SYMBIAN32__)
 
42
#include <phonon/path.h>
 
43
#endif
 
44
#include <audiooutput.h>
 
45
#include <mediaobject.h>
 
46
#include <videowidget.h>
39
47
 
40
48
using namespace Phonon;
41
49
 
42
 
#define LOG_MEDIAOBJECT() (LOG(Media,"%s", debugMediaObject(this, *m_mediaObject).constData()))
 
50
#define LOG_MEDIAOBJECT() (LOG(Media, "%s", debugMediaObject(this, *m_mediaObject).constData()))
43
51
 
44
52
static QByteArray debugMediaObject(WebCore::MediaPlayerPrivate* mediaPlayer, const MediaObject& mediaObject)
45
53
{
76
84
MediaPlayerPrivate::MediaPlayerPrivate(MediaPlayer* player)
77
85
    : m_player(player)
78
86
    , m_networkState(MediaPlayer::Empty)
79
 
    , m_readyState(MediaPlayer::DataUnavailable)
 
87
    , m_readyState(MediaPlayer::HaveNothing)
80
88
    , m_mediaObject(new MediaObject())
81
89
    , m_videoWidget(new VideoWidget(0))
82
90
    , m_audioOutput(new AudioOutput())
93
101
 
94
102
    // Make sure we get updates for each frame
95
103
    m_videoWidget->installEventFilter(this);
96
 
    foreach(QWidget* widget, qFindChildren<QWidget*>(m_videoWidget)) {
 
104
    foreach (QWidget* widget, qFindChildren<QWidget*>(m_videoWidget))
97
105
        widget->installEventFilter(this);
98
 
    }
99
106
 
100
107
    connect(m_mediaObject, SIGNAL(stateChanged(Phonon::State, Phonon::State)),
101
108
            this, SLOT(stateChanged(Phonon::State, Phonon::State)));
110
117
    connect(m_mediaObject, SIGNAL(totalTimeChanged(qint64)), this, SLOT(totalTimeChanged(qint64)));
111
118
}
112
119
 
 
120
MediaPlayerPrivateInterface* MediaPlayerPrivate::create(MediaPlayer* player)
 
121
{
 
122
    return new MediaPlayerPrivate(player);
 
123
}
 
124
 
 
125
void MediaPlayerPrivate::registerMediaEngine(MediaEngineRegistrar registrar)
 
126
{
 
127
    if (isAvailable())
 
128
        registrar(create, getSupportedTypes, supportsType);
 
129
}
 
130
 
 
131
 
113
132
MediaPlayerPrivate::~MediaPlayerPrivate()
114
133
{
115
134
    LOG(Media, "MediaPlayerPrivatePhonon::dtor deleting videowidget");
131
150
    notImplemented();
132
151
}
133
152
 
 
153
MediaPlayer::SupportsType MediaPlayerPrivate::supportsType(const String&, const String&)
 
154
{
 
155
    // FIXME: do the real thing
 
156
    notImplemented();
 
157
    return MediaPlayer::IsNotSupported;
 
158
}
 
159
 
134
160
bool MediaPlayerPrivate::hasVideo() const
135
161
{
136
162
    bool hasVideo = m_mediaObject->hasVideo();
138
164
    return hasVideo;
139
165
}
140
166
 
141
 
void MediaPlayerPrivate::load(String url)
 
167
bool MediaPlayerPrivate::hasAudio() const
 
168
{
 
169
    // FIXME: Phonon::MediaObject does not have such a hasAudio() function
 
170
    bool hasAudio = true;
 
171
    LOG(Media, "MediaPlayerPrivatePhonon::hasAudio() -> %s", hasAudio ? "true" : "false");
 
172
    return hasAudio;
 
173
}
 
174
 
 
175
void MediaPlayerPrivate::load(const String& url)
142
176
{
143
177
    LOG(Media, "MediaPlayerPrivatePhonon::load(\"%s\")", url.utf8().data());
144
178
 
149
183
    }
150
184
 
151
185
    // And we don't have any data yet
152
 
    if (m_readyState != MediaPlayer::DataUnavailable) {
153
 
        m_readyState = MediaPlayer::DataUnavailable;
 
186
    if (m_readyState != MediaPlayer::HaveNothing) {
 
187
        m_readyState = MediaPlayer::HaveNothing;
154
188
        m_player->readyStateChanged();
155
189
    }
156
190
 
205
239
 
206
240
float MediaPlayerPrivate::duration() const
207
241
{
208
 
    if (m_networkState < MediaPlayer::LoadedMetaData)
 
242
    if (m_readyState < MediaPlayer::HaveMetadata)
209
243
        return 0.0f;
210
244
 
211
245
    float duration = m_mediaObject->totalTime() / 1000.0f;
225
259
    return currentTime;
226
260
}
227
261
 
228
 
void MediaPlayerPrivate::setEndTime(float endTime)
 
262
void MediaPlayerPrivate::setEndTime(float)
229
263
{
230
264
    notImplemented();
231
265
}
232
266
 
233
 
float MediaPlayerPrivate::maxTimeBuffered() const
 
267
PassRefPtr<TimeRanges> MediaPlayerPrivate::buffered() const
234
268
{
235
269
    notImplemented();
236
 
    return 0.0f;
 
270
    return TimeRanges::create();
237
271
}
238
272
 
239
273
float MediaPlayerPrivate::maxTimeSeekable() const
243
277
}
244
278
 
245
279
unsigned MediaPlayerPrivate::bytesLoaded() const
246
 
{ 
 
280
{
247
281
    notImplemented();
248
282
    return 0;
249
283
}
309
343
    Phonon::State phononState = m_mediaObject->state();
310
344
 
311
345
    if (phononState == Phonon::StoppedState) {
312
 
        if (oldNetworkState < MediaPlayer::LoadedMetaData) {
313
 
            m_networkState = MediaPlayer::LoadedMetaData;
314
 
            m_readyState = MediaPlayer::DataUnavailable;
 
346
        if (m_readyState < MediaPlayer::HaveMetadata) {
 
347
            m_networkState = MediaPlayer::Loading; // FIXME: should this be MediaPlayer::Idle?
 
348
            m_readyState = MediaPlayer::HaveMetadata;
315
349
            m_mediaObject->pause();
316
350
        }
317
351
    } else if (phononState == Phonon::PausedState) {
318
352
        m_networkState = MediaPlayer::Loaded;
319
 
        m_readyState = MediaPlayer::CanPlayThrough;
 
353
        m_readyState = MediaPlayer::HaveEnoughData;
320
354
    } else if (phononState == Phonon::ErrorState) {
321
355
         if (!m_mediaObject || m_mediaObject->errorType() == Phonon::FatalError) {
322
 
             m_networkState = MediaPlayer::LoadFailed;
323
 
             m_readyState = MediaPlayer::DataUnavailable;
 
356
             // FIXME: is it possile to differentiate between different types of errors
 
357
             m_networkState = MediaPlayer::NetworkError;
 
358
             m_readyState = MediaPlayer::HaveNothing;
324
359
             cancelLoad();
325
 
         } else {
 
360
         } else
326
361
             m_mediaObject->pause();
327
 
         }
328
362
    }
329
363
 
330
364
    if (seeking())
331
 
        m_readyState = MediaPlayer::DataUnavailable;
 
365
        m_readyState = MediaPlayer::HaveNothing;
332
366
 
333
367
    if (m_networkState != oldNetworkState) {
334
368
        const QMetaObject* metaObj = this->metaObject();
357
391
    m_videoWidget->setVisible(m_isVisible);
358
392
}
359
393
 
360
 
void MediaPlayerPrivate::setRect(const IntRect& newRect)
 
394
void MediaPlayerPrivate::setSize(const IntSize& newSize)
361
395
{
362
396
    if (!m_videoWidget)
363
397
        return;
364
398
 
365
 
    LOG(Media, "MediaPlayerPrivatePhonon::setRect(%d,%d %dx%d)",
366
 
                newRect.x(), newRect.y(),
367
 
                newRect.width(), newRect.height());
 
399
    LOG(Media, "MediaPlayerPrivatePhonon::setSize(%d,%d)",
 
400
                newSize.width(), newSize.height());
368
401
 
369
402
    QRect currentRect = m_videoWidget->rect();
370
403
 
371
 
    if (newRect.width() != currentRect.width() || newRect.height() != currentRect.height())
372
 
        m_videoWidget->resize(newRect.width(), newRect.height());
 
404
    if (newSize.width() != currentRect.width() || newSize.height() != currentRect.height())
 
405
        m_videoWidget->resize(newSize.width(), newSize.height());
373
406
}
374
407
 
375
408
IntSize MediaPlayerPrivate::naturalSize() const
380
413
        return IntSize();
381
414
    }
382
415
 
383
 
    if (m_networkState < MediaPlayer::LoadedMetaData) {
 
416
    if (m_readyState < MediaPlayer::HaveMetadata) {
384
417
        LOG(Media, "MediaPlayerPrivatePhonon::naturalSize() -> %dx%d",
385
418
                           0, 0);
386
419
        return IntSize();