/*  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 "videorenderer_soft.h"

#ifndef QT_NO_PHONON_VIDEO

#include "qmeminputpin.h"

#include "qbasefilter.h"

#include <QtGui/QPainter>

#include <QtGui/QPaintEngine>

#include <QtGui/QApplication>

#include <QtCore/QTime>

#define _USE_MATH_DEFINES //for pi

#include <QtCore/qmath.h> //for sin and cos

/* M_PI is a #define that may or may not be handled in <cmath> */

#ifndef M_PI

#define M_PI 3.14159265358979323846264338327950288419717

#endif

#include <dvdmedia.h> //for VIDEOINFOHEADER2

//this will make a display every second of how many frames were pocessed and actually displayed

//#define FPS_COUNTER

#ifdef Q_OS_WINCE

#define QT_NO_OPENGL

#endif

#ifndef QT_NO_OPENGL

#include <gl/gl.h>

#ifndef GL_FRAGMENT_PROGRAM_ARB

#define GL_FRAGMENT_PROGRAM_ARB           0x8804

#define GL_PROGRAM_FORMAT_ASCII_ARB       0x8875

#endif

// support old OpenGL installations (1.2)

// assume that if TEXTURE0 isn't defined, none are

#ifndef GL_TEXTURE0

# define GL_TEXTURE0    0x84C0

# define GL_TEXTURE1    0x84C1

# define GL_TEXTURE2    0x84C2

#endif

// arbfp1 fragment program for converting yuv (YV12) to rgb

static const char yv12ToRgb[] =

"!!ARBfp1.0"

"PARAM c[5] = { program.local[0..1],"

"{ 1.164, 0, 1.596, 0.5 },"

"{ 0.0625, 1.164, -0.391, -0.81300002 },"

"{ 1.164, 2.0179999, 0 } };"

"TEMP R0;"

"TEX R0.x, fragment.texcoord[0], texture[1], 2D;"

"ADD R0.y, R0.x, -c[2].w;"

"TEX R0.x, fragment.texcoord[0], texture[2], 2D;"

"ADD R0.x, R0, -c[2].w;"

"MUL R0.z, R0.y, c[0].w;"

"MAD R0.z, R0.x, c[0], R0;"

"MUL R0.w, R0.x, c[0];"

"MUL R0.z, R0, c[0].y;"

"TEX R0.x, fragment.texcoord[0], texture[0], 2D;"

"MAD R0.y, R0, c[0].z, R0.w;"

"ADD R0.x, R0, -c[3];"

"MUL R0.y, R0, c[0];"

"MUL R0.z, R0, c[1].x;"

"MAD R0.x, R0, c[0].y, c[0];"

"MUL R0.y, R0, c[1].x;"

"DP3 result.color.x, R0, c[2];"

"DP3 result.color.y, R0, c[3].yzww;"

"DP3 result.color.z, R0, c[4];"

"MOV result.color.w, c[1].y;"

"END";

static const char yuy2ToRgb[] =

"!!ARBfp1.0"

"PARAM c[5] = { program.local[0..1],"

"{ 0.5, 2, 1, 0.0625 },"

"{ 1.164, 0, 1.596, 2.0179999 },"

"{ 1.164, -0.391, -0.81300002 } };"

"TEMP R0;"

"TEMP R1;"

"TEMP R2;"

"FLR R1.z, fragment.texcoord[0].x;"

"ADD R0.x, R1.z, c[2];"

"ADD R1.z, fragment.texcoord[0].x, -R1;"

"MUL R1.x, fragment.texcoord[0].z, R0;"

"MOV R1.y, fragment.texcoord[0];"

"TEX R0, R1, texture[0], 2D;"

"ADD R1.y, R0.z, -R0.x;"

"MUL R2.x, R1.z, R1.y;"

"MAD R0.x, R2, c[2].y, R0;"

"MOV R1.y, fragment.texcoord[0];"

"ADD R1.x, fragment.texcoord[0].z, R1;"

"TEX R1.xyw, R1, texture[0], 2D;"

"ADD R2.x, R1, -R0.z;"

"MAD R1.x, R1.z, c[2].y, -c[2].z;"

"MAD R0.z, R1.x, R2.x, R0;"

"ADD R1.xy, R1.ywzw, -R0.ywzw;"

"ADD R0.z, R0, -R0.x;"

"SGE R1.w, R1.z, c[2].x;"

"MAD R0.x, R1.w, R0.z, R0;"

"MAD R0.yz, R1.z, R1.xxyw, R0.xyww;"

"ADD R0.xyz, R0, -c[2].wxxw;"

