ODDecodeBlockFile.h

Go to the documentation of this file.

/**********************************************************************
 
  Audacity: A Digital Audio Editor
 
  ODDecodeBlockFile.h
 
  Created by Michael Chinen (mchinen)
  Audacity(R) is copyright (c) 1999-2008 Audacity Team.
  License: GPL v2.  See License.txt.
 
******************************************************************//*******************************************************************/
 
 
 
 
 
 
#ifndef __AUDACITY_ODDecodeBlockFile__
#define __AUDACITY_ODDecodeBlockFile__
 
#include "SimpleBlockFile.h"
#include <wx/atomic.h> // member variable
 
class ODFileDecoder;
 
class ODDecodeBlockFile final : public SimpleBlockFile
{
 public:
 
   // Constructor / Destructor
 
   ODDecodeBlockFile(wxFileNameWrapper &&baseFileName, wxFileNameWrapper &&audioFileName, sampleCount aliasStart,
                     size_t aliasLen, int aliasChannel, unsigned int decodeType);
   ODDecodeBlockFile(wxFileNameWrapper &&existingFile, wxFileNameWrapper &&audioFileName, sampleCount aliasStart,
                     size_t aliasLen, int aliasChannel, unsigned int decodeType,
                   float min, float max, float rms, bool dataAvailable);
 
   virtual ~ODDecodeBlockFile();
   //checks to see if summary data has been computed and written to disk yet.  Thread safe.  Blocks if we are writing summary data.
   bool IsSummaryAvailable() const override;
 
   bool IsDataAvailable() const override;
 
   bool IsSummaryBeingComputed() override { return false; }
 
   const wxFileNameWrapper &GetExternalFileName() const override;
   void SetExternalFileName( wxFileNameWrapper &&newName ) override;
 
   //Calls that rely on summary files need to be overridden
   DiskByteCount GetSpaceUsage() const override;
   MinMaxRMS GetMinMaxRMS(
      size_t start, size_t len, bool mayThrow) const override;
   MinMaxRMS GetMinMaxRMS(bool mayThrow) const override;
   bool Read256(float *buffer, size_t start, size_t len) override;
   bool Read64K(float *buffer, size_t start, size_t len) override;
 
 
 
 
   BlockFilePtr Copy(wxFileNameWrapper &&fileName) override;
 
   void SaveXML(XMLWriter &xmlFile) override;
 
   static BlockFilePtr BuildFromXML(DirManager &dm, const wxChar **attrs);
 
   void Recover(void) override;
 
   int DoWriteBlockFile(){return WriteODDecodeBlockFile();}
 
   int WriteODDecodeBlockFile();
 
   void SetStart(sampleCount startSample){mStart = startSample;}
 
   sampleCount GetStart() const {return mStart;}
 
   //returns the number of samples from the beginning of the track that this blockfile starts at
   sampleCount GetGlobalStart() const {return mClipOffset+mStart;}
 
   //returns the number of samples from the beginning of the track that this blockfile ends at
   sampleCount GetGlobalEnd() const {return mClipOffset+mStart+GetLength();}
 
   //Below calls are overridden just so we can take wxlog calls out, which are not threadsafe.
 
   size_t ReadData(samplePtr data, sampleFormat format,
                        size_t start, size_t len, bool mayThrow) const override;
 
   bool ReadSummary(ArrayOf<char> &data) override;
 
   unsigned int GetDecodeType() /* not override */ const { return mType; }
   // void SetDecodeType(unsigned int type) /* not override */ { mType = type; }
 
   void SetClipOffset(sampleCount numSamples){mClipOffset= numSamples;}
 
   sampleCount GetClipOffset() const {return mClipOffset;}
 
   //OD TODO:set ISAlias to true while we have no data?
 
   void SetODFileDecoder(ODFileDecoder* decoder);
 
   const wxFileName &GetAudioFileName(){return mAudioFileName;}
 
   void SetFileName(wxFileNameWrapper &&name) override;
   GetFileNameResult GetFileName() const override;
 
   void LockRead() const override;
   void UnlockRead() const override;
 
   const wxFileNameWrapper &GetEncodedAudioFilename() const
   {
      return mAudioFileName;
   }
 
   void ChangeAudioFile(wxFileNameWrapper &&newAudioFile);
 
  protected:
 
//   void WriteSimpleBlockFile() override;
   void *CalcSummary(samplePtr buffer, size_t len,
                             sampleFormat format, ArrayOf<char> &cleanup) override;
   //The on demand type.
   unsigned int mType;
 
   mutable ODLock mFileNameMutex;
 
   wxFileNameWrapper mAudioFileName;
 
   wxAtomicInt mDataAvailable{ 0 };
   bool mDataBeingComputed;
 
   ODFileDecoder* mDecoder;
   ODLock mDecoderMutex;
 
   mutable ODLock mReadDataMutex;
 
   sampleCount mStart;
 
   sampleCount mClipOffset;
 
   sampleFormat mFormat;
 
   sampleCount mAliasStart;//where in the encoded audio file this block corresponds to.
   const int         mAliasChannel;//The channel number in the encoded file..
 
};
 
class ODFileDecoder /* not final */
{
public:
   ODFileDecoder(const wxString& fName);
   virtual ~ODFileDecoder();
 
   virtual bool ReadHeader()=0;
   virtual bool Init(){return ReadHeader();}
 
   virtual bool SeekingAllowed(){return true;}
 
   virtual int Decode(SampleBuffer & data, sampleFormat & format, sampleCount start, size_t len, unsigned int channel) = 0;
 
   const wxString &GetFileName(){return mFName;}
 
   bool IsInitialized();
 
protected:
   void MarkInitialized();
 
   bool     mInited;
   ODLock   mInitedLock;
 
   const wxString  mFName;
 
   unsigned int mSampleRate;
   unsigned int mNumSamples;//this may depend on the channel - so TODO: we should probably let the decoder create/modify the track info directly.
   unsigned int mNumChannels;
};
 
#endif