OpusImportFileHandle Class Reference

Inheritance diagram for OpusImportFileHandle:

Collaboration diagram for OpusImportFileHandle:

Public Member Functions
	OpusImportFileHandle (const FilePath &filename)
	~OpusImportFileHandle ()
bool	IsOpen () const
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 Member Functions
void	LogOpusError (const char *method, int error)
void	NotifyImportFailed (ImportProgressListener &progressListener, int error)
void	NotifyImportFailed (ImportProgressListener &progressListener, const TranslatableString &error)

Static Private Member Functions
static int	OpusReadCallback (void *stream, unsigned char *ptr, int nbytes)
static int	OpusSeekCallback (void *stream, opus_int64 offset, int whence)
static opus_int64	OpusTellCallback (void *stream)
static int	OpusCloseCallback (void *stream)
static TranslatableString	GetOpusErrorString (int error)

Private Attributes
wxFile	mFile
OpusFileCallbacks	mCallbacks
OggOpusFile *	mOpusFile {}
int	mNumChannels {}
int64_t	mNumSamples {}
const double	mSampleRate { 48000.0 }
const sampleFormat	mFormat { floatSample }

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 49 of file ImportOpus.cpp.

Constructor & Destructor Documentation

OpusImportFileHandle()

OpusImportFileHandle::OpusImportFileHandle ( const FilePath &  filename )

explicit

Definition at line 137 of file ImportOpus.cpp.

    : ImportFileHandleEx { filename }
{
   // Try to open the file for reading
   if (!mFile.Open(filename, wxFile::read))
      return;
 
   OpusFileCallbacks callbacks = {
      OpusReadCallback,
      OpusSeekCallback,
      OpusTellCallback,
      OpusCloseCallback
   };
 
   int error = 0;
   mOpusFile = op_open_callbacks(this, &callbacks, nullptr, 0, &error);
 
   if (mOpusFile == nullptr)
   {
      LogOpusError("Error while opening Opus file", error);
      return;
   }
 
   mNumChannels = op_channel_count(mOpusFile, -1);
   mNumSamples = op_pcm_total(mOpusFile, -1);
}

References LogOpusError(), mFile, mNumChannels, mNumSamples, mOpusFile, OpusCloseCallback(), OpusReadCallback(), OpusSeekCallback(), and OpusTellCallback().

Here is the call graph for this function:

~OpusImportFileHandle()

OpusImportFileHandle::~OpusImportFileHandle

(

)

Definition at line 417 of file ImportOpus.cpp.

{
   if (mOpusFile != nullptr)
      op_free(mOpusFile);
}

References mOpusFile.

Member Function Documentation

GetFileDescription()

TranslatableString OpusImportFileHandle::GetFileDescription ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 164 of file ImportOpus.cpp.

{
   return DESC;
}

References DESC.

GetFileUncompressedBytes()

auto OpusImportFileHandle::GetFileUncompressedBytes ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 169 of file ImportOpus.cpp.

{
   return 0;
}

GetOpusErrorString()

TranslatableString OpusImportFileHandle::GetOpusErrorString ( int  error )

staticprivate

Definition at line 347 of file ImportOpus.cpp.

{
   switch (error)
   {
   case OP_EREAD:
      return XO("IO error reading from file");
   case OP_EFAULT:
      return XO("internal error");
   case OP_EIMPL:
      return XO("not implemented");
   case OP_EINVAL:
      return XO("invalid argument");
   case OP_ENOTFORMAT:
      return XO("not an Opus file");
   case OP_EBADHEADER:
      return XO("invalid header");
   case OP_EVERSION:
      return XO("unsupported version");
   case OP_EBADPACKET:
      return XO("invalid packet");
   case OP_EBADLINK:
      return XO("invalid stream structure");
   case OP_ENOSEEK:
      return XO("stream is not seekable");
   case OP_EBADTIMESTAMP:
      return XO("invalid timestamp");
   default:
      return {};
   }
}

References XO().

Referenced by LogOpusError(), and NotifyImportFailed().

Here is the call graph for this function:

Here is the caller graph for this function:

GetStreamCount()

wxInt32 OpusImportFileHandle::GetStreamCount ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 287 of file ImportOpus.cpp.

{
   return 1;
}

GetStreamInfo()

const TranslatableStrings & OpusImportFileHandle::GetStreamInfo ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 292 of file ImportOpus.cpp.

{
   static TranslatableStrings empty;
   return empty;
}

Import()

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

overridevirtual

Implements ImportFileHandle.

Definition at line 174 of file ImportOpus.cpp.

