OggImportFileHandle Class Reference

Inheritance diagram for OggImportFileHandle:

Collaboration diagram for OggImportFileHandle:

Public Member Functions
	OggImportFileHandle (const FilePath &filename, std::unique_ptr< wxFFile > &&file, std::unique_ptr< OggVorbis_File > &&vorbisFile)
	~OggImportFileHandle ()
TranslatableString	GetFileDescription () override
ByteCount	GetFileUncompressedBytes () override
void	Import (ImportProgressListener &progressListener, WaveTrackFactory *trackFactory, TrackHolders &outTracks, Tags *tags, std::optional< LibFileFormats::AcidizerTags > &outAcidTags) override
wxInt32	GetStreamCount () override
const TranslatableStrings &	GetStreamInfo () override
void	SetStreamUsage (wxInt32 StreamID, bool Use) override
Public Member Functions inherited from ImportFileHandleEx
	ImportFileHandleEx (const FilePath &filename)
FilePath	GetFilename () const override
void	Cancel () override
void	Stop () override
Public Member Functions inherited from ImportFileHandle
virtual	~ImportFileHandle ()
virtual FilePath	GetFilename () const =0
virtual TranslatableString	GetErrorMessage () const
virtual TranslatableString	GetFileDescription ()=0
virtual ByteCount	GetFileUncompressedBytes ()=0
virtual wxInt32	GetStreamCount ()=0
virtual const TranslatableStrings &	GetStreamInfo ()=0
virtual void	SetStreamUsage (wxInt32 StreamID, bool Use)=0
virtual void	Import (ImportProgressListener &progressListener, WaveTrackFactory *trackFactory, TrackHolders &outTracks, Tags *tags, std::optional< LibFileFormats::AcidizerTags > &acidTags)=0
virtual void	Cancel ()=0
virtual void	Stop ()=0

Private Attributes
std::unique_ptr< wxFFile >	mFile
std::unique_ptr< OggVorbis_File >	mVorbisFile
ArrayOf< int >	mStreamUsage
TranslatableStrings	mStreamInfo
std::vector< TrackListHolder >	mStreams

Additional Inherited Members
Public Types inherited from ImportFileHandle
using	ByteCount = unsigned long long
Protected Member Functions inherited from ImportFileHandleEx
void	BeginImport ()
bool	IsCancelled () const noexcept
bool	IsStopped () const noexcept

Detailed Description

Definition at line 73 of file ImportOGG.cpp.

Constructor & Destructor Documentation

OggImportFileHandle()

OggImportFileHandle::OggImportFileHandle ( const FilePath &  filename, std::unique_ptr< wxFFile > &&  file, std::unique_ptr< OggVorbis_File > &&  vorbisFile  )

inline

Definition at line 76 of file ImportOGG.cpp.

   :  ImportFileHandleEx(filename),
      mFile(std::move(file)),
      mVorbisFile(std::move(vorbisFile))
      , mStreamUsage{ static_cast<size_t>(mVorbisFile->links) }
   {
      for (int i = 0; i < mVorbisFile->links; i++)
      {
         auto strinfo = XO("Index[%02x] Version[%d], Channels[%d], Rate[%ld]")
            .Format(
               (unsigned int) i,
               mVorbisFile->vi[i].version,
               mVorbisFile->vi[i].channels,
               mVorbisFile->vi[i].rate);
         mStreamInfo.push_back(strinfo);
         mStreamUsage[i] = 0;
      }
 
   }

References mStreamInfo, mStreamUsage, mVorbisFile, and XO().

Here is the call graph for this function:

~OggImportFileHandle()

OggImportFileHandle::~OggImportFileHandle

(

)

Definition at line 366 of file ImportOGG.cpp.

{
   ov_clear(mVorbisFile.get());
   mFile->Detach();    // so that it doesn't try to close the file (ov_clear()
                       // did that already)
}

References mFile, and mVorbisFile.

Member Function Documentation

GetFileDescription()

TranslatableString OggImportFileHandle::GetFileDescription ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 194 of file ImportOGG.cpp.

{
   return DESC;
}

References DESC.

GetFileUncompressedBytes()

auto OggImportFileHandle::GetFileUncompressedBytes ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 199 of file ImportOGG.cpp.

{
   // TODO:
   return 0;
}

GetStreamCount()

wxInt32 OggImportFileHandle::GetStreamCount ( )

inlineoverridevirtual

Implements ImportFileHandle.

