vconvert.h

Go to the documentation of this file.

/*
 * vconvert.h
 *
 * Classes to support streaming video input (grabbing) and output.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-2000 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): Derek Smithies (derek@indranet.co.nz)
 *                 Thorsten Westheider (thorsten.westheider@teleos-web.de)
 *                 Mark Cooke (mpc@star.sr.bham.ac.uk)
 */

#ifndef PTLIB_CONVERT_H
#define PTLIB_CONVERT_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib.h>

#if P_VIDEO

#include <ptlib/videoio.h>

struct jdec_private;


class PColourPair : public PObject
{
    PCLASSINFO(PColourPair, PObject)
  public:
    PColourPair(const PString & src, const PString & dst)
      : m_srcColourFormat(src)
      , m_dstColourFormat(dst)
    { }

    Comparison Compare(const PObject & other) const;

    const PString & GetSrcColourFormat() const { return m_srcColourFormat; }

    const PString & GetDstColourFormat() const { return m_dstColourFormat; }

  protected:
    const PString m_srcColourFormat;
    const PString m_dstColourFormat;
};

class PColourConverter : public PColourPair
{
    PCLASSINFO(PColourConverter, PColourPair);
  protected:
    PColourConverter(
      const PColourPair & colours
    );

  public:
    virtual void PrintOn(
      ostream & strm
    ) const;

    bool GetVFlipState() const
    { return m_verticalFlip; }
    
    void SetVFlipState(
      bool vFlipState  
    ) { m_verticalFlip = vFlipState; }
    
    virtual PBoolean SetFrameSize(
      unsigned width,   
      unsigned height   
    );

    virtual PBoolean SetSrcFrameInfo(
      const PVideoFrameInfo & info   
    );

    virtual PBoolean SetDstFrameInfo(
      const PVideoFrameInfo & info  
    );

    virtual void GetSrcFrameInfo(
      PVideoFrameInfo & info   
    );

    virtual void GetDstFrameInfo(
      PVideoFrameInfo & info  
    );

    virtual PBoolean SetSrcFrameSize(
      unsigned width,   
      unsigned height   
    );

    virtual PBoolean SetDstFrameSize(
      unsigned width,   
      unsigned height   
    );
    virtual PBoolean SetDstFrameSize(
      unsigned width,   
      unsigned height,  
      PBoolean bScale   
    );

    PINDEX GetMaxSrcFrameBytes() const { return m_srcFrameBytes; }

    void SetSrcFrameBytes(PINDEX frameBytes) { m_srcFrameBytes = frameBytes; }

    PINDEX GetMaxDstFrameBytes() const { return m_dstFrameBytes; }


    virtual PBoolean Convert(
      const BYTE * srcFrameBuffer,  
      BYTE * dstFrameBuffer,        
      PINDEX * bytesReturned = NULL 
    ) = 0;

    virtual PBoolean ConvertInPlace(
      BYTE * frameBuffer,               
      PINDEX * bytesReturned = NULL,    
      PBoolean noIntermediateFrame = false  
    );


    static PColourConverter * Create(
      const PVideoFrameInfo & src, 
      const PVideoFrameInfo & dst  
    );
    static PColourConverter * Create(
      const PString & srcColourFormat,
      const PString & destColourFormat,
      unsigned width,
      unsigned height
    );

    PBoolean GetDstFrameSize(
      unsigned & width, 
      unsigned & height 
    ) const;

    PBoolean GetSrcFrameSize(
      unsigned & width, 
      unsigned & height 
    ) const;

    unsigned GetSrcFrameWidth()  const { return m_srcFrameWidth;  }
    unsigned GetSrcFrameHeight() const { return m_srcFrameHeight; }
    unsigned GetDstFrameWidth()  const { return m_dstFrameWidth;  }
    unsigned GetDstFrameHeight() const { return m_dstFrameHeight; }

    void SetResizeMode(
      PVideoFrameInfo::ResizeMode mode
    ) { if (mode < PVideoFrameInfo::eMaxResizeMode) m_resizeMode = mode; }

