pwavfile.h

Go to the documentation of this file.

/*
 * pwavfile.h
 *
 * WAV file I/O channel class.
 *
 * Portable Windows Library
 *
 * Copyright (c) 2001 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
 * Roger Hardiman <roger@freebsd.org>
 * and Shawn Pai-Hsiang Hsiao <shawn@eecs.harvard.edu>
 *
 * All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 20385 $
 * $Author: rjongbloed $
 * $Date: 2008-06-04 10:40:38 +0000 (Wed, 04 Jun 2008) $
 */

#ifndef _PWAVFILE
#define _PWAVFILE

//#ifdef P_USE_PRAGMA
//#pragma interface
//#endif

#ifndef _PTLIB_H
#include <ptlib.h>
#endif

#include <ptlib/pfactory.h>

class PWAVFile;

namespace PWAV {

#ifdef __GNUC__
#define P_PACKED    __attribute__ ((packed));
#else
#define P_PACKED
#pragma pack(1)
#endif

struct ChunkHeader
{
  char    tag[4];
  PInt32l len    P_PACKED;
};

struct RIFFChunkHeader 
{
  ChunkHeader hdr;
  char        tag[4];
};

struct FMTChunk
{
  ChunkHeader hdr;                    
  PUInt16l format          P_PACKED;  
  PUInt16l numChannels     P_PACKED;  
  PUInt32l sampleRate      P_PACKED;  
  PUInt32l bytesPerSec     P_PACKED;  
  PUInt16l bytesPerSample  P_PACKED;  
  PUInt16l bitsPerSample   P_PACKED;  
};

}; // namespace PWAV

#ifdef __GNUC__
#undef P_PACKED
#else
#pragma pack()
#endif

class PWAVFileFormat
{
  public:
    virtual ~PWAVFileFormat() { }

    virtual unsigned GetFormat() const = 0;

    virtual PString GetFormatString() const = 0;

    virtual PString GetDescription() const = 0;

    virtual void CreateHeader(PWAV::FMTChunk & header, PBYTEArray & extendedHeader) = 0;

    virtual void UpdateHeader(PWAV::FMTChunk & /*header*/, PBYTEArray & /*extendedHeader*/)
    { }

    virtual PBoolean WriteExtraChunks(PWAVFile & /*file*/)
    { return PTrue; }

    virtual PBoolean ReadExtraChunks(PWAVFile & /*file*/)
    { return PTrue; }

    virtual void OnStart()
    { }

    virtual void OnStop()
    { }

    virtual PBoolean Read(PWAVFile & file, void * buf, PINDEX & len);

    virtual PBoolean Write(PWAVFile & file, const void * buf, PINDEX & len);
};

typedef PFactory<PWAVFileFormat, PCaselessString> PWAVFileFormatByFormatFactory;
typedef PFactory<PWAVFileFormat, unsigned> PWAVFileFormatByIDFactory;

class PWAVFileConverter 
{
  public:
    virtual ~PWAVFileConverter() { }
    virtual unsigned GetFormat    (const PWAVFile & file) const = 0;
    virtual off_t GetPosition     (const PWAVFile & file) const = 0;
    virtual PBoolean SetPosition      (PWAVFile & file, off_t pos, PFile::FilePositionOrigin origin) = 0;
    virtual unsigned GetSampleSize(const PWAVFile & file) const = 0;
    virtual off_t GetDataLength   (PWAVFile & file) = 0;
    virtual PBoolean Read             (PWAVFile & file, void * buf, PINDEX len)  = 0;
    virtual PBoolean Write            (PWAVFile & file, const void * buf, PINDEX len) = 0;
};

typedef PFactory<PWAVFileConverter, unsigned> PWAVFileConverterFactory;

class PWAVFile : public PFile
{
  PCLASSINFO(PWAVFile, PFile);