Definition at line 106 of file ImportOGG.cpp.

   {
      if (mVorbisFile)
         return mVorbisFile->links;
      else
         return 0;
   }

References mVorbisFile.

GetStreamInfo()

const TranslatableStrings & OggImportFileHandle::GetStreamInfo ( )

inlineoverridevirtual

Implements ImportFileHandle.

Definition at line 114 of file ImportOGG.cpp.

   {
      return mStreamInfo;
   }

References mStreamInfo.

Import()

void OggImportFileHandle::Import ( ImportProgressListener &  progressListener, WaveTrackFactory *  trackFactory, TrackHolders &  outTracks, Tags *  tags, std::optional< LibFileFormats::AcidizerTags > &  outAcidTags  )

overridevirtual

Implements ImportFileHandle.

Definition at line 205 of file ImportOGG.cpp.

{
   BeginImport();
 
   outTracks.clear();
 
   wxASSERT(mFile->IsOpened());
 
   //Number of streams used may be less than mVorbisFile->links,
   //but this way bitstream matches array index.
   mStreams.reserve(mVorbisFile->links);
 
   for(int i = 0; i < mVorbisFile->links; ++i)
   {
      //Stream is not used
      if (mStreamUsage[i] == 0)
      {
         //This is just a padding to keep bitstream number and
         //array indices matched.
         mStreams.push_back({});
         continue;
      }
 
      vorbis_info *vi = ov_info(mVorbisFile.get(), i);
 
      // The format agrees with what is always passed to Append() below
      auto tracks = trackFactory->CreateMany(vi->channels, int16Sample, vi->rate);
 
      mStreams.push_back(tracks);
   }
 
   /* The number of bytes to get from the codec in each run */
#define CODEC_TRANSFER_SIZE 4096u
 
   /* The number of samples to read between calls to the callback.
    * Balance between responsiveness of the GUI and throughput of import. */
#define SAMPLES_PER_CALLBACK 100000
 
   long bytesRead = 0;
   {
      ArrayOf<short> mainBuffer{ CODEC_TRANSFER_SIZE };
 
      /* determine endianness (clever trick courtesy of Nicholas Devillard,
       * (http://www.eso.org/~ndevilla/endian/) */
      int testvar = 1, endian;
      if (*(char *)&testvar)
         endian = 0;  // little endian
      else
         endian = 1;  // big endian
 
      /* number of samples currently in each channel's buffer */
      long samplesRead = 0;
      int bitstream = 0;
      int samplesSinceLastCallback = 0;
 
      // You would think that the stream would already be seeked to 0, and
      // indeed it is if the file is legit.  But I had several ogg files on
      // my hard drive that have malformed headers, and this added call
      // causes them to be read correctly.  Otherwise they have lots of
      // zeros inserted at the beginning
      ov_pcm_seek(mVorbisFile.get(), 0);
 
      do {
         /* get data from the decoder */
         bytesRead = ov_read(mVorbisFile.get(), (char *)mainBuffer.get(),
            CODEC_TRANSFER_SIZE,
            endian,
            2,    // word length (2 for 16 bit samples)
            1,    // signed
            &bitstream);
 
         if (bytesRead == OV_HOLE) {
            wxFileName ff(GetFilename());
            wxLogError(wxT("Ogg Vorbis importer: file %s is malformed, ov_read() reported a hole"),
               ff.GetFullName());
            /* http://lists.xiph.org/pipermail/vorbis-dev/2001-February/003223.html
             * is the justification for doing this - best effort for malformed file,
             * hence the message.
             */
            continue;
         }
         else if (bytesRead < 0) {
            /* Malformed Ogg Vorbis file. */
            /* TODO: Return some sort of meaningful error. */
            wxLogError(wxT("Ogg Vorbis importer: ov_read() returned error %i"),
               bytesRead);
            break;
         }
 
         samplesRead = bytesRead / mVorbisFile->vi[bitstream].channels / sizeof(short);
 
         if (mStreamUsage[bitstream] != 0)
         {
            /* give the data to the wavetracks */
            unsigned chn = 0;
            ImportUtils::ForEachChannel(**std::next(mStreams.begin(), bitstream), [&](auto& channel)
            {
               channel.AppendBuffer(
                  (char *)(mainBuffer.get() + chn),
                  int16Sample,
                  samplesRead,
                  mVorbisFile->vi[bitstream].channels,
                  int16Sample
               );
               ++chn;
            });
         }
 
         samplesSinceLastCallback += samplesRead;
         if (samplesSinceLastCallback > SAMPLES_PER_CALLBACK) {
            const auto timeTotal = ov_time_total(mVorbisFile.get(), bitstream);
            if(timeTotal > 0)
               progressListener.OnImportProgress(ov_time_tell(mVorbisFile.get()) / timeTotal);
            samplesSinceLastCallback -= SAMPLES_PER_CALLBACK;
         }
      } while (!IsCancelled() && !IsStopped() && bytesRead != 0);
   }
 
   if (bytesRead < 0)
   {
      progressListener.OnImportResult(ImportProgressListener::ImportResult::Error);
      return;
   }
 
   if(IsCancelled())
   {
      progressListener.OnImportResult(ImportProgressListener::ImportResult::Cancelled);
      return;
   }
 
   for (auto& stream : mStreams)
   {
      ImportUtils::FinalizeImport(outTracks, std::move(*stream));
   }
   mStreams.clear();
 
   //\todo { Extract comments from each stream? }
   if (mVorbisFile->vc[0].comments > 0) {
      tags->Clear();
      for (int c = 0; c < mVorbisFile->vc[0].comments; c++) {
         wxString comment = UTF8CTOWX(mVorbisFile->vc[0].user_comments[c]);
         wxString name = comment.BeforeFirst(wxT('='));
         wxString value = comment.AfterFirst(wxT('='));
         if (name.Upper() == wxT("DATE") && !tags->HasTag(TAG_YEAR)) {
            long val;
            if (value.length() == 4 && value.ToLong(&val)) {
               name = TAG_YEAR;
            }
         }
         tags->SetTag(name, value);
      }
   }
 
   progressListener.OnImportResult(IsStopped()
                                   ? ImportProgressListener::ImportResult::Stopped
                                   : ImportProgressListener::ImportResult::Success);
}