    PVideoFrameInfo::ResizeMode GetResizeMode() const { return m_resizeMode; }

    static void RGBtoYUV(
      unsigned r, unsigned g, unsigned b,
      BYTE   & y, BYTE   & u, BYTE   & v
    );

    static void YUVtoRGB(
      unsigned y, unsigned u, unsigned v,
      BYTE   & r, BYTE   & g, BYTE   & b
    );

    static bool CopyYUV420P(
      unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
      unsigned srcFrameWidth, unsigned srcFrameHeight, const BYTE * srcYUV,
      unsigned dstX, unsigned dstY, unsigned dstWidth, unsigned dstHeight,
      unsigned dstFrameWidth, unsigned dstFrameHeight, BYTE * dstYUV,
      PVideoFrameInfo::ResizeMode resizeMode = PVideoFrameInfo::eScale,
      bool verticalFlip = false, std::ostream * error = NULL
    );

    static bool RotateYUV420P(
      int angle, unsigned width, unsigned height, BYTE * srcYUV, BYTE * dstYUV = NULL
    );

    static bool FillYUV420P(
      unsigned x, unsigned y, unsigned width, unsigned height,
      unsigned frameWidth, unsigned frameHeight, BYTE * yuv,
      unsigned r_or_y, unsigned g_or_u, unsigned b_or_v,
      bool rgb = true
    );

  protected:
    unsigned m_srcFrameWidth;
    unsigned m_srcFrameHeight;
    PINDEX   m_srcFrameBytes;

    // Needed for resizing
    unsigned m_dstFrameWidth;
    unsigned m_dstFrameHeight;
    PINDEX   m_dstFrameBytes;

    PVideoFrameInfo::ResizeMode m_resizeMode;
    bool                        m_verticalFlip;

    PBYTEArray m_intermediateFrameStore;

  P_REMOVE_VIRTUAL(PBoolean,Convert(const BYTE*,BYTE*,unsigned,PINDEX*),false);
};

typedef PFactory<PColourConverter, PColourPair> PColourConverterFactory;


#define PCOLOUR_CONVERTER2(cls,ancestor,srcFmt,dstFmt) \
class cls : public ancestor { \
  public: \
    cls() : ancestor(PColourPair(srcFmt, dstFmt)) { } \
    virtual PBoolean Convert(const BYTE *, BYTE *, PINDEX * = NULL); \
}; \
PFACTORY_CREATE(PColourConverterFactory, cls, PColourPair(srcFmt, dstFmt)); \
PBoolean cls::Convert(const BYTE *srcFrameBuffer, BYTE *dstFrameBuffer, PINDEX * bytesReturned) \


#define PCOLOUR_CONVERTER(cls,src,dst) \
        PCOLOUR_CONVERTER2(cls,PColourConverter,src,dst)



#if P_JPEG_DECODER

class PJPEGConverter : public PColourConverter
{
  protected:
    struct Context;
    Context * m_context;

  public:
    PJPEGConverter();
    PJPEGConverter(
      unsigned width,   
      unsigned height,  
      PVideoFrameInfo::ResizeMode resizeMode = PVideoFrameInfo::eScaleKeepAspect, 
      const PString & colourFormat = PVideoFrameInfo::YUV420P() 
    );
    PJPEGConverter(
      const PColourPair & colours
    );

    PJPEGConverter(
      const PVideoFrameInfo & src,
      const PVideoFrameInfo & dst
    );

    ~PJPEGConverter();

    virtual PBoolean Convert(
      const BYTE * srcFrameBuffer,  
      BYTE * dstFrameBuffer,        
      PINDEX * bytesReturned = NULL 
    );

    bool Load(
      const PFilePath & filename,   
      PBYTEArray & dstFrameBuffer   
    );
    bool Load(
      PFile & file,                 
      PBYTEArray & dstFrameBuffer   
    );
};

#endif  // P_JPEG_DECODER

#endif // P_VIDEO

#endif // PTLIB_CONVERT_H


// End of file ///////////////////////////////////////////////////////////////