← Back to branch summary

~ubuntu-branches/ubuntu/saucy/phonon-backend-gstreamer/saucy

« back to all changes in this revision

Viewing changes to gstreamer/volumefadereffect.cpp

  • Committer: Package Import Robot
  • Author(s): Felix Geyer
  • Date: 2012-02-16 21:50:11 UTC
  • mfrom: (1.1.3)
  • Revision ID: package-import@ubuntu.com-20120216215011-wv2qn430er68r7k0
Tags: 4:4.7.0really4.6.0-0ubuntu1
* New upstream release.
* Bump build-dependency on phonon to 4:4.7.0really4.6.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gstreamer/volumefadereffect.cpp
21
21
#include <gst/gstghostpad.h>
22
22
#include <gst/gstutils.h>
23
23
 
24
 
#include <QtCore/QEvent>
 
24
#include <QtCore/QTimeLine>
25
25
 
26
26
QT_BEGIN_NAMESPACE
27
27
 
33
33
VolumeFaderEffect::VolumeFaderEffect(Backend *backend, QObject *parent)
34
34
    : Effect(backend, parent, AudioSource | AudioSink)
35
35
    , m_fadeCurve(Phonon::VolumeFaderEffect::Fade3Decibel)
36
 
    , m_fadeTimer(0)
37
 
    , m_fadeDuration(0)
38
36
    , m_fadeFromVolume(0)
39
37
    , m_fadeToVolume(0)
40
38
{
41
39
    m_effectElement = gst_element_factory_make ("volume", NULL);
42
40
    if (m_effectElement)
43
41
        init();
 
42
    m_fadeTimeline = new QTimeLine(1000, this);
 
43
    connect(m_fadeTimeline, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetVolume(qreal)));
44
44
}
45
45
 
46
46
VolumeFaderEffect::~VolumeFaderEffect()
47
47
{
48
 
    if (m_fadeTimer)
49
 
        killTimer(m_fadeTimer);
50
48
}
51
49
 
52
50
GstElement* VolumeFaderEffect::createEffectBin()
62
60
    gst_bin_add(GST_BIN(audioBin), m_effectElement);
63
61
 
64
62
    // Link src pad
65
 
    GstPad *srcPad= gst_element_get_pad (m_effectElement, "src");
 
63
    GstPad *srcPad= gst_element_get_static_pad (m_effectElement, "src");
66
64
    gst_element_add_pad (audioBin, gst_ghost_pad_new ("src", srcPad));
67
65
    gst_object_unref (srcPad);
68
66
 
69
67
    // Link sink pad
70
 
    gst_element_link_many(queue, mconv, m_effectElement, (const char*)NULL);
71
 
    GstPad *sinkpad = gst_element_get_pad (queue, "sink");
 
68
    gst_element_link_many(queue, mconv, m_effectElement, NULL);
 
69
    GstPad *sinkpad = gst_element_get_static_pad (queue, "sink");
72
70
    gst_element_add_pad (audioBin, gst_ghost_pad_new ("sink", sinkpad));
73
71
    gst_object_unref (sinkpad);
74
72
    return audioBin;
76
74
 
77
75
float VolumeFaderEffect::volume() const
78
76
{
79
 
    gdouble val = 0.0;
 
77
    gdouble val = 1.0;
80
78
    if (m_effectElement)
81
 
        g_object_get(G_OBJECT(m_effectElement), "volume", &val, (const char*)NULL);
 
79
        g_object_get(G_OBJECT(m_effectElement), "volume", &val, NULL);
82
80
    return (float)val;
83
81
}
84
82
 
85
 
void VolumeFaderEffect::setVolume(float volume)
 
83
void VolumeFaderEffect::slotSetVolume(qreal volume)
86
84
{
87
 
    g_object_set(G_OBJECT(m_effectElement), "volume", volume, (const char*)NULL);
 
85
    float gstVolume = m_fadeFromVolume + (volume * (m_fadeToVolume - m_fadeFromVolume));
 
86
    setVolume(gstVolume);
88
87
}
89
88
 
90
89
Phonon::VolumeFaderEffect::FadeCurve VolumeFaderEffect::fadeCurve() const
92
91
    return m_fadeCurve;
93
92
}
94
93
 
95
 
void VolumeFaderEffect::setFadeCurve(Phonon::VolumeFaderEffect::FadeCurve fadeCurve)
 