"MUL R0.w, R0.y, c[0];"

"MAD R0.w, R0.z, c[0].z, R0;"

"MUL R0.z, R0, c[0].w;"

"MAD R0.y, R0, c[0].z, R0.z;"

"MUL R0.w, R0, c[0].y;"

"MUL R0.y, R0, c[0];"

"MUL R0.z, R0.w, c[1].x;"

"MAD R0.x, R0, c[0].y, c[0];"

"MUL R0.y, R0, c[1].x;"

"DP3 result.color.x, R0, c[3];"

"DP3 result.color.y, R0, c[4];"

"DP3 result.color.z, R0, c[3].xwyw;"

"MOV result.color.w, c[1].y;"

"END";

#endif //QT_NO_OPENGL

#define CLIP_SHIFT_RIGHT_8(c) ((c) < 0 ? 0 : (c) > 0xffff ? 0xff : (c) >> 8)

#define CLIP_SHIFT_LEFT_8(c) ((c) < 0 ? 0 : (c) > 0xffff ? 0xff0000 : ( ((c) << 8) & 0xff0000) )

#define CLIP_NO_SHIFT(c) ((c) < 0 ? 0 : (c) > 0xffff ? 0xff00 : ((c) & 0xff00) )

#define CLIPPED_PIXEL(base, r, g, b) (0xff000000u | CLIP_SHIFT_LEFT_8(base+r) | CLIP_NO_SHIFT(base+g) | CLIP_SHIFT_RIGHT_8(base+b))

#define CLIPPED_PIXEL2(r, g, b) (0xff000000u | CLIP_SHIFT_LEFT_8(r) | CLIP_NO_SHIFT(g) | CLIP_SHIFT_RIGHT_8(b))

QT_BEGIN_NAMESPACE

namespace Phonon

{

    namespace DS9

    {

        static const QVector<AM_MEDIA_TYPE> videoMediaTypes()

        {

            AM_MEDIA_TYPE mt = { MEDIATYPE_Video, MEDIASUBTYPE_YV12, 0, 0, 0, GUID_NULL, 0, 0, 0 };

            QVector<AM_MEDIA_TYPE> ret;

            //we add all the subtypes we support

            ret << mt; //YV12

            mt.subtype = MEDIASUBTYPE_YUY2;

            ret << mt; //YUY2

            mt.subtype = MEDIASUBTYPE_RGB32;

            ret << mt; //RGB32

            return ret;

        }

        class VideoRendererSoftFilter : public QBaseFilter

        {

        public:

            VideoRendererSoftFilter(VideoRendererSoft *renderer);

            ~VideoRendererSoftFilter();

            QSize videoSize() const;

#ifndef QT_NO_OPENGL

            void freeGLResources()

            {

                if (m_usingOpenGL) {

                    //let's reinitialize those values

                    m_usingOpenGL = false;

                    //to be sure we recreate it

                    if (m_textureUploaded) {

                        glDeleteTextures(3, m_texture);

                        m_textureUploaded = false;

                    }

                }

                m_checkedPrograms = false;

            }

#endif // QT_NO_OPENGL

            void freeResources()

            {

                QMutexLocker locker(&m_mutex);

                m_sampleBuffer = ComPointer<IMediaSample>();

#ifndef QT_NO_OPENGL

                freeGLResources();

                m_textureUploaded = false;

#endif // QT_NO_OPENGL

            }

            void endOfStream()

            {

                //received from the input pin

                ::SetEvent(m_receiveCanWait); //unblocks the flow

                //we send the message to the graph

                ComPointer<IMediaEventSink> sink(graph(), IID_IMediaEventSink);

                if (sink) {

                    sink->Notify(EC_COMPLETE, S_OK,

                        reinterpret_cast<LONG_PTR>(static_cast<IBaseFilter*>(this)));

                }

            }

            void freeMediaSample()

            {

                QMutexLocker locker(&m_mutex);

                m_sampleBuffer = ComPointer<IMediaSample>();

            }

            void beginFlush()

            {

                freeMediaSample();

                ::SetEvent(m_receiveCanWait); //unblocks the flow

            }

            void endFlush()

            {

                if (m_inputPin->connected() == 0) {

                    ::SetEvent(m_receiveCanWait); //unblock the flow in receive

                } else {

                    ::ResetEvent(m_receiveCanWait); //block the flow again

                }

            }

            STDMETHODIMP Stop()

            {

                HRESULT hr = QBaseFilter::Stop();

                beginFlush();

                return hr;

            }

            STDMETHODIMP Pause()

