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
ProgressResult	Import (WaveTrackFactory *trackFactory, TrackHolders &outTracks, Tags *tags) override
wxInt32	GetStreamCount () override
const TranslatableStrings &	GetStreamInfo () override
void	SetStreamUsage (wxInt32 StreamID, bool Use) override
Public Member Functions inherited from ImportFileHandle
	ImportFileHandle (const FilePath &filename)
virtual	~ImportFileHandle ()
void	CreateProgress ()
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 ProgressResult	Import (WaveTrackFactory *trackFactory, TrackHolders &outTracks, Tags *tags)=0

Private Attributes
std::unique_ptr< wxFFile >	mFile
std::unique_ptr< OggVorbis_File >	mVorbisFile
ArrayOf< int >	mStreamUsage
TranslatableStrings	mStreamInfo
std::list< NewChannelGroup >	mChannels

Additional Inherited Members
Public Types inherited from ImportFileHandle
using	ProgressResult = BasicUI::ProgressResult
using	ByteCount = unsigned long long
Static Public Member Functions inherited from ImportFileHandle
static sampleFormat	ChooseFormat (sampleFormat effectiveFormat)
	Choose appropriate format, which will not be narrower than the specified one. More...
Protected Member Functions inherited from ImportFileHandle
std::shared_ptr< WaveTrack >	NewWaveTrack (WaveTrackFactory &trackFactory, sampleFormat effectiveFormat, double rate)
	Build a wave track with appropriate format, which will not be narrower than the specified one. More...
Protected Attributes inherited from ImportFileHandle
FilePath	mFilename
std::unique_ptr< ProgressDialog >	mProgress

Detailed Description

Definition at line 95 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 98 of file ImportOGG.cpp.

   :  ImportFileHandle(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 380 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 214 of file ImportOGG.cpp.

{
   return DESC;
}

References DESC.

GetFileUncompressedBytes()

auto OggImportFileHandle::GetFileUncompressedBytes ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 219 of file ImportOGG.cpp.

{
   // TODO:
   return 0;
}

GetStreamCount()

wxInt32 OggImportFileHandle::GetStreamCount ( )

inlineoverridevirtual

Implements ImportFileHandle.

Definition at line 126 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 134 of file ImportOGG.cpp.

   {
      return mStreamInfo;
   }

References mStreamInfo.

Import()

ProgressResult OggImportFileHandle::Import ( WaveTrackFactory *  trackFactory, TrackHolders &  outTracks, Tags *  tags  )

overridevirtual

Implements ImportFileHandle.

Definition at line 225 of file ImportOGG.cpp.

{
   outTracks.clear();
 
   wxASSERT(mFile->IsOpened());
 
   CreateProgress();
 
   //Number of streams used may be less than mVorbisFile->links,
   //but this way bitstream matches array index.
   mChannels.resize(mVorbisFile->links);
 
   int i = -1;
   for (auto &link : mChannels)
   {
      ++i;
 
      //Stream is not used
      if (mStreamUsage[i] == 0)
      {
         //This is just a padding to keep bitstream number and
         //array indices matched.
         continue;
      }
 
      vorbis_info *vi = ov_info(mVorbisFile.get(), i);
 
      link.resize(vi->channels);
 
      for (auto &channel : link)
         // The format agrees with what is always passed to Append() below
         channel = NewWaveTrack(*trackFactory, int16Sample, vi->rate);
   }
 
   /* 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
 
   auto updateResult = ProgressResult::Success;
   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(mFilename);
            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);
 
         /* give the data to the wavetracks */
         auto iter = mChannels.begin();
         std::advance(iter, bitstream);
         if (mStreamUsage[bitstream] != 0)
         {
            auto iter2 = iter->begin();
            for (int c = 0; c < mVorbisFile->vi[bitstream].channels; ++iter2, ++c)
               iter2->get()->Append((char *)(mainBuffer.get() + c),
               int16Sample,
               samplesRead,
               mVorbisFile->vi[bitstream].channels,
               int16Sample);
         }
 
         samplesSinceLastCallback += samplesRead;
         if (samplesSinceLastCallback > SAMPLES_PER_CALLBACK) {
            updateResult = mProgress->Update(ov_time_tell(mVorbisFile.get()),
               ov_time_total(mVorbisFile.get(), bitstream));
            samplesSinceLastCallback -= SAMPLES_PER_CALLBACK;
         }
      } while (updateResult == ProgressResult::Success && bytesRead != 0);
   }
 
   auto res = updateResult;
   if (bytesRead < 0)
     res = ProgressResult::Failed;
 
   if (res == ProgressResult::Failed || res == ProgressResult::Cancelled) {
      return res;
   }
 
   for (auto &link : mChannels)
   {
      for (auto &channel : link)
         channel->Flush();
      outTracks.push_back(std::move(link));
   }
 
   //\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);
      }
   }
 
   return res;
}

References RefreshCode::Cancelled, Tags::Clear(), CODEC_TRANSFER_SIZE, ImportFileHandle::CreateProgress(), Tags::HasTag(), int16Sample, mChannels, mFile, ImportFileHandle::mFilename, ImportFileHandle::mProgress, mStreamUsage, mVorbisFile, name, ImportFileHandle::NewWaveTrack(), SAMPLES_PER_CALLBACK, Tags::SetTag(), BasicUI::Success, TAG_YEAR, 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 139 of file ImportOGG.cpp.

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

References mStreamUsage, and mVorbisFile.

Member Data Documentation

mChannels

std::list<NewChannelGroup> OggImportFileHandle::mChannels

private

Definition at line 154 of file ImportOGG.cpp.

Referenced by Import().

mFile

std::unique_ptr<wxFFile> OggImportFileHandle::mFile

private

Definition at line 149 of file ImportOGG.cpp.

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

mStreamInfo

TranslatableStrings OggImportFileHandle::mStreamInfo

private

Definition at line 153 of file ImportOGG.cpp.

Referenced by GetStreamInfo(), and OggImportFileHandle().

mStreamUsage

ArrayOf<int> OggImportFileHandle::mStreamUsage

private

Definition at line 152 of file ImportOGG.cpp.

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

mVorbisFile

std::unique_ptr<OggVorbis_File> OggImportFileHandle::mVorbisFile

private

Definition at line 150 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