| /* This file is part of the KDE project |
| Copyright (C) 2007 Matthias Kretz <kretz@kde.org> |
| |
| This library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) version 3, or any |
| later version accepted by the membership of KDE e.V. (or its |
| successor approved by the membership of KDE e.V.), Nokia Corporation |
| (or its successors, if any) and the KDE Free Qt Foundation, which shall |
| act as a proxy defined in Section 6 of version 3 of the license. |
| |
| This library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with this library. If not, see <http://www.gnu.org/licenses/>. |
| |
| */ |
| |
| #include "abstractmediastream.h" |
| #include "abstractmediastream_p.h" |
| #include "mediaobjectinterface.h" |
| #include "mediaobject_p.h" |
| #include "streaminterface_p.h" |
| |
| #ifndef QT_NO_PHONON_ABSTRACTMEDIASTREAM |
| |
| QT_BEGIN_NAMESPACE |
| |
| namespace Phonon |
| { |
| |
| AbstractMediaStream::AbstractMediaStream(QObject *parent) |
| : QObject(parent), |
| d_ptr(new AbstractMediaStreamPrivate) |
| { |
| d_ptr->q_ptr = this; |
| } |
| |
| AbstractMediaStream::AbstractMediaStream(AbstractMediaStreamPrivate &dd, QObject *parent) |
| : QObject(parent), |
| d_ptr(&dd) |
| { |
| d_ptr->q_ptr = this; |
| } |
| |
| AbstractMediaStream::~AbstractMediaStream() |
| { |
| } |
| |
| qint64 AbstractMediaStream::streamSize() const |
| { |
| return d_ptr->streamSize; |
| } |
| |
| void AbstractMediaStream::setStreamSize(qint64 newSize) |
| { |
| d_ptr->setStreamSize(newSize); |
| } |
| |
| void AbstractMediaStreamPrivate::setStreamSize(qint64 newSize) |
| { |
| streamSize = newSize; |
| if (streamInterface) { |
| streamInterface->setStreamSize(newSize); |
| } |
| } |
| |
| bool AbstractMediaStream::streamSeekable() const |
| { |
| return d_ptr->streamSeekable; |
| } |
| |
| void AbstractMediaStream::setStreamSeekable(bool s) |
| { |
| d_ptr->setStreamSeekable(s); |
| } |
| |
| void AbstractMediaStreamPrivate::setStreamSeekable(bool s) |
| { |
| streamSeekable = s; |
| if (streamInterface) { |
| streamInterface->setStreamSeekable(s); |
| } |
| } |
| |
| void AbstractMediaStream::writeData(const QByteArray &data) |
| { |
| d_ptr->writeData(data); |
| } |
| |
| void AbstractMediaStreamPrivate::writeData(const QByteArray &data) |
| { |
| if (ignoreWrites) { |
| return; |
| } |
| Q_ASSERT(streamInterface); |
| streamInterface->writeData(data); |
| } |
| |
| void AbstractMediaStream::endOfData() |
| { |
| d_ptr->endOfData(); |
| } |
| |
| void AbstractMediaStreamPrivate::endOfData() |
| { |
| if (streamInterface) { |
| streamInterface->endOfData(); |
| } |
| } |
| |
| void AbstractMediaStream::error(Phonon::ErrorType type, const QString &text) |
| { |
| Q_D(AbstractMediaStream); |
| d->errorType = type; |
| d->errorText = text; |
| if (d->mediaObjectPrivate) { |
| // TODO: MediaObject might be in a different thread |
| d->mediaObjectPrivate->streamError(type, text); |
| } |
| } |
| |
| void AbstractMediaStream::enoughData() |
| { |
| } |
| |
| void AbstractMediaStream::seekStream(qint64) |
| { |
| Q_ASSERT(!d_ptr->streamSeekable); |
| } |
| |
| AbstractMediaStreamPrivate::~AbstractMediaStreamPrivate() |
| { |
| if (mediaObjectPrivate) { |
| // TODO: MediaObject might be in a different thread |
| mediaObjectPrivate->removeDestructionHandler(this); |
| } |
| if (streamInterface) { |
| // TODO: StreamInterface might be in a different thread |
| streamInterface->d->disconnectMediaStream(); |
| } |
| } |
| |
| void AbstractMediaStreamPrivate::setStreamInterface(StreamInterface *iface) |
| { |
| Q_Q(AbstractMediaStream); |
| streamInterface = iface; |
| if (!iface) { |
| // our subclass might be just about to call writeData, so tell it we have enoughData and |
| // ignore the next writeData calls |
| q->enoughData(); |
| ignoreWrites = true; |
| return; |
| } |
| if (ignoreWrites) { |
| ignoreWrites = false; |
| // we had a StreamInterface before. The new StreamInterface expects us to start reading from |
| // position 0 |
| q->reset(); |
| } else { |
| iface->setStreamSize(streamSize); |
| iface->setStreamSeekable(streamSeekable); |
| } |
| } |
| |
| void AbstractMediaStreamPrivate::setMediaObjectPrivate(MediaObjectPrivate *mop) |
| { |
| // TODO: MediaObject might be in a different thread |
| mediaObjectPrivate = mop; |
| mediaObjectPrivate->addDestructionHandler(this); |
| if (!errorText.isEmpty()) { |
| mediaObjectPrivate->streamError(errorType, errorText); |
| } |
| } |
| |
| void AbstractMediaStreamPrivate::phononObjectDestroyed(MediaNodePrivate *bp) |
| { |
| // TODO: MediaObject might be in a different thread |
| Q_ASSERT(bp == mediaObjectPrivate); |
| Q_UNUSED(bp); |
| mediaObjectPrivate = 0; |
| } |
| |
| } // namespace Phonon |
| |
| |
| QT_END_NAMESPACE |
| |
| #include "moc_abstractmediastream.cpp" |
| |
| #endif //QT_NO_PHONON_ABSTRACTMEDIASTREAM |
| |
| // vim: sw=4 sts=4 et tw=100 |