            {

                HRESULT hr = QBaseFilter::Pause();

                if (m_inputPin->connected() == 0) {

                    ::SetEvent(m_receiveCanWait); //unblock the flow in receive

                } else {

                    ::ResetEvent(m_receiveCanWait); //this will block

                }

                return hr;

            }

            STDMETHODIMP Run(REFERENCE_TIME start)

            {

                HRESULT hr = QBaseFilter::Run(start);

                m_start = start;

                if (m_inputPin->connected() == 0) {

                    endOfStream();

                } else {

                    ::SetEvent(m_receiveCanWait); //unblocks the flow (this event will block then again)

                }

#ifdef FPS_COUNTER

                fpsTime.restart();

                nbFramesProcessed = 0;

                nbFramesDisplayed = 0;

#endif

                return hr;

            }

            HRESULT processSample(IMediaSample *sample);

            void applyMixerSettings(qreal brightness, qreal contrast, qreal hue, qreal saturation)

            {

                //let's normalize the values

                m_brightness = brightness * 128;

                m_contrast = contrast + 1.;

                m_hue = hue * M_PI;

                m_saturation = saturation + 1.;

            }

            QImage currentImage() const

            {

                return m_currentImage;

            }

            void setCurrentImage(const QImage &image)

            {

                QMutexLocker locker(&m_mutex);

                m_currentImage = image;

            }

            //the following function is called from the GUI thread

            void repaintCurrentFrame(QPainter &painter, const QRect &r);

        protected:

            static void convertYV12toRGB(const uchar *data, const QSize &s, QImage &dest,

                                         qreal brightness, qreal contrast, qreal hue, qreal saturation);

            static void convertYUY2toRGB(const uchar *data, const QSize &s, QImage &dest,

                                         qreal brightness, qreal contrast, qreal hue, qreal saturation);

            static void normalizeRGB(const uchar *data, const QSize &s, QImage &destImage);

        private:

            QPin *const m_inputPin;

            ComPointer<IMediaSample> m_sampleBuffer;

            QImage m_currentImage;

            VideoRendererSoft *m_renderer;

            mutable QMutex m_mutex;

            REFERENCE_TIME m_start;

            HANDLE m_renderEvent, m_receiveCanWait;         // Signals sample to render

            QSize m_size;

            //mixer settings

            qreal m_brightness,

                  m_contrast,

                  m_hue,

                  m_saturation;

#ifdef FPS_COUNTER

           QTime fpsTime;

           int nbFramesProcessed;

           int nbFramesDisplayed;

#endif

#ifndef QT_NO_OPENGL

            enum Program

            {

                YV12toRGB = 0,

                YUY2toRGB = 1,

                ProgramCount = 2

            };

            void updateTexture();

            bool checkGLPrograms();

            // ARB_fragment_program

            typedef void (APIENTRY *_glProgramStringARB) (GLenum, GLenum, GLsizei, const GLvoid *);

            typedef void (APIENTRY *_glBindProgramARB) (GLenum, GLuint);

            typedef void (APIENTRY *_glDeleteProgramsARB) (GLsizei, const GLuint *);

            typedef void (APIENTRY *_glGenProgramsARB) (GLsizei, GLuint *);

            typedef void (APIENTRY *_glProgramLocalParameter4fARB) (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat);

            typedef void (APIENTRY *_glActiveTexture) (GLenum);

            _glProgramStringARB glProgramStringARB;

            _glBindProgramARB glBindProgramARB;

            _glDeleteProgramsARB glDeleteProgramsARB;

            _glGenProgramsARB glGenProgramsARB;

            _glProgramLocalParameter4fARB glProgramLocalParameter4fARB;

            _glActiveTexture glActiveTexture;

            bool m_checkedPrograms;

            bool m_usingOpenGL;

            bool m_textureUploaded;

            GLuint m_program[2];

            GLuint m_texture[3];

#endif

        };

        class VideoRendererSoftPin : public QMemInputPin

        {

        public:

            VideoRendererSoftPin(VideoRendererSoftFilter *parent) :

              QMemInputPin(parent, videoMediaTypes(), false /*no transformation of the samples*/, 0),

                  m_renderer(parent)

              {

              }

              STDMETHODIMP EndOfStream()

              {

                  m_renderer->endOfStream();

                  return QMemInputPin::EndOfStream();

              }

              STDMETHODIMP ReceiveCanBlock()

              {

                  //yes, it can block

                  return S_OK;

              }

              STDMETHODIMP BeginFlush()

              {

                  m_renderer->beginFlush();

                  return QMemInputPin::BeginFlush();

              }

              STDMETHODIMP EndFlush()

              {

                  m_renderer->endFlush();

                  return QMemInputPin::EndFlush();

              }

