← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/3rdparty/phonon/mmf/audioplayer.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/phonon/mmf/audioplayer.cpp
 
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
 
 
19
#include <QUrl>
 
20
 
 
21
#include "audioplayer.h"
 
22
#include "utils.h"
 
23
 
 
24
QT_BEGIN_NAMESPACE
 
25
 
 
26
using namespace Phonon;
 
27
using namespace Phonon::MMF;
 
28
 
 
29
/*! \class MMF::AudioPlayer
 
30
  \internal
 
31
*/
 
32
 
 
33
//-----------------------------------------------------------------------------
 
34
// Constructor / destructor
 
35
//-----------------------------------------------------------------------------
 
36
 
 
37
MMF::AudioPlayer::AudioPlayer() : m_player(0)
 
38
{
 
39
    construct();
 
40
}
 
41
 
 
42
MMF::AudioPlayer::AudioPlayer(const AbstractPlayer& player)
 
43
        : AbstractMediaPlayer(player)
 
44
        , m_player(0)
 
45
{
 
46
    construct();
 
47
}
 
48
 
 
49
void MMF::AudioPlayer::construct()
 
50
{
 
51
    TRACE_CONTEXT(AudioPlayer::AudioPlayer, EAudioApi);
 
52
    TRACE_ENTRY_0();
 
53
 
 
54
    TRAPD(err, m_player = CPlayerType::NewL(*this, 0, EMdaPriorityPreferenceNone));
 
55
    if (KErrNone != err) {
 
56
        changeState(ErrorState);
 
57
    }
 
58
 
 
59
    TRACE_EXIT_0();
 
60
}
 
61
 
 
62
MMF::AudioPlayer::~AudioPlayer()
 
63
{
 
64
    TRACE_CONTEXT(AudioPlayer::~AudioPlayer, EAudioApi);
 
65
    TRACE_ENTRY_0();
 
66
 
 
67
    delete m_player;
 
68
 
 
69
    TRACE_EXIT_0();
 
70
}
 
71
 
 
72
//-----------------------------------------------------------------------------
 
73
// Public API
 
74
//-----------------------------------------------------------------------------
 
75
 
 
76
void MMF::AudioPlayer::doPlay()
 
77
{
 
78
    m_player->Play();
 
79
}
 
80
 
 
81
void MMF::AudioPlayer::doPause()
 
82
{
 
83
    m_player->Pause();
 
84
}
 
85
 
 
86
void MMF::AudioPlayer::doStop()
 
87
{
 
88
    m_player->Stop();
 
89
}
 
90
 
 
91
void MMF::AudioPlayer::doSeek(qint64 ms)
 
92
{
 
93
    m_player->SetPosition(TTimeIntervalMicroSeconds(ms * 1000));
 
94
}
 
95
 
 
96
int MMF::AudioPlayer::setDeviceVolume(int mmfVolume)
 
97
{
 
98
    /* In SDK 3.1, SetVolume() returns void. If we're compiling against
 
99
     * 3.1, we handle it with ifdefs. However, if we compile against a later
 
100
     * SDK but are _running_ against 3.1, we avoid returning from an undefined
 
101
     * stack by doing a runtime check of the SDK version. */
 
102
#if !defined(__SERIES60_31__)
 
103
    const int err = m_player->SetVolume(mmfVolume);
 
104
    if (QSysInfo::s60Version() >= QSysInfo::SV_S60_5_0)
 
105
        return err;
 
106
    else
 
107
        return KErrNone;
 
108
 #else
 
109
     m_player->SetVolume(mmfVolume);
 
110
     return KErrNone;
 
111
#endif
 
112
}
 
113
 
 
114
int MMF::AudioPlayer::openFile(RFile& file)
 
115
{
 
116
    TRAPD(err, m_player->OpenFileL(file));
 
117
 
 
118
#ifdef QT_PHONON_MMF_AUDIO_DRM
 
119
    if (KErrNone == err) {
 
120
        // There appears to be a bug in the CDrmPlayerUtility implementation (at least
 
121
        // in S60 5.x) whereby the player does not check whether the loading observer
 
122
        // pointer is null before dereferencing it.  Therefore we must register for
 
123
        // loading notification, even though we do nothing in the callback functions.
 
124
        m_player->RegisterForAudioLoadingNotification(*this);
 
125
    }
 
126
#endif
 
127
 
 
128
    return err;
 
129
}
 
130
 
 
131
void MMF::AudioPlayer::close()
 
132
{
 
133
    m_player->Close();
 
134
}
 
