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)
 *
 * $Revision: 30106 $
 * $Author: rjongbloed $
 * $Date: 2013-07-04 18:12:37 +1000 (Thu, 04 Jul 2013) $
 */

#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 PColourConverterRegistration : public PCaselessString
{
    PCLASSINFO(PColourConverterRegistration, PCaselessString);
  public:
    PColourConverterRegistration(
      const PString & srcColourFormat,  
      const PString & destColourFormat  
    );

  protected:
    virtual PColourConverter * Create(
      const PVideoFrameInfo & src, 
      const PVideoFrameInfo & dst  
    ) const = 0;

    PColourConverterRegistration * link;

  friend class PColourConverter;
};


class PColourConverter : public PObject
{
    PCLASSINFO(PColourConverter, PObject);
  public:
    PColourConverter(
      const PString & srcColourFormat,  
      const PString & dstColourFormat,  
      unsigned width,   
      unsigned height   
    );
    PColourConverter(
      const PVideoFrameInfo & src, 
      const PVideoFrameInfo & dst  
    );

    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   
    );

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

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

    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,
      unsigned & y, unsigned & u, unsigned & v
    );
    static void RGBtoYUV(
      unsigned r, unsigned g, unsigned b,
      BYTE   & y, BYTE   & u, BYTE   & v
    );

    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
    );

    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, unsigned g, unsigned b
    );

  protected:
    void Construct(
      const PVideoFrameInfo & src, 
      const PVideoFrameInfo & dst  
    );

    PString  m_srcColourFormat;
    PString  m_dstColourFormat;
    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);

  friend class PColourConverterRegistration;
};


#define PCOLOUR_CONVERTER2(cls,ancestor,srcFmt,dstFmt) \
class cls : public ancestor { \
  public: \
  cls(const PVideoFrameInfo & src, const PVideoFrameInfo & dst) \
    : ancestor(src, dst) { } \
  virtual PBoolean Convert(const BYTE *, BYTE *, PINDEX * = NULL); \
}; \
static class cls##_Registration : public PColourConverterRegistration { \
  public: cls##_Registration() \
    : PColourConverterRegistration(srcFmt,dstFmt) { } \
  protected: virtual PColourConverter * Create(const PVideoFrameInfo & src, const PVideoFrameInfo & dst) const; \
} p_##cls##_registration_instance; \
PColourConverter * cls##_Registration::Create(const PVideoFrameInfo & src, const PVideoFrameInfo & dst) const \
  { return new cls(src, dst); } \
PBoolean cls::Convert(const BYTE *srcFrameBuffer, BYTE *dstFrameBuffer, PINDEX * bytesReturned) \


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



class PSynonymColour : public PColourConverter {
  public:
    PSynonymColour(
      const PVideoFrameInfo & src,
      const PVideoFrameInfo & dst
    ) : PColourConverter(src, dst) { }
    virtual PBoolean Convert(const BYTE *, BYTE *, PINDEX * = NULL);
};


class PSynonymColourRegistration : public PColourConverterRegistration {
  public:
    PSynonymColourRegistration(
      const char * srcFmt,
      const char * dstFmt
    );

  protected:
    virtual PColourConverter * Create(const PVideoFrameInfo & src, const PVideoFrameInfo & dst) const;
};


#define PSYNONYM_COLOUR_CONVERTER(from,to) \
  static PSynonymColourRegistration p_##from##_##to##_registration_instance(#from,#to)


#if P_JPEG_DECODER

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

  public:
    PJPEGConverter(const PVideoFrameInfo & src, const PVideoFrameInfo & dst);
    ~PJPEGConverter();

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

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

#endif  // P_JPEG_DECODER

#endif // P_VIDEO

#endif // PTLIB_CONVERT_H


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