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: 20385 $
 * $Author: rjongbloed $
 * $Date: 2008-06-04 10:40:38 +0000 (Wed, 04 Jun 2008) $
 */

#ifndef _PCONVERT
#define _PCONVERT

#ifdef P_USE_PRAGMA
#ifndef P_MACOSX
#pragma interface
#endif
#endif

#include <ptbuildopts.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  
    );

    PBoolean GetVFlipState() 
      { return verticalFlip; }
    
    void SetVFlipState(PBoolean vFlipState) 
      { 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() { return srcColourFormat; }

    const PString & GetDstColourFormat() { return dstColourFormat; }

    PINDEX GetMaxSrcFrameBytes() { return srcFrameBytes; }

    PINDEX GetMaxDstFrameBytes() { return dstFrameBytes; }


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

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

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


    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 srcFrameWidth;  }
    unsigned GetSrcFrameHeight() const { return srcFrameHeight; }
    unsigned GetDstFrameWidth()  const { return dstFrameWidth;  }
    unsigned GetDstFrameHeight() const { return dstFrameHeight; }

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

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

  protected:
    PString  srcColourFormat;
    PString  dstColourFormat;
    unsigned srcFrameWidth;
    unsigned srcFrameHeight;
    unsigned srcFrameBytes;

    // Needed for resizing
    unsigned dstFrameWidth;
    unsigned dstFrameHeight;
    unsigned dstFrameBytes;

    PVideoFrameInfo::ResizeMode resizeMode;
     
    PBoolean     verticalFlip;

    PBYTEArray intermediateFrameStore;

#ifndef P_MACOSX
      /* Use by the jpeg decompressor */
    struct jdec_private *jdec;
#endif

  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); \
  virtual PBoolean Convert(const BYTE *, BYTE *, unsigned int , 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, unsigned int __srcFrameBytes, PINDEX * bytesReturned) \
  { srcFrameBytes = __srcFrameBytes;return Convert(srcFrameBuffer, dstFrameBuffer, bytesReturned); } \
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);
    virtual PBoolean Convert(const BYTE *, BYTE *, unsigned int , 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)


class PVideoTools {
  public:
    static void GenerateYUV420NTSCTestFrame(BYTE *resFrame, unsigned frameWidth, unsigned frameHeight, unsigned bytesPerPixel, unsigned scanLineWidth);
    static void FillYUV420Rect(BYTE * frame, unsigned bytesPerPixel, unsigned scanLineWidth,
                               unsigned frameWidth, unsigned frameHeight, 
                               int xPos, int initialYPos, int rectWidth, int rectHeight, int r, int g,  int b);
};

#endif // P_VIDEO


#endif // _PCONVERT

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

---