← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/phonon/oneiric-201108111512

« back to all changes in this revision

Viewing changes to qt7/mediaobjectaudionode.mm

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2011-01-24 10:12:11 UTC
  • mfrom: (0.5.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20110124101211-w9rew7q0dmwbwhqx
Tags: 4:4.7.0really4.4.4-0ubuntu1
* New upstream release
* Xine and GStreamer backends now split out source, remove build-deps and
  binary packages from debian/control
* Remove 02_no_rpath.patch, now upstream
* Disable kubuntu04_no_va_mangle.patch, no longer applies
* Remove kubuntu_05_gst_codec_installer_window_id.diff, kubuntu_06_forward_events.diff,
  kubuntu_07_include_fix.diff, gstreamer now separate

Show diffs side-by-side

added added

removed removed

Lines of Context:
qt7/mediaobjectaudionode.mm
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 "mediaobjectaudionode.h"
19
 
#include "quicktimeaudioplayer.h"
20
 
#include "quicktimevideoplayer.h"
21
 
#include "audiomixer.h"
22
 
 
23
 
QT_BEGIN_NAMESPACE
24
 
 
25
 
namespace Phonon
26
 
{
27
 
namespace QT7
28
 
{
29
 
 
30
 
MediaObjectAudioNode::MediaObjectAudioNode(QuickTimeAudioPlayer *player1, QuickTimeAudioPlayer *player2) : AudioNode(0, 1)
31
 
{
32
 
    m_mute = false;
33
 
    m_player1 = player1;
34
 
    m_player2 = player2;
35
 
    m_mixer = new AudioMixerAudioNode();
36
 
 
37
 
    m_connection1 = new AudioConnection(m_player1, 0, m_mixer, 0);
38
 
    m_connection2 = new AudioConnection(m_player2, 0, m_mixer, 1);
39
 
 
40
 
    m_fadeDuration = 0;
41
 
}
42
 
 
43
 
MediaObjectAudioNode::~MediaObjectAudioNode()
44
 
{
45
 
    setGraph(0);
46
 
    delete m_player1;
47
 
    delete m_player2;
48
 
    delete m_mixer;
49
 
    delete m_connection1;
50
 
    delete m_connection2;
51
 
}
52
 
 
53
 
void MediaObjectAudioNode::createAndConnectAUNodes()
54
 
{
55
 
    DEBUG_AUDIO_GRAPH("(MediaObjectAudioNode" << int(this) << "createAndConnectAUNodes called)" )
56
 
    m_player1->createAndConnectAUNodes();
57
 
    m_player2->createAndConnectAUNodes();
58
 
    m_mixer->createAndConnectAUNodes();
59
 
 
60
 
    m_connection1->connect(m_audioGraph);
61
 
    m_connection2->connect(m_audioGraph);
62
 
}
63
 
 
64
 
void MediaObjectAudioNode::createAudioUnits()
65
 
{
66
 
    DEBUG_AUDIO_GRAPH("(MediaObjectAudioNode" << int(this) << "createAudioUnits called)" )
67
 
    m_player1->createAudioUnits();
68
 
    m_player2->createAudioUnits();
69
 
    m_mixer->createAudioUnits();
70
 
}
71
 
 
72
 
void MediaObjectAudioNode::setGraph(AudioGraph *audioGraph)
73
 
{
74
 
    DEBUG_AUDIO_GRAPH("MediaObjectAudioNode" << int(this) << "is setting graph:" << int(audioGraph))
75
 
    m_audioGraph = audioGraph;
76
 
    m_player1->setGraph(audioGraph);
77
 
    m_player2->setGraph(audioGraph);
78
 
    m_mixer->setGraph(audioGraph);
79
 
}
80
 
 
81
 
AUNode MediaObjectAudioNode::getOutputAUNode()
82
 
{
83
 
    return m_mixer->getOutputAUNode();
84
 
}
85
 
 
86
 
bool MediaObjectAudioNode::fillInStreamSpecification(AudioConnection *connection, ConnectionSide side)
87
 
{
88
 
    if (side == Source){
89
 
        DEBUG_AUDIO_STREAM("(MediaObjectAudioNode" << int(this) << "fillInStreamSpecification called, role = source)")
90
 
        return m_mixer->fillInStreamSpecification(connection, side);
91
 
    } else {
92
 
        DEBUG_AUDIO_STREAM("(MediaObjectAudioNode" << int(this) << "fillInStreamSpecification called, role = sink)")
93
 
        return (m_connection2->updateStreamSpecification() && m_connection1->updateStreamSpecification());
94
 
    }
95
 
}
96
 
 
97
 
bool MediaObjectAudioNode::setStreamSpecification(AudioConnection *connection, ConnectionSide side)
98
 
{
99
 
    if (side == Source){
100
 
        DEBUG_AUDIO_STREAM("(MediaObjectAudioNode" << int(this) << "setStreamSpecification called, role = source)")
101
 
        return m_mixer->setStreamSpecification(connection, side);
102
 
    }
103
 
    return true;
104
 
}
105
 
 
106
 
void MediaObjectAudioNode::setMute(bool mute)
107
 
{
108
 
    m_mute = mute;
109
 
    m_mixer->setVolume(m_mute ? 0 : m_volume1, m_connection1->m_sinkInputBus);
110
 
    m_mixer->setVolume(m_mute ? 0 : m_volume2, m_connection2->m_sinkInputBus);
111
 
}
112
 
 
113
 
void MediaObjectAudioNode::updateVolume()
114
 
{
115
 
    if (m_mute)
116
 
        return;
117
 
        
118
 
    QuickTimeVideoPlayer *player1 = static_cast<QuickTimeAudioPlayer *>(m_connection1->m_sourceAudioNode)->videoPlayer();
119
 
    QuickTimeVideoPlayer *player2 = static_cast<QuickTimeAudioPlayer *>(m_connection2->m_sourceAudioNode)->videoPlayer();
120
 
    if (player1)
121
 
        player1->setRelativeVolume(m_volume1);
122
 
    if (player2)
123
 
        player2->setRelativeVolume(m_volume2);
124
 
 
125
 
    m_mixer->setVolume(m_volume1, m_connection1->m_sinkInputBus);
126
 
    m_mixer->setVolume(m_volume2, m_connection2->m_sinkInputBus);
127
 
}
128
 
 
129
 
void MediaObjectAudioNode::startCrossFade(qint64 duration)
130
 
{
131
 
    m_fadeDuration = duration;
132
 
 
133
 
    // Swap:
134
 
    AudioConnection *tmp = m_connection1;
135
 
    m_connection1 = m_connection2;
136
 
    m_connection2 = tmp;
137
 
 
138
 
    // Init volume:
139
 
    if (m_fadeDuration > 0){
140
 
        m_volume1 = 0;
141
 
        m_volume2 = 1;
142
 
    } else {
143
 
        m_volume1 = 1;
144
 
        m_volume2 = 0;
145
 
    }
146
 
    updateVolume();
147
 
}
148
 
 
149
 
float MediaObjectAudioNode::applyCurve(float volume)
150
 
{
151
 
    float newValue = 0;
152
 
    if (volume > 0)
153
 
        newValue = float(0.5f * (2 + log10(volume)));
154
 
    return newValue;
155
 
}
156
 
 
157
 
void MediaObjectAudioNode::updateCrossFade(qint64 currentTime)
158
 
{
159
 
    // Assume that currentTime starts at 0 and progress.
160
 
    if (m_fadeDuration > 0){
161
 
        float volume = float(currentTime) / float(m_fadeDuration);
162
 
        if (volume >= 1){
163
 
            volume = 1;
164
 
            m_fadeDuration = 0;
165
 
        }
166
 
        m_volume1 = applyCurve(volume);
167
 
        m_volume2 = 1 - volume;
168
 
        updateVolume();
169
 
    }
170
 
}
171
 
 
172
 
bool MediaObjectAudioNode::isCrossFading()
173
 
{
174
 
    return (m_fadeDuration > 0);
175
 
}
176
 
 
177
 
void MediaObjectAudioNode::cancelCrossFade()
178
 
{
179
 
    m_fadeDuration = 0;
180
 
    m_volume1 = 1;
181
 
    m_volume2 = 0;
182
 
    updateVolume();
183
 
}
184
 
 
185
 
void MediaObjectAudioNode::mediaNodeEvent(const MediaNodeEvent *event)
186
 
{
187
 
    switch (event->type()){
188
 
    case MediaNodeEvent::AudioGraphAboutToBeDeleted:
189
 
        m_connection1->invalidate();
190
 
        m_connection2->invalidate();
191
 
        break;
192
 
    case MediaNodeEvent::AudioGraphCannotPlay:
193
 
    case MediaNodeEvent::AudioGraphInitialized:
194
 
        updateVolume();
195
 
        break;
196
 
    default:
197
 
        break;
198
 
    }
199
 
 
200
 
    m_player1->mediaNodeEvent(event);
201
 
    m_player2->mediaNodeEvent(event);
202
 
    m_mixer->mediaNodeEvent(event);
203
 
}
204
 
 
205
 
}} //namespace Phonon::QT7
206
 
 
207
 
QT_END_NAMESPACE