135
 
 
136
bool MMF::AudioPlayer::hasVideo() const
 
137
{
 
138
    return false;
 
139
}
 
140
 
 
141
qint64 MMF::AudioPlayer::currentTime() const
 
142
{
 
143
    TRACE_CONTEXT(AudioPlayer::currentTime, EAudioApi);
 
144
 
 
145
    TTimeIntervalMicroSeconds us;
 
146
    const TInt err = m_player->GetPosition(us);
 
147
 
 
148
    qint64 result = 0;
 
149
 
 
150
    if (KErrNone == err) {
 
151
        result = toMilliSeconds(us);
 
152
    } else {
 
153
        TRACE("GetPosition err %d", err);
 
154
 
 
155
        // If we don't cast away constness here, we simply have to ignore
 
156
        // the error.
 
157
        const_cast<AudioPlayer*>(this)->setError(NormalError);
 
158
    }
 
159
 
 
160
    return result;
 
161
}
 
162
 
 
163
qint64 MMF::AudioPlayer::totalTime() const
 
164
{
 
165
    return toMilliSeconds(m_player->Duration());
 
166
}
 
167
 
 
168
 
 
169
//-----------------------------------------------------------------------------
 
170
// Symbian multimedia client observer callbacks
 
171
//-----------------------------------------------------------------------------
 
172
 
 
173
#ifdef QT_PHONON_MMF_AUDIO_DRM
 
174
void MMF::AudioPlayer::MdapcInitComplete(TInt aError,
 
175
        const TTimeIntervalMicroSeconds &)
 
176
#else
 
177
void MMF::AudioPlayer::MapcInitComplete(TInt aError,
 
178
                                        const TTimeIntervalMicroSeconds &)
 
179
#endif
 
180
{
 
181
    TRACE_CONTEXT(AudioPlayer::MapcInitComplete, EAudioInternal);
 
182
    TRACE_ENTRY("state %d error %d", state(), aError);
 
183
 
 
184
    __ASSERT_ALWAYS(LoadingState == state(), Utils::panic(InvalidStatePanic));
 
185
 
 
186
    if (KErrNone == aError) {
 
187
        maxVolumeChanged(m_player->MaxVolume());
 
188
 
 
189
        emit totalTimeChanged(totalTime());
 
190
        changeState(StoppedState);
 
191
    } else {
 
192
        // TODO: set different error states according to value of aError?
 
193
        setError(NormalError);
 
194
    }
 
195
 
 
196
    TRACE_EXIT_0();
 
197
}
 
198
 
 
199
#ifdef QT_PHONON_MMF_AUDIO_DRM
 
200
void MMF::AudioPlayer::MdapcPlayComplete(TInt aError)
 
201
#else
 
202
void MMF::AudioPlayer::MapcPlayComplete(TInt aError)
 
203
#endif
 
204
{
 
205
    TRACE_CONTEXT(AudioPlayer::MapcPlayComplete, EAudioInternal);
 
206
    TRACE_ENTRY("state %d error %d", state(), aError);
 
207
 
 
208
    stopTickTimer();
 
209
 
 
210
    if (KErrNone == aError) {
 
211
        changeState(StoppedState);
 
212
        // TODO: move on to m_nextSource
 
213
    } else {
 
214
        // TODO: do something with aError?
 
215
        setError(NormalError);
 
216
    }
 
217
 
 
218
    /*
 
219
        if(aError == KErrNone) {
 
220
            if(m_nextSource.type() == MediaSource::Empty) {
 
221
                emit finished();
 
222
            } else {
 
223
                setSource(m_nextSource);
 
224
                m_nextSource = MediaSource();
 
225
            }
 
226
 
 
227
            changeState(StoppedState);
 
228
        }
 
229
        else {
 
230
            m_error = NormalError;
 
231
            changeState(ErrorState);
 
232
        }
 
233
    */
 
234
 
 
235
    TRACE_EXIT_0();
 
236
}
 
237
 
 
238
CPlayerType *MMF::AudioPlayer::player() const
 
239
{
 
240
    return m_player;
 
241
}
 
242
 
 
243
 
 
244
#ifdef QT_PHONON_MMF_AUDIO_DRM
 
245
void MMF::AudioPlayer::MaloLoadingStarted()
 
246
{
 
247
 
 
248
}
 
249
 
 
250
void MMF::AudioPlayer::MaloLoadingComplete()
 
251
{
 
252
 
 
253
}
 
254
#endif // QT_PHONON_MMF_AUDIO_DRM
 
255
 
 
256
 
 
257
QT_END_NAMESPACE
 
258