73 connect(m_session, SIGNAL(mutedStateChanged(bool)), |
76 connect(m_session, SIGNAL(mutedStateChanged(bool)), |
74 this, SIGNAL(mutedChanged(bool))); |
77 this, SIGNAL(mutedChanged(bool))); |
75 connect(m_session, SIGNAL(volumeChanged(int)), |
78 connect(m_session, SIGNAL(volumeChanged(int)), |
76 this, SIGNAL(volumeChanged(int))); |
79 this, SIGNAL(volumeChanged(int))); |
77 connect(m_session, SIGNAL(stateChanged(QMediaPlayer::State)), |
80 connect(m_session, SIGNAL(stateChanged(QMediaPlayer::State)), |
78 this, SIGNAL(stateChanged(QMediaPlayer::State))); |
81 this, SLOT(updateState(QMediaPlayer::State))); |
79 connect(m_session, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)), |
|
80 this, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus))); |
|
81 connect(m_session,SIGNAL(bufferingProgressChanged(int)), |
82 connect(m_session,SIGNAL(bufferingProgressChanged(int)), |
82 this, SIGNAL(bufferStatusChanged(int))); |
83 this, SLOT(setBufferProgress(int))); |
|
84 connect(m_session, SIGNAL(playbackFinished()), |
|
85 this, SLOT(processEOS())); |
83 connect(m_session, SIGNAL(audioAvailableChanged(bool)), |
86 connect(m_session, SIGNAL(audioAvailableChanged(bool)), |
84 this, SIGNAL(audioAvailableChanged(bool))); |
87 this, SIGNAL(audioAvailableChanged(bool))); |
85 connect(m_session, SIGNAL(videoAvailableChanged(bool)), |
88 connect(m_session, SIGNAL(videoAvailableChanged(bool)), |
86 this, SIGNAL(videoAvailableChanged(bool))); |
89 this, SIGNAL(videoAvailableChanged(bool))); |
87 connect(m_session, SIGNAL(seekableChanged(bool)), |
90 connect(m_session, SIGNAL(seekableChanged(bool)), |
88 this, SIGNAL(seekableChanged(bool))); |
91 this, SIGNAL(seekableChanged(bool))); |
|
92 connect(m_session, SIGNAL(error(int,QString)), |
|
93 this, SIGNAL(error(int,QString))); |
89 } |
94 } |
90 |
95 |
91 QGstreamerPlayerControl::~QGstreamerPlayerControl() |
96 QGstreamerPlayerControl::~QGstreamerPlayerControl() |
92 { |
97 { |
93 if (m_fifoFd[0] >= 0) { |
98 if (m_fifoFd[0] >= 0) { |
108 return m_session->duration(); |
113 return m_session->duration(); |
109 } |
114 } |
110 |
115 |
111 QMediaPlayer::State QGstreamerPlayerControl::state() const |
116 QMediaPlayer::State QGstreamerPlayerControl::state() const |
112 { |
117 { |
113 return m_session->state(); |
118 return m_state; |
114 } |
119 } |
115 |
120 |
116 QMediaPlayer::MediaStatus QGstreamerPlayerControl::mediaStatus() const |
121 QMediaPlayer::MediaStatus QGstreamerPlayerControl::mediaStatus() const |
117 { |
122 { |
118 return m_session->mediaStatus(); |
123 return m_mediaStatus; |
119 } |
124 } |
120 |
125 |
121 int QGstreamerPlayerControl::bufferStatus() const |
126 int QGstreamerPlayerControl::bufferStatus() const |
122 { |
127 { |
123 return 100; |
128 if (m_bufferProgress == -1) { |
|
129 return m_session->state() == QMediaPlayer::StoppedState ? 0 : 100; |
|
130 } else |
|
131 return m_bufferProgress; |
124 } |
132 } |
125 |
133 |
126 int QGstreamerPlayerControl::volume() const |
134 int QGstreamerPlayerControl::volume() const |
127 { |
135 { |
128 return m_session->volume(); |
136 return m_session->volume(); |
163 m_session->seek(pos); |
171 m_session->seek(pos); |
164 } |
172 } |
165 |
173 |
166 void QGstreamerPlayerControl::play() |
174 void QGstreamerPlayerControl::play() |
167 { |
175 { |
168 m_session->play(); |
176 if (m_session->play()) { |
169 |
177 if (m_state != QMediaPlayer::PlayingState) |
170 if (m_fifoFd[1] >= 0) { |
178 emit stateChanged(m_state = QMediaPlayer::PlayingState); |
171 m_fifoCanWrite = true; |
|
172 |
|
173 writeFifo(); |
|
174 } |
179 } |
175 } |
180 } |
176 |
181 |
177 void QGstreamerPlayerControl::pause() |
182 void QGstreamerPlayerControl::pause() |
178 { |
183 { |
179 m_session->pause(); |
184 if (m_session->pause()) { |
|
185 if (m_state != QMediaPlayer::PausedState) |
|
186 emit stateChanged(m_state = QMediaPlayer::PausedState); |
|
187 } |
180 } |
188 } |
181 |
189 |
182 void QGstreamerPlayerControl::stop() |
190 void QGstreamerPlayerControl::stop() |
183 { |
191 { |
|
192 if (m_state != QMediaPlayer::StoppedState) { |
|
193 m_session->pause(); |
|
194 if (!m_session->seek(0)) { |
|
195 m_bufferProgress = -1; |
|
196 m_session->stop(); |
|
197 m_session->pause(); |
|
198 } |
|
199 emit positionChanged(0); |
|
200 if (m_state != QMediaPlayer::StoppedState) |
|
201 emit stateChanged(m_state = QMediaPlayer::StoppedState); |
|
202 } |
|
203 } |
|
204 |
|
205 void QGstreamerPlayerControl::setVolume(int volume) |
|
206 { |
|
207 m_session->setVolume(volume); |
|
208 } |
|
209 |
|
210 void QGstreamerPlayerControl::setMuted(bool muted) |
|
211 { |
|
212 m_session->setMuted(muted); |
|
213 } |
|
214 |
|
215 QMediaContent QGstreamerPlayerControl::media() const |
|
216 { |
|
217 return m_currentResource; |
|
218 } |
|
219 |
|
220 const QIODevice *QGstreamerPlayerControl::mediaStream() const |
|
221 { |
|
222 return m_stream; |
|
223 } |
|
224 |
|
225 void QGstreamerPlayerControl::setMedia(const QMediaContent &content, QIODevice *stream) |
|
226 { |
|
227 QMediaPlayer::State oldState = m_state; |
|
228 m_state = QMediaPlayer::StoppedState; |
184 m_session->stop(); |
229 m_session->stop(); |
185 } |
230 |
186 |
231 if (m_bufferProgress != -1) { |
187 void QGstreamerPlayerControl::setVolume(int volume) |
232 m_bufferProgress = -1; |
188 { |
233 emit bufferStatusChanged(0); |
189 m_session->setVolume(volume); |
234 } |
190 } |
|
191 |
|
192 void QGstreamerPlayerControl::setMuted(bool muted) |
|
193 { |
|
194 m_session->setMuted(muted); |
|
195 } |
|
196 |
|
197 QMediaContent QGstreamerPlayerControl::media() const |
|
198 { |
|
199 return m_currentResource; |
|
200 } |
|
201 |
|
202 const QIODevice *QGstreamerPlayerControl::mediaStream() const |
|
203 { |
|
204 return m_stream; |
|
205 } |
|
206 |
|
207 void QGstreamerPlayerControl::setMedia(const QMediaContent &content, QIODevice *stream) |
|
208 { |
|
209 m_session->stop(); |
|
210 |
235 |
211 if (m_stream) { |
236 if (m_stream) { |
212 closeFifo(); |
237 closeFifo(); |
213 |
238 |
214 disconnect(m_stream, SIGNAL(readyRead()), this, SLOT(writeFifo())); |
239 disconnect(m_stream, SIGNAL(readyRead()), this, SLOT(writeFifo())); |
228 url = content.canonicalUrl(); |
253 url = content.canonicalUrl(); |
229 } |
254 } |
230 |
255 |
231 m_session->load(url); |
256 m_session->load(url); |
232 |
257 |
|
258 if (m_fifoFd[1] >= 0) { |
|
259 m_fifoCanWrite = true; |
|
260 |
|
261 writeFifo(); |
|
262 } |
|
263 |
|
264 if (!url.isEmpty()) { |
|
265 if (m_mediaStatus != QMediaPlayer::LoadingMedia) |
|
266 emit mediaStatusChanged(m_mediaStatus = QMediaPlayer::LoadingMedia); |
|
267 m_session->pause(); |
|
268 } else { |
|
269 if (m_mediaStatus != QMediaPlayer::NoMedia) |
|
270 emit mediaStatusChanged(m_mediaStatus = QMediaPlayer::NoMedia); |
|
271 setBufferProgress(0); |
|
272 } |
|
273 |
233 emit mediaChanged(m_currentResource); |
274 emit mediaChanged(m_currentResource); |
|
275 if (m_state != oldState) |
|
276 emit stateChanged(m_state); |
234 } |
277 } |
235 |
278 |
236 void QGstreamerPlayerControl::setVideoOutput(QObject *output) |
279 void QGstreamerPlayerControl::setVideoOutput(QObject *output) |
237 { |
280 { |
238 m_session->setVideoRenderer(output); |
281 m_session->setVideoRenderer(output); |
244 } |
287 } |
245 |
288 |
246 bool QGstreamerPlayerControl::isVideoAvailable() const |
289 bool QGstreamerPlayerControl::isVideoAvailable() const |
247 { |
290 { |
248 return m_session->isVideoAvailable(); |
291 return m_session->isVideoAvailable(); |
|
292 } |
|
293 |
|
294 void QGstreamerPlayerControl::updateState(QMediaPlayer::State state) |
|
295 { |
|
296 QMediaPlayer::MediaStatus oldStatus = m_mediaStatus; |
|
297 |
|
298 switch (state) { |
|
299 case QMediaPlayer::StoppedState: |
|
300 if (m_state != QMediaPlayer::StoppedState) |
|
301 emit stateChanged(m_state = QMediaPlayer::StoppedState); |
|
302 break; |
|
303 |
|
304 case QMediaPlayer::PlayingState: |
|
305 case QMediaPlayer::PausedState: |
|
306 if (m_state == QMediaPlayer::StoppedState) |
|
307 m_mediaStatus = QMediaPlayer::LoadedMedia; |
|
308 else { |
|
309 if (m_bufferProgress == -1) |
|
310 m_mediaStatus = QMediaPlayer::BufferedMedia; |
|
311 } |
|
312 break; |
|
313 } |
|
314 |
|
315 if (m_mediaStatus != oldStatus) |
|
316 emit mediaStatusChanged(m_mediaStatus); |
|
317 } |
|
318 |
|
319 void QGstreamerPlayerControl::processEOS() |
|
320 { |
|
321 m_mediaStatus = QMediaPlayer::EndOfMedia; |
|
322 m_state = QMediaPlayer::StoppedState; |
|
323 |
|
324 emit stateChanged(m_state); |
|
325 emit mediaStatusChanged(m_mediaStatus); |
|
326 } |
|
327 |
|
328 void QGstreamerPlayerControl::setBufferProgress(int progress) |
|
329 { |
|
330 if (m_bufferProgress == progress || m_mediaStatus == QMediaPlayer::NoMedia) |
|
331 return; |
|
332 |
|
333 QMediaPlayer::MediaStatus oldStatus = m_mediaStatus; |
|
334 |
|
335 m_bufferProgress = progress; |
|
336 |
|
337 if (m_state == QMediaPlayer::StoppedState) { |
|
338 m_mediaStatus = QMediaPlayer::LoadedMedia; |
|
339 } else { |
|
340 if (m_bufferProgress < 100) { |
|
341 m_mediaStatus = QMediaPlayer::StalledMedia; |
|
342 m_session->pause(); |
|
343 } else { |
|
344 m_mediaStatus = QMediaPlayer::BufferedMedia; |
|
345 if (m_state == QMediaPlayer::PlayingState) |
|
346 m_session->play(); |
|
347 } |
|
348 } |
|
349 |
|
350 if (m_mediaStatus != oldStatus) |
|
351 emit mediaStatusChanged(m_mediaStatus); |
|
352 |
|
353 emit bufferStatusChanged(m_bufferProgress); |
249 } |
354 } |
250 |
355 |
251 void QGstreamerPlayerControl::writeFifo() |
356 void QGstreamerPlayerControl::writeFifo() |
252 { |
357 { |
253 if (m_fifoCanWrite) { |
358 if (m_fifoCanWrite) { |