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): ______________________________________.
 *
 * $Revision: 27140 $
 * $Author: rjongbloed $
 * $Date: 2012-03-07 14:53:56 +1100 (Wed, 07 Mar 2012) $
 */

#ifndef PTLIB_PWAVFILE_H
#define PTLIB_PWAVFILE_H

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

#include <ptbuildopts.h>

#ifdef P_WAVFILE

#include <ptlib/pfactory.h>

class PWAVFile;

namespace PWAV {

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

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

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

}; // 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 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;

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

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,

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

  PWAVFile(
    unsigned format = fmt_PCM 
  );

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

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

  PWAVFile(
    const PString & format,  
    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 Open(
    OpenMode mode = ReadWrite,  
    OpenOptions opts = ModeDefault      
  );

  virtual PBoolean Open(
    const PFilePath & name,    
    OpenMode mode = ReadWrite, 
    OpenOptions 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();


  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; }
  void SetLastWriteCount(PINDEX v) { lastWriteCount = v; }

  // Restored for backward compatibility reasons
  static PWAVFile * format(const PString & format);
  static PWAVFile * format(const PString & format, OpenMode mode, OpenOptions opts = ModeDefault);


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

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

  PBYTEArray wavHeaderData;
  PWAV::FMTChunk wavFmtChunk;
  PBYTEArray extendedHeader;

  bool     isValidWAV;

  unsigned int origFmt;
  PWAVFileFormat * formatHandler;

  PBoolean     autoConvert;
  PWAVFileConverter * autoConverter;

  off_t lenHeader;
  off_t lenData;

  bool     header_needs_updating;

friend class PWAVFileConverter;
};

#endif // P_WAVFILE

#endif // PTLIB_PWAVFILE_H

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