References ImportFileHandleEx::BeginImport(), ImportProgressListener::Cancelled, Tags::Clear(), CODEC_TRANSFER_SIZE, WaveTrackFactory::CreateMany(), ImportProgressListener::Error, ImportUtils::FinalizeImport(), ImportUtils::ForEachChannel(), ImportFileHandleEx::GetFilename(), Tags::HasTag(), int16Sample, ImportFileHandleEx::IsCancelled(), ImportFileHandleEx::IsStopped(), mFile, mStreams, mStreamUsage, mVorbisFile, name, ImportProgressListener::OnImportProgress(), ImportProgressListener::OnImportResult(), SAMPLES_PER_CALLBACK, Tags::SetTag(), ImportProgressListener::Stopped, ImportProgressListener::Success, TAG_YEAR, tracks, UTF8CTOWX, and wxT().

Here is the call graph for this function:

SetStreamUsage()

void OggImportFileHandle::SetStreamUsage ( wxInt32  StreamID, bool  Use  )

inlineoverridevirtual

Implements ImportFileHandle.

Definition at line 119 of file ImportOGG.cpp.

   {
      if (mVorbisFile)
      {
         if (StreamID < mVorbisFile->links)
            mStreamUsage[StreamID] = (Use ? 1 : 0);
      }
   }

References mStreamUsage, and mVorbisFile.

Member Data Documentation

mFile

std::unique_ptr<wxFFile> OggImportFileHandle::mFile

private

Definition at line 129 of file ImportOGG.cpp.

Referenced by Import(), and ~OggImportFileHandle().

mStreamInfo

TranslatableStrings OggImportFileHandle::mStreamInfo

private

Definition at line 133 of file ImportOGG.cpp.

Referenced by GetStreamInfo(), and OggImportFileHandle().

mStreams

std::vector<TrackListHolder> OggImportFileHandle::mStreams

private

Definition at line 134 of file ImportOGG.cpp.

Referenced by Import().

mStreamUsage

ArrayOf<int> OggImportFileHandle::mStreamUsage

private

Definition at line 132 of file ImportOGG.cpp.

Referenced by Import(), OggImportFileHandle(), and SetStreamUsage().

mVorbisFile

std::unique_ptr<OggVorbis_File> OggImportFileHandle::mVorbisFile

private

Definition at line 130 of file ImportOGG.cpp.

Referenced by GetStreamCount(), Import(), OggImportFileHandle(), SetStreamUsage(), and ~OggImportFileHandle().

---

The documentation for this class was generated from the following file:

• ImportOGG.cpp