{
   BeginImport();
 
   outTracks.clear();
 
   auto track = ImportUtils::NewWaveTrack(
      *trackFactory,
      mNumChannels,
      mFormat,
      mSampleRate);
 
   /* The number of samples to read in each loop */
   const size_t SAMPLES_TO_READ = track->GetMaxBlockSize();
   uint64_t totalSamplesRead = 0;
 
   const auto bufferSize = mNumChannels * SAMPLES_TO_READ;
 
   ArrayOf<float> floatBuffer { bufferSize };
 
   uint64_t samplesRead = 0;
 
   do
   {
      int linkIndex { -1 };
      auto samplesPerChannelRead = op_read_float(mOpusFile, floatBuffer.get(), SAMPLES_TO_READ, &linkIndex);
 
      if (samplesPerChannelRead < 0 && samplesPerChannelRead != OP_HOLE)
      {
         NotifyImportFailed(progressListener, samplesPerChannelRead);
         return;
      }
 
      auto linkChannels = op_head(mOpusFile, linkIndex)->channel_count;
 
      if (linkChannels != mNumChannels)
      {
         NotifyImportFailed(progressListener, XO("File has changed the number of channels in the middle."));
         return;
      }
 
      unsigned chn = 0;
      ImportUtils::ForEachChannel(*track, [&](auto& channel)
      {
         channel.AppendBuffer(
            reinterpret_cast<constSamplePtr>(floatBuffer.get() +
            chn), mFormat, samplesRead, mNumChannels, mFormat
         );
         ++chn;
      });
 
      samplesRead = samplesPerChannelRead;
      totalSamplesRead += samplesRead;
 
      progressListener.OnImportProgress(double(totalSamplesRead) / mNumSamples);
   } while (!IsCancelled() && !IsStopped() && samplesRead != 0);
 
   if (IsCancelled())
   {
      progressListener.OnImportResult(
         ImportProgressListener::ImportResult::Cancelled);
      return;
   }
 
   if (totalSamplesRead < mNumSamples && !IsStopped())
   {
      progressListener.OnImportResult(ImportProgressListener::ImportResult::Error);
      return;
   }
 
   ImportUtils::FinalizeImport(outTracks, *track);
 
   auto opusTags = op_tags(mOpusFile, -1);
 
   if (opusTags != nullptr)
   {
         for (int i = 0; i < opusTags->comments; ++i)
         {
            const auto comment = opusTags->user_comments[i];
            const auto commentLength = opusTags->comment_lengths[i];
 
            std::string_view tag { comment,
                                   std::string_view::size_type(commentLength) };
 
            const auto separator = tag.find('=');
 
            if (separator != std::string_view::npos)
            {
               auto name = audacity::ToWXString(tag.substr(0, separator));
               const auto value = audacity::ToWXString(tag.substr(separator + 1));
 
               // See: ImportOGG.cpp tags parsing
               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, ImportProgressListener::Error, ImportUtils::FinalizeImport(), ImportUtils::ForEachChannel(), Tags::HasTag(), ImportFileHandleEx::IsCancelled(), ImportFileHandleEx::IsStopped(), mFormat, mNumChannels, mNumSamples, mOpusFile, mSampleRate, name, ImportUtils::NewWaveTrack(), NotifyImportFailed(), Tuple::detail::npos(), ImportProgressListener::OnImportProgress(), ImportProgressListener::OnImportResult(), Tags::SetTag(), ImportProgressListener::Stopped, ImportProgressListener::Success, TAG_YEAR, audacity::ToWXString(), wxT(), and XO().

Here is the call graph for this function:

IsOpen()

bool OpusImportFileHandle::IsOpen

(

)

const

Definition at line 412 of file ImportOpus.cpp.

{
   return mOpusFile != nullptr;
}

References mOpusFile.

LogOpusError()

void OpusImportFileHandle::LogOpusError ( const char *  method, int  error  )

private

Definition at line 378 of file ImportOpus.cpp.

{
   if (error == 0)
      return;
 
   if (error == OP_ENOTFORMAT)
      wxLogDebug("%s: Not Opus format", GetOpusErrorString(error).Translation());
   else
      wxLogError("%s: %s", method, GetOpusErrorString(error).Translation());
}

References GetOpusErrorString().

Referenced by OpusImportFileHandle().

Here is the call graph for this function:

Here is the caller graph for this function:

NotifyImportFailed() [1/2]

void OpusImportFileHandle::NotifyImportFailed ( ImportProgressListener &  progressListener, const TranslatableString &  error  )

private

Definition at line 395 of file ImportOpus.cpp.

{
   ImportUtils::ShowMessageBox(
      XO("Failed to decode Opus file: %s").Format(error));
 
   if (IsCancelled())
      progressListener.OnImportResult(
         ImportProgressListener::ImportResult::Cancelled);
   else if (!IsStopped())
      progressListener.OnImportResult(
         ImportProgressListener::ImportResult::Error);
   else
      progressListener.OnImportResult(
         ImportProgressListener::ImportResult::Stopped);
}

References ImportProgressListener::Cancelled, ImportProgressListener::Error, ImportFileHandleEx::IsCancelled(), ImportFileHandleEx::IsStopped(), ImportProgressListener::OnImportResult(), ImportUtils::ShowMessageBox(), ImportProgressListener::Stopped, and XO().

Here is the call graph for this function:

NotifyImportFailed() [2/2]

void OpusImportFileHandle::NotifyImportFailed ( ImportProgressListener &  progressListener, int  error  )

private

Definition at line 389 of file ImportOpus.cpp.

{
   NotifyImportFailed(progressListener, GetOpusErrorString(error));
}

References GetOpusErrorString(), and NotifyImportFailed().

Referenced by Import(), and NotifyImportFailed().

Here is the call graph for this function:

Here is the caller graph for this function:

OpusCloseCallback()

int OpusImportFileHandle::OpusCloseCallback ( void *  stream )

staticprivate

Definition at line 337 of file ImportOpus.cpp.

{
   auto stream = static_cast<OpusImportFileHandle*>(pstream);
 
   if (stream->mFile.IsOpened())
      return stream->mFile.Close() ? 0 : EOF;
 
   return 0;
}

References mFile.

Referenced by OpusImportFileHandle().

Here is the caller graph for this function:

OpusReadCallback()

int OpusImportFileHandle::OpusReadCallback ( void *  stream, unsigned char *  ptr, int  nbytes  )

staticprivate

Definition at line 302 of file ImportOpus.cpp.

{
   auto stream = static_cast<OpusImportFileHandle*>(pstream);
 
   if (!stream->mFile.IsOpened())
      return EOF;
 
   // OpusFile never reads more than 2^31 bytes at a time,
   // so we can safely cast ssize_t to int.
   return int(stream->mFile.Read(ptr, nbytes));
}

Referenced by OpusImportFileHandle().

Here is the caller graph for this function:

OpusSeekCallback()

int OpusImportFileHandle::OpusSeekCallback ( void *  stream, opus_int64  offset, int  whence  )

staticprivate

Definition at line 315 of file ImportOpus.cpp.

{
   auto stream = static_cast<OpusImportFileHandle*>(pstream);
 
   if (!stream->mFile.IsOpened())
      return -1;
 
   wxSeekMode wxWhence = whence == SEEK_SET ? wxFromStart :
                         whence == SEEK_CUR ? wxFromCurrent :
                         whence == SEEK_END ? wxFromEnd : wxFromStart;
 
   return stream->mFile.Seek(offset, wxWhence) != wxInvalidOffset ? 0 : -1;
}

References mFile.

Referenced by OpusImportFileHandle().

Here is the caller graph for this function:

OpusTellCallback()

opus_int64 OpusImportFileHandle::OpusTellCallback ( void *  stream )

staticprivate

Definition at line 330 of file ImportOpus.cpp.

{
   auto stream = static_cast<OpusImportFileHandle*>(pstream);
 
   return static_cast<opus_int64>(stream->mFile.Tell());
}

Referenced by OpusImportFileHandle().

Here is the caller graph for this function:

SetStreamUsage()

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

overridevirtual

Implements ImportFileHandle.

Definition at line 298 of file ImportOpus.cpp.

{
}

Member Data Documentation

mCallbacks

OpusFileCallbacks OpusImportFileHandle::mCallbacks

private

Definition at line 81 of file ImportOpus.cpp.

mFile

wxFile OpusImportFileHandle::mFile

private

Definition at line 79 of file ImportOpus.cpp.

Referenced by OpusCloseCallback(), OpusImportFileHandle(), and OpusSeekCallback().

mFormat

const sampleFormat OpusImportFileHandle::mFormat { floatSample }

private

Definition at line 93 of file ImportOpus.cpp.

Referenced by Import().

mNumChannels

int OpusImportFileHandle::mNumChannels {}

private

Definition at line 83 of file ImportOpus.cpp.

Referenced by Import(), and OpusImportFileHandle().

mNumSamples

int64_t OpusImportFileHandle::mNumSamples {}

private

Definition at line 84 of file ImportOpus.cpp.

Referenced by Import(), and OpusImportFileHandle().

mOpusFile

OggOpusFile* OpusImportFileHandle::mOpusFile {}

private

Definition at line 82 of file ImportOpus.cpp.

Referenced by Import(), IsOpen(), OpusImportFileHandle(), and ~OpusImportFileHandle().

mSampleRate

const double OpusImportFileHandle::mSampleRate { 48000.0 }

private

Definition at line 89 of file ImportOpus.cpp.

Referenced by Import().

---

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

• ImportOpus.cpp