              STDMETHODIMP GetAllocatorRequirements(ALLOCATOR_PROPERTIES *prop)

              {

                  if (!prop) {

                      return E_POINTER;

                  }

                  //we need 2 buffers

                  prop->cBuffers = 2;

                  return S_OK;

              }

              STDMETHODIMP NotifyAllocator(IMemAllocator *alloc, BOOL readonly)

              {

                  if (!alloc) {

                      return E_POINTER;

                  }

                  ALLOCATOR_PROPERTIES prop;

                  HRESULT hr = alloc->GetProperties(&prop);

                  if (SUCCEEDED(hr) && prop.cBuffers == 1) {

                      //we ask to get 2 buffers so that we don't block the flow 

                      //when we addref the mediasample

                      prop.cBuffers = 2;

                      ALLOCATOR_PROPERTIES dummy;

                      alloc->SetProperties(&prop, &dummy);

                  }

                  return QMemInputPin::NotifyAllocator(alloc, readonly);

              }

        private:

            VideoRendererSoftFilter * const m_renderer;

        };

        VideoRendererSoftFilter::VideoRendererSoftFilter(VideoRendererSoft *renderer) :

        QBaseFilter(CLSID_NULL), m_inputPin(new VideoRendererSoftPin(this)),

            m_renderer(renderer), m_start(0)

#ifndef QT_NO_OPENGL

            , m_checkedPrograms(false), m_usingOpenGL(false), m_textureUploaded(false)

#endif

        {

            m_renderEvent    = ::CreateEvent(0, 0, 0, 0);

            m_receiveCanWait = ::CreateEvent(0, 0, 0, 0);

            //simply initialize the array with default values

            applyMixerSettings(0., 0., 0., 0.);

#ifndef QT_NO_OPENGL

#endif

        }

        VideoRendererSoftFilter::~VideoRendererSoftFilter()

        {

            ::CloseHandle(m_renderEvent);

            ::CloseHandle(m_receiveCanWait);

            //this frees up resources

            freeResources();

        }

        QSize VideoRendererSoftFilter::videoSize() const

        {

            QSize ret;

            const AM_MEDIA_TYPE &mt = m_inputPin->connectedType();

            if (mt.pbFormat && mt.pbFormat) {

                if (mt.formattype == FORMAT_VideoInfo) {

                    const VIDEOINFOHEADER *header = reinterpret_cast<VIDEOINFOHEADER*>(mt.pbFormat);

                    const int h = qAbs(header->bmiHeader.biHeight),

                        w = qAbs(header->bmiHeader.biWidth);

                    ret = QSize(w, h);

                } else if (mt.formattype == FORMAT_VideoInfo2) {

                    const VIDEOINFOHEADER2 *header = reinterpret_cast<VIDEOINFOHEADER2*>(mt.pbFormat);

                    const int h = qAbs(header->bmiHeader.biHeight),

                        w = qAbs(header->bmiHeader.biWidth);

                    ret = QSize(w, h);

                }

            }

            return ret;

        }

        HRESULT VideoRendererSoftFilter::processSample(IMediaSample *sample)

        {

#ifdef FPS_COUNTER

            if (fpsTime.elapsed() > 1000) {

                qDebug("FPS_COUNTER: processed=%d, displayed=%d (%d)", nbFramesProcessed, nbFramesDisplayed, fpsTime.elapsed());

                nbFramesProcessed = 0;

                nbFramesDisplayed = 0;

                fpsTime.restart();

            }

#endif

            AM_MEDIA_TYPE *type = 0;

            if (sample->GetMediaType(&type) == S_OK) {

                //let's update the media type of the input pin

                m_inputPin->setConnectedType(*type);

            }

            const AM_MEDIA_TYPE &mt = m_inputPin->connectedType();

            if (mt.pbFormat == 0 || mt.cbFormat == 0) {

                return VFW_E_INVALIDMEDIATYPE;

            }

            m_size = videoSize();

            if (!m_size.isValid()) {

                return VFW_E_INVALIDMEDIATYPE;

            }

#ifdef FPS_COUNTER

            nbFramesProcessed++;

#endif

            REFERENCE_TIME start = 0, stop = 0;

            HRESULT hr = sample->GetTime(&start, &stop);

            ComPointer<IReferenceClock> clock;

            GetSyncSource(clock.pparam());

            const bool playing = SUCCEEDED(hr) && state() == State_Running && clock;

            if (playing) {

                REFERENCE_TIME current;

                clock->GetTime(&current);

                DWORD_PTR advise;

                //let's synchronize here

                clock->AdviseTime(m_start, start,