← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gstreamer/streamreader.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2011-04-15 14:43:30 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110415144330-7uif3319lxdu4ltt
Tags: 4:4.7.0really4.5.0-0ubuntu2
* New upstream release
* Add kubuntu_02_install_codec.diff to fix codec install

Show diffs side-by-side

added added

removed removed

Lines of Context:
gstreamer/streamreader.cpp
18
18
 
19
19
#include "streamreader.h"
20
20
 
 
21
#include "debug.h"
 
22
 
21
23
QT_BEGIN_NAMESPACE
22
24
#ifndef QT_NO_PHONON_ABSTRACTMEDIASTREAM
23
25
namespace Phonon
29
31
    : m_pos(0)
30
32
    , m_size(0)
31
33
    , m_eos(false)
 
34
    , m_locked(false)
32
35
    , m_seekable(false)
33
36
    , m_mediaObject(parent)
34
37
{
 
38
    DEBUG_BLOCK;
35
39
    connectToSource(source);
36
40
}
37
41
 
 
42
StreamReader::~StreamReader()
 
43
{
 
44
    DEBUG_BLOCK;
 
45
}
 
46
 
 
47
//------------------------------------------------------------------------------
 
48
// Thead safe because every changing function is locked ------------------------
 
49
//------------------------------------------------------------------------------
 
50
 
38
51
int StreamReader::currentBufferSize() const
39
52
{
40
53
    return m_buffer.size();
41
54
}
42
55
 
43
 
void StreamReader::writeData(const QByteArray &data) {
44
 
    QMutexLocker locker(&m_mutex);
45
 
 
46
 
    m_buffer.append(data);
47
 
    m_waitingForData.wakeAll();
48
 
}
 
56
quint64 StreamReader::currentPos() const
 
57
{
 
58
    return m_pos;
 
59
}
 
60
 
 
61
qint64 StreamReader::streamSize() const
 
62
{
 
63
    return m_size;
 
64
}
 
65
 
 
66
bool StreamReader::streamSeekable() const
 
67
{
 
68
    // TODO - problems with pull seeking and the way our current stack works.
 
69
    return false;
 
70
//    return m_seekable;
 
71
}
 
72
 
 
73
//------------------------------------------------------------------------------
 
74
// Explicit thread safe by locking the mutex ---------------------------------
 
75
//------------------------------------------------------------------------------
49
76
 
50
77
void StreamReader::setCurrentPos(qint64 pos)
51
78
{
52
79
    QMutexLocker locker(&m_mutex);
53
 
 
54
80
    m_pos = pos;
55
81
    seekStream(pos);
56
82
    m_buffer.clear();
57
83
}
58
84
 
59
 
quint64 StreamReader::currentPos() const
 
85
void StreamReader::writeData(const QByteArray &data)
60
86
{
61
 
    return m_pos;
 
87
    QMutexLocker locker(&m_mutex);
 
88
    DEBUG_BLOCK;
 
89
    m_buffer.append(data);
 
90
    m_waitingForData.wakeAll();
62
91
}
63
92
 
64
93
GstFlowReturn StreamReader::read(quint64 pos, int length, char *buffer)
65
94
{
66
95
    QMutexLocker locker(&m_mutex);
 
96
    DEBUG_BLOCK;
67
97
 
68
98
    if (currentPos() != pos) {
69
99
        if (!streamSeekable()) {
81
111
 
82
112
        m_waitingForData.wait(&m_mutex);
83
113
 
 
114
        // Abort instantly if we got unlocked, whether we got sufficient data or not
 
115
        // is absolutely unimportant at this point.
 
116
        if (!m_locked) {
 
117
            break;
 
118
        }
 
119
 
84
120
        if (oldSize == currentBufferSize()) {
85
 
            // We didn't get any data.
 
121
            // We didn't get any data, check if we are at the end of stream already.
86
122
            if (m_eos) {
87
123
                return GST_FLOW_UNEXPECTED;
88
 
            } else {
89
 
                return GST_FLOW_ERROR;
90
124
            }
91
125
        }
92
126
    }
105
139
void StreamReader::endOfData()
106
140
{
107
141
    QMutexLocker locker(&m_mutex);
 
142
    DEBUG_BLOCK;
108
143
    m_eos = true;
109
144
    m_waitingForData.wakeAll();
110
145
}
112
147
void StreamReader::start()
113
148
{
114
149
    QMutexLocker locker(&m_mutex);
 
150
    DEBUG_BLOCK;
115
151
    m_buffer.clear();
116
152
    m_eos = false;
 
153
    m_locked = true;
117
154
    m_pos = 0;
118
155
    m_seekable = false;
119
156
    m_size = 0;
122
159
 
123
160
void StreamReader::stop()
124
161
{
 
162
    QMutexLocker locker(&m_mutex);
 
163
    DEBUG_BLOCK;
125
164
    enoughData();
126
165
    m_waitingForData.wakeAll();
127
166
}
129
168
void StreamReader::unlock()
130
169
{
131
170
    QMutexLocker locker(&m_mutex);
 
171
    DEBUG_BLOCK;
132
172
    enoughData();
 
173
    m_locked = false;
133
174
    m_waitingForData.wakeAll();
134
175
}
135
176
 
136
 
void StreamReader::setStreamSize(qint64 newSize) {
 
177
void StreamReader::setStreamSize(qint64 newSize)
 
178
{
 
179
    QMutexLocker locker(&m_mutex);
137
180
    m_size = newSize;
138
181
}
139
182
 
140
 
qint64 StreamReader::streamSize() const {
141
 
    return m_size;
142
 
}
143
 
 
144
 
void StreamReader::setStreamSeekable(bool seekable) {
 
183
void StreamReader::setStreamSeekable(bool seekable)
 
184
{
 
185
    QMutexLocker locker(&m_mutex);
145
186
//    if (seekable) {
146
187
//        // The initial stream size of a seekable stream *must* not be 0 or
147
188
//        // GStreamer will refuse to typefind.
150
191
    m_seekable = seekable;
151
192
}
152
193
 
153
 
bool StreamReader::streamSeekable() const {
154
 
    // TODO - problems with pull seeking and the way our current stack works.
155
 
    return false;
156
 
//    return m_seekable;
157
 
}
158
 
 
159
194
}
160
195
}
161
196
#endif //QT_NO_PHONON_ABSTRACTMEDIASTREAM