  public:
    enum {
      fmt_PCM         = 1,      
      fmt_MSADPCM     = 2,      
      fmt_ALaw        = 6,      
      fmt_uLaw        = 7,      
      fmt_VOXADPCM    = 0x10,   
      fmt_IMAADPCM    = 0x11,   
      fmt_GSM         = 0x31,   
      fmt_G728        = 0x41,   
      fmt_G723        = 0x42,   
      fmt_MSG7231     = 0x42,   
      fmt_G726        = 0x64,   
      fmt_G722        = 0x65,   
      fmt_G729        = 0x83,   
      fmt_VivoG7231   = 0x111,  

      // For backward compatibility
      PCM_WavFile     = fmt_PCM,
      G7231_WavFile   = fmt_VivoG7231,

      // allow opening files without knowing the format
      fmt_NotKnown    = 0x10000
    };

    PWAVFile(
      unsigned format = fmt_PCM 
    );
    static PWAVFile * format(
      const PString & format    
    );

    PWAVFile(
      OpenMode mode,          
      int opts = ModeDefault, 
      unsigned format = fmt_PCM 
    );
    static PWAVFile * format(
      const PString & format,  
      PFile::OpenMode mode,          
      int opts = PFile::ModeDefault 
    );

    PWAVFile(
      const PFilePath & name,     
      OpenMode mode = ReadWrite,  
      int opts = ModeDefault,     
      unsigned format = fmt_PCM 
    );
    PWAVFile(
      const PString & format,  
      const PFilePath & name,     
      OpenMode mode = PFile::ReadWrite,  
      int opts = PFile::ModeDefault     
    );

    ~PWAVFile();

    virtual PBoolean Read(
      void * buf,   
      PINDEX len    
    );

    virtual PBoolean Write(
      const void * buf,   
      PINDEX len    
    );

    virtual PBoolean Open(
      OpenMode mode = ReadWrite,  
      int opts = ModeDefault      
    );

    virtual PBoolean Open(
      const PFilePath & name,    
      OpenMode mode = ReadWrite, 
      int opts = ModeDefault     
    );

    virtual PBoolean Close();

    virtual PBoolean SetPosition(
      off_t pos,                         
      FilePositionOrigin origin = Start  
    );

    virtual off_t GetPosition() const;

    virtual PBoolean SetFormat(unsigned fmt);
    virtual PBoolean SetFormat(const PString & format);

    virtual unsigned GetFormat() const;
    virtual PString GetFormatAsString() const;

    virtual unsigned GetChannels() const;
    virtual void SetChannels(unsigned v);

    virtual unsigned GetSampleRate() const;
    virtual void SetSampleRate(unsigned v);

    virtual unsigned GetSampleSize() const;
    virtual void SetSampleSize(unsigned v);

    virtual unsigned GetBytesPerSecond() const;
    virtual void SetBytesPerSecond(unsigned v);

    off_t GetHeaderLength() const;

    virtual off_t GetDataLength();

    PBoolean IsValid() const { return isValidWAV; }

    PString GetFormatString() const
    { if (formatHandler == NULL) return PString("N/A"); else return formatHandler->GetFormatString(); }

    void SetAutoconvert();

 
    friend class PWAVFileConverter;

    PBoolean RawRead(void * buf, PINDEX len);
    PBoolean RawWrite(const void * buf, PINDEX len);

    PBoolean FileRead(void * buf, PINDEX len);
    PBoolean FileWrite(const void * buf, PINDEX len);

    off_t RawGetPosition() const;
    PBoolean RawSetPosition(off_t pos, FilePositionOrigin origin);
    off_t RawGetDataLength();

    void SetLastReadCount(PINDEX v) { lastReadCount = v; } 

    PWAV::FMTChunk wavFmtChunk;
    PBYTEArray extendedHeader;

  protected:
    void Construct();
    void SelectFormat(unsigned fmt);
    void SelectFormat(const PString & format);

    PBYTEArray wavHeaderData;

    PBoolean ProcessHeader();
    PBoolean GenerateHeader();
    PBoolean UpdateHeader();

    PBoolean     isValidWAV;

    unsigned int origFmt;
    PWAVFileFormat * formatHandler;

    PBoolean     autoConvert;
    PWAVFileConverter * autoConverter;

    off_t lenHeader;
    off_t lenData;

    PBoolean     header_needs_updating;
};

#endif

// End Of File ///////////////////////////////////////////////////////////////

---