pwavfile.h

Go to the documentation of this file.

/*
 * pwavfile.h
 *
 * WAV file I/O channel class.
 *
 * Portable Tools 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): ______________________________________.
 */

#ifndef PTLIB_PWAVFILE_H
#define PTLIB_PWAVFILE_H

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

#include <ptlib.h>

#ifdef P_WAVFILE

#include <ptlib/pfactory.h>

class PWAVFile;

namespace PWAV {

#pragma pack(1)

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

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

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

  struct G7231ExtendedInfo
  {
    PInt16l data1;      // 1
    PInt16l data2;      // 480
  };

  struct G7231FACTChunk
  {
    PWAV::ChunkHeader hdr;
    PInt32l data1;      // 0   Should be number of samples.
  };

#pragma pack()

}; // namespace PWAV


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

  virtual unsigned GetFormat() const = 0;

  virtual PString GetFormatString() const = 0;

  virtual PString GetDescription() const = 0;

  virtual bool CanSetChannels(unsigned channels) const = 0;

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

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

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

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

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

  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;

#define PCREATE_WAVFILE_FORMAT_FACTORY(cls, id, name) \
  PFACTORY_CREATE(PWAVFileFormatByIDFactory, cls, id); \
  typedef cls cls##_ByFormat; \
  PFACTORY_CREATE(PWAVFileFormatByFormatFactory, cls##_ByFormat, name)

PFACTORY_LOAD(PWAVFileFormatPCM);


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;

protected:
};

typedef PFactory<PWAVFileConverter, unsigned> PWAVFileConverterFactory;

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

public:
  enum WaveType {
    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,
  };

  PWAVFile(
    unsigned createFormat = fmt_PCM  
  );

  PWAVFile(
    OpenMode mode,                  
    OpenOptions opts = ModeDefault, 
    unsigned createFormat = fmt_PCM 
  );

  PWAVFile(
    const PFilePath & name,         
    OpenMode mode = ReadWrite,      
    OpenOptions opts = ModeDefault, 
    unsigned createFormat = fmt_PCM 
  );

  PWAVFile(
    const PString & createFormat,   
    const PFilePath & name,         
    OpenMode mode = ReadWrite,      
    OpenOptions opts = ModeDefault  
  );

  ~PWAVFile();

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

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

  virtual PBoolean Close();

  virtual off_t GetLength() const;
      
  virtual PBoolean SetLength(
    off_t len   // New length of file.
  );

  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 GetFormatString() const;

  virtual unsigned GetChannels() const;

  virtual bool SetChannels(unsigned v);

  virtual unsigned GetSampleRate() const;

  virtual bool SetSampleRate(unsigned v);

  virtual unsigned GetSampleSize() const;

  unsigned GetRawSampleSize() const;

  virtual bool SetSampleSize(unsigned v);

  virtual unsigned GetBytesPerSecond() const;

  virtual void SetBytesPerSecond(unsigned v);

  bool SetAutoconvert(bool convert = true);

  // Internal stuff
  bool RawRead(void * buf, PINDEX len);
  bool RawWrite(const void * buf, PINDEX len);

  off_t RawGetPosition() const;
  bool RawSetPosition(off_t pos, FilePositionOrigin origin);
  off_t RawGetDataLength() { return m_dataLength; }

  // Restored for backward compatibility reasons
  static PWAVFile * format(const PString & format);
  static PWAVFile * format(const PString & format, OpenMode mode, OpenOptions opts = ModeDefault);
  __inline bool IsValid() const { return IsOpen(); }


protected:
  virtual bool InternalOpen(OpenMode mode, OpenOptions opts, PFileInfo::Permissions permissions);
  void Construct(OpenMode mode);
  bool SelectFormat(PWAVFileFormat * handler);

  bool ProcessHeader();
  bool GenerateHeader();
  bool UpdateHeader();

  unsigned            m_createFormat;
  PWAV::FMTChunk      m_wavFmtChunk;
  PBYTEArray          m_wavHeaderData;
  PBYTEArray          m_extendedHeader;
  off_t               m_headerLength;
  off_t               m_dataLength;

  PWAVFileFormat    * m_formatHandler;
  PWAVFileConverter * m_autoConverter;

  enum {
    e_Reading,
    e_PreWrite,
    e_Writing
  } m_status;

  // Rate/channel conversion of WAV file
  unsigned     m_readSampleRate;
  unsigned     m_readChannels;
  PShortArray  m_readBuffer;
  PINDEX       m_readBufCount;
  PINDEX       m_readBufPos;
};

#endif // P_WAVFILE

#endif // PTLIB_PWAVFILE_H

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