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 "backendheader.h"

    19 #include "quicktimestreamreader.h"

    20 

    21 QT_BEGIN_NAMESPACE

    22 

    23 namespace Phonon

    24 {

    25 namespace QT7

    26 {

    27 

    28 QuickTimeStreamReader::QuickTimeStreamReader(const Phonon::MediaSource &source)

    29 {

    30     connectToSource(source);

    31 }

    32 

    33 QuickTimeStreamReader::~QuickTimeStreamReader()

    34 {

    35 }

    36 

    37 bool QuickTimeStreamReader::readAllData()

    38 {

    39     int oldSize = m_buffer.size();

    40     while (m_buffer.size() < m_size){

    41         needData();

    42         if (oldSize == currentBufferSize())

    43             BACKEND_ASSERT3(oldSize != currentBufferSize(),

    44                 "Could not create new movie from IO stream. Not enough free memory to preload the whole movie.",

    45                 FATAL_ERROR, false)

    46         oldSize = m_buffer.size();

    47     }

    48     return true;

    49 }

    50 

    51 QByteArray *QuickTimeStreamReader::pointerToData()

    52 {

    53     return &m_buffer;

    54 }

    55 

    56 int QuickTimeStreamReader::readData(long offset, long size, void *data)

    57 {

    58 //    QReadLocker readLocker(&m_lock);

    59     if (streamSize() != 1 && offset + size > streamSize()){

    60         size = streamSize() - offset;

    61     }

    62 

    63     if (currentPos() - currentBufferSize() != offset)

    64         setCurrentPos(offset);

    65 

    66     int oldSize = currentBufferSize();

    67     while (currentBufferSize() < int(size)) {

    68         needData();

    69         if (oldSize == currentBufferSize())

    70             break;

    71         oldSize = currentBufferSize();

    72     }

    73     

    74     int bytesRead = qMin(currentBufferSize(), int(size));

    75 //    QWriteLocker writeLocker(&m_lock);

    76     qMemCopy(data, m_buffer.data(), bytesRead);

    77     m_buffer = m_buffer.mid(bytesRead);

    78 

    79     return bytesRead;

    80 }

    81     

    82 void QuickTimeStreamReader::writeData(const QByteArray &data)

    83 {

    84     QWriteLocker locker(&m_lock);

    85     m_pos += data.size();

    86     m_buffer += data;

    87 }

    88 

    89 void QuickTimeStreamReader::endOfData()

    90 {

    91 }

    92 

    93 void QuickTimeStreamReader::setStreamSize(qint64 newSize)

    94 {

    95     m_size = newSize;

    96 }

    97 

    98 qint64 QuickTimeStreamReader::streamSize() const

    99 {

   100     return m_size;

   101 }

   102 

   103 void QuickTimeStreamReader::setStreamSeekable(bool s)

   104 {

   105     m_seekable = s;

   106 }

   107 

   108 bool QuickTimeStreamReader::streamSeekable() const

   109 {

   110     return m_seekable;

   111 }

   112 

   113 void QuickTimeStreamReader::setCurrentPos(qint64 pos)

   114 {

   115     QWriteLocker locker(&m_lock);

   116     m_pos = pos;

   117     seekStream(pos);

   118     m_buffer.clear();

   119 }

   120 

   121 qint64 QuickTimeStreamReader::currentPos() const

   122 {

   123     return m_pos;

   124 }

   125 

   126 int QuickTimeStreamReader::currentBufferSize() const

   127 {

   128     QReadLocker locker(&m_lock);

   129     return m_buffer.size();

   130 }

   131 

   132 }} //namespace Phonon::QT7

   133 

   134 QT_END_NAMESPACE

   135 

   136 #include "moc_quicktimestreamreader.cpp"

   137