/*  This file is part of the KDE project.

Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

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 or 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 "iodevicereader.h"

#include "qasyncreader.h"

#include "mediagraph.h"

#include <phonon/streaminterface.h>

#include <dshow.h>

#include <initguid.h>

QT_BEGIN_NAMESPACE

#ifndef QT_NO_PHONON_ABSTRACTMEDIASTREAM

namespace Phonon

{

    namespace DS9

    {

        //these mediatypes define a stream, its type will be autodetected by DirectShow

        static QVector<AM_MEDIA_TYPE> getMediaTypes()

        {

            //the order here is important because otherwise,

            //directshow might not be able to detect the stream type correctly

            AM_MEDIA_TYPE mt = { MEDIATYPE_Stream, MEDIASUBTYPE_Avi, TRUE, FALSE, 1, GUID_NULL, 0, 0, 0};

            QVector<AM_MEDIA_TYPE> ret;

            //AVI stream

            ret << mt;

            //WAVE stream

            mt.subtype = MEDIASUBTYPE_WAVE;

            ret << mt;

            //normal auto-detect stream (must be at the end!)

            mt.subtype = MEDIASUBTYPE_NULL;

            ret << mt;

            return ret;

        }

        class StreamReader : public QAsyncReader, public Phonon::StreamInterface

        {

        public:

            StreamReader(QBaseFilter *parent, const Phonon::MediaSource &source, const MediaGraph *mg) : 

              QAsyncReader(parent, getMediaTypes()),

                  m_seekable(false), m_pos(0), m_size(-1), m_mediaGraph(mg)

              {

                  connectToSource(source);

              }

              //for Phonon::StreamInterface

              void writeData(const QByteArray &data)

              {

                  m_pos += data.size();

                  m_buffer += data;

              }

              void endOfData()

              {

              }

              void setStreamSize(qint64 newSize)

              {

                  QMutexLocker locker(&m_mutex);

                  m_size = newSize;

              }

              void setStreamSeekable(bool s)

              {

                  QMutexLocker locker(&m_mutex);

                  m_seekable = s;

              }

              //virtual pure members

              //implementation from IAsyncReader

              STDMETHODIMP Length(LONGLONG *total, LONGLONG *available)

              {

                  QMutexLocker locker(&m_mutex);

                  if (total) {

                      *total = m_size;

                  }

                  if (available) {

                      *available = m_size;

                  }

                  return S_OK;

              }

              HRESULT read(LONGLONG pos, LONG length, BYTE *buffer, LONG *actual)

              {

                  Q_ASSERT(!m_mutex.tryLock());

                  if (m_mediaGraph->isStopping()) {

                      return VFW_E_WRONG_STATE;

                  }

                  if(m_size != 1 && pos + length > m_size) {

                      //it tries to read outside of the boundaries

                      return E_FAIL;

                  }

                  if (m_pos - m_buffer.size() != pos) {

                      if (!m_seekable) {

                          return S_FALSE;

                      }

                      m_pos = pos;

                      seekStream(pos);

                      m_buffer.clear();

                  }

                  int oldSize = m_buffer.size();

                  while (m_buffer.size() < int(length)) {

                      needData();

                      if (oldSize == m_buffer.size()) {

                          break; //we didn't get any data

                      }

                      oldSize = m_buffer.size();

                  }

                  int bytesRead = qMin(m_buffer.size(), int(length));

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

                  //truncate the buffer

                  m_buffer = m_buffer.mid(bytesRead);

                  if (actual) {

                      *actual = bytesRead; //initialization

                  }

                  return bytesRead == length ? S_OK : S_FALSE;

              }

        public:

            //for Phonon::StreamInterface

            QByteArray m_buffer;

            bool m_seekable;

            qint64 m_pos;

            qint64 m_size;

            const MediaGraph *m_mediaGraph;

        };

        IODeviceReader::IODeviceReader(const Phonon::MediaSource &source, const MediaGraph *mg) :

        QBaseFilter(CLSID_NULL)

        {

            //create the output pin

            m_streamReader = new StreamReader(this, source, mg);

        }

        IODeviceReader::~IODeviceReader()

        {

        }

    }

}

#endif //QT_NO_PHONON_ABSTRACTMEDIASTREAM

QT_END_NAMESPACE