94
void VolumeFaderEffect::setFadeCurve(Phonon::VolumeFaderEffect::FadeCurve pFadeCurve)
96
95
{
97
 
    m_fadeCurve = fadeCurve;
 
96
    m_fadeCurve = pFadeCurve;
 
97
    QEasingCurve fadeCurve;
 
98
    switch(pFadeCurve) {
 
99
        case Phonon::VolumeFaderEffect::Fade3Decibel:
 
100
            fadeCurve = QEasingCurve::InQuad;
 
101
            break;
 
102
        case Phonon::VolumeFaderEffect::Fade6Decibel:
 
103
            fadeCurve = QEasingCurve::Linear;
 
104
            break;
 
105
        case Phonon::VolumeFaderEffect::Fade9Decibel:
 
106
            fadeCurve = QEasingCurve::OutCubic;
 
107
            break;
 
108
        case Phonon::VolumeFaderEffect::Fade12Decibel:
 
109
            fadeCurve = QEasingCurve::OutQuart;
 
110
            break;
 
111
    }
 
112
    m_fadeTimeline->setEasingCurve(fadeCurve);
98
113
}
99
114
 
100
115
void VolumeFaderEffect::fadeTo(float targetVolume, int fadeTime)
101
116
{
102
117
    m_fadeToVolume = targetVolume;
103
 
    m_fadeDuration = fadeTime;
104
 
    m_fadeFromVolume = volume();
105
 
    m_fadeStartTime.start();
106
 
 
107
 
    if (m_fadeTimer)
108
 
        killTimer(m_fadeTimer);
109
 
    m_fadeTimer = startTimer(30);
110
 
}
111
 
 
112
 
void VolumeFaderEffect::updateFade()
113
 
{
114
 
    double currVal = 0.0;
115
 
    float step = float(m_fadeStartTime.elapsed()) / float(m_fadeDuration);
116
 
    if (step > 1){
117
 
        step = 1;
118
 
        if (m_fadeTimer) {
119
 
            killTimer(m_fadeTimer);
120
 
            m_fadeTimer = 0;
121
 
        }
122
 
    }
123
 
    // This is a very loose and interpretation of the API
124
 
    // But in fact when fading between arbitrary values, the decibel values make no sense
125
 
    // Note : seems like we will change the API to re-use names from QTimeline for this
126
 
    switch (fadeCurve()) {
127
 
        case Phonon::VolumeFaderEffect::Fade3Decibel: // Slow in the beginning
128
 
            currVal = step * step;
129
 
            break;
130
 
        case Phonon::VolumeFaderEffect::Fade6Decibel: // Linear fade
131
 
            currVal = step;
132
 
            break;
133
 
        case Phonon::VolumeFaderEffect::Fade9Decibel: // Fast in the beginning / Linear
134
 
            currVal = step * 0.5 + (1.0-(1.0-step)*(1.0-step)) * 0.5;
135
 
            break;
136
 
        case Phonon::VolumeFaderEffect::Fade12Decibel: // Fast in the beginning
137
 
            currVal = 1.0 - (1.0-step) * (1.0-step);
138
 
            break;
139
 
        default:
140
 
            break;
141
 
    }
142
 
    const double volume = (1.0 - currVal) * m_fadeFromVolume + currVal * m_fadeToVolume;
143
 
    setVolume(volume);
144
 
}
145
 
 
146
 
bool VolumeFaderEffect::event(QEvent *event)
147
 
{
148
 
    switch (event->type()){
149
 
        case QEvent::Timer:
150
 
        {
151
 
            QTimerEvent *timerEvent = static_cast<QTimerEvent *>(event);
152
 
            if (timerEvent->timerId() == m_fadeTimer)
153
 
                updateFade();
154
 
            break;
155
 
        }
156
 
        default:
157
 
            break;
158
 
    }
159
 
    return QObject::event(event);
 
118
    g_object_get(G_OBJECT(m_effectElement), "volume", &m_fadeFromVolume, NULL);
 
119
 
 
120
    // Don't call QTimeLine::setDuration() with zero.
 
121
    // It is not supported and breaks fading.
 
122
    if (fadeTime <= 0) {
 
123
        setVolume(targetVolume);
 
124
        return;
 
125
    }
 
126
 
 
127
    m_fadeTimeline->setDuration(fadeTime);
 
128
    m_fadeTimeline->start();
 
129
}
 
130
 
 
131
void VolumeFaderEffect::setVolume(float v)
 
132
{
 
133
    g_object_set(G_OBJECT(m_effectElement), "volume", (gdouble)v, NULL);
 
134
    qDebug() << "Fading to" << v;
160
135
}
161
136
 
162
137
}} //namespace Phonon::Gstreamer