anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle Class Reference

Inheritance diagram for anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle:

Collaboration diagram for anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle:

Public Member Functions
	MP3ImportFileHandle (const FilePath &filename)
	~MP3ImportFileHandle ()
TranslatableString	GetFileDescription () override
ByteCount	GetFileUncompressedBytes () override
void	Import (ImportProgressListener &progressListener, WaveTrackFactory *trackFactory, TrackHolders &outTracks, Tags *tags, std::optional< LibFileFormats::AcidizerTags > &outAcidTags) override
bool	SetupOutputFormat ()
void	ReadTags (Tags *tags)
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
bool	Open ()

Static Private Member Functions
static ptrdiff_t	ReadCallback (void *handle, void *buffer, size_t size)
static off_t	SeekCallback (void *handle, off_t offset, int whence)

Private Attributes
wxFile	mFile
wxFileOffset	mFileLen { 0 }
WaveTrackFactory *	mTrackFactory { nullptr }
WaveTrack::Holder	mTrack
unsigned	mNumChannels { 0 }
mpg123_handle *	mHandle { nullptr }
bool	mFloat64Output {}
friend	MP3ImportPlugin

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 123 of file ImportMP3_MPG123.cpp.

Constructor & Destructor Documentation

MP3ImportFileHandle()

anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::MP3ImportFileHandle

(

const FilePath &

filename

)

Definition at line 186 of file ImportMP3_MPG123.cpp.

    : ImportFileHandleEx(filename)
{
   int errorCode = MPG123_OK;
   mHandle = mpg123_new(nullptr, &errorCode);
 
   if (errorCode != MPG123_OK)
   {
      wxLogError(
         "Failed to create MPG123 handle: %s",
         mpg123_plain_strerror(errorCode));
 
      mHandle = nullptr;
 
      return;
   }
 
   errorCode = mpg123_replace_reader_handle(
      mHandle, ReadCallback, SeekCallback, nullptr);
 
   if (errorCode != MPG123_OK)
   {
      wxLogError(
         "Failed to set reader on the MPG123 handle: %s",
         mpg123_plain_strerror(errorCode));
 
      mpg123_delete(mHandle);
      mHandle = nullptr;
   }
 
   // We force mpg123 to decode into floats
   mpg123_param(mHandle, MPG123_FLAGS, MPG123_GAPLESS | MPG123_FORCE_FLOAT, 0.0);
 
   if (errorCode != MPG123_OK)
   {
      wxLogError(
         "Failed to set options on the MPG123 handle",
         mpg123_plain_strerror(errorCode));
 
      mpg123_delete(mHandle);
      mHandle = nullptr;
   }
}

References mHandle, ReadCallback(), and SeekCallback().

Here is the call graph for this function:

~MP3ImportFileHandle()

anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::~MP3ImportFileHandle

(

)

Definition at line 230 of file ImportMP3_MPG123.cpp.

{
   // nullptr is a valid input for the mpg123_delete
   mpg123_delete(mHandle);
}

References mHandle.

Member Function Documentation

GetFileDescription()

TranslatableString anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::GetFileDescription ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 236 of file ImportMP3_MPG123.cpp.

{
   return DESC;
}

References DESC.

GetFileUncompressedBytes()

auto anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::GetFileUncompressedBytes ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 241 of file ImportMP3_MPG123.cpp.

{
   // We have to parse the file first using mpg123_scan,
   // we do not want to do that before the import starts.
   return 0;
}

GetStreamCount()

wxInt32 anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::GetStreamCount ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 248 of file ImportMP3_MPG123.cpp.

{
   return 1;
}

GetStreamInfo()

const TranslatableStrings & anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::GetStreamInfo ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 253 of file ImportMP3_MPG123.cpp.

{
   static TranslatableStrings empty;
   return empty;
}

Import()

void anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::Import ( ImportProgressListener &  progressListener, WaveTrackFactory *  trackFactory, TrackHolders &  outTracks, Tags *  tags, std::optional< LibFileFormats::AcidizerTags > &  outAcidTags  )

overridevirtual

Implements ImportFileHandle.

Definition at line 263 of file ImportMP3_MPG123.cpp.

{
   BeginImport();
 
   auto finalAction = finally([handle = mHandle]() { mpg123_close(handle); });
 
   outTracks.clear();
   mTrackFactory = trackFactory;
 
   long long framesCount = mpg123_framelength(mHandle);
 
   if (!SetupOutputFormat())
   {
      progressListener.OnImportResult(ImportProgressListener::ImportResult::Error);
      return;
   }
 
   off_t frameIndex { 0 };
   unsigned char* data { nullptr };
   size_t dataSize { 0 };
 
   std::vector<float> conversionBuffer;
 
   int ret = MPG123_OK;
 
   while ((ret = mpg123_decode_frame(mHandle, &frameIndex, &data, &dataSize)) ==
                 MPG123_OK)
   {
      if(framesCount > 0)
         progressListener.OnImportProgress(static_cast<double>(frameIndex) / static_cast<double>(framesCount));
 
      if(IsCancelled())
      {
         progressListener.OnImportResult(ImportProgressListener::ImportResult::Cancelled);
         return;
      }
      //VS: doesn't implement Stop behavior...
 
      constSamplePtr samples = reinterpret_cast<constSamplePtr>(data);
      const size_t samplesCount = dataSize / sizeof(float) / mNumChannels;
 
      // libmpg123 picks up the format based on some "internal" precision.
      // This case is not expected to happen
      if (mFloat64Output)
      {
         conversionBuffer.resize(samplesCount * mNumChannels);
 
         for (size_t sampleIndex = 0; sampleIndex < conversionBuffer.size();
              ++sampleIndex)
         {
            conversionBuffer[sampleIndex] = static_cast<float>(
               reinterpret_cast<const double*>(data)[sampleIndex]);
         }
 
         samples = reinterpret_cast<constSamplePtr>(conversionBuffer.data());
      }
      // Just copy the interleaved data to the channels
      unsigned chn = 0;
      ImportUtils::ForEachChannel(*mTrack, [&](auto& channel)
      {
         channel.AppendBuffer(
            samples + sizeof(float) * chn,
            floatSample, samplesCount,
            mNumChannels,
            floatSample);
         ++chn;
      });
   }
 
   if (ret != MPG123_DONE)
   {
      wxLogError(
         "Failed to decode MP3 file: %s", mpg123_plain_strerror(ret));
 
      progressListener.OnImportResult(ImportProgressListener::ImportResult::Error);
      return;
   }
 
   ImportUtils::FinalizeImport(outTracks, *mTrack);
 
   ReadTags(tags);
 
   progressListener.OnImportResult(ImportProgressListener::ImportResult::Success);
}

References ImportFileHandleEx::BeginImport(), ImportProgressListener::Cancelled, ImportProgressListener::Error, ImportUtils::FinalizeImport(), floatSample, ImportUtils::ForEachChannel(), ImportFileHandleEx::IsCancelled(), mFloat64Output, mHandle, mNumChannels, mTrack, mTrackFactory, ImportProgressListener::OnImportProgress(), ImportProgressListener::OnImportResult(), ReadTags(), SetupOutputFormat(), and ImportProgressListener::Success.

Here is the call graph for this function:

Open()

bool anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::Open ( )

private

Definition at line 453 of file ImportMP3_MPG123.cpp.

{
   if (mHandle == nullptr)
      return false;
 
   // Open the file
   if (!mFile.Open(GetFilename()))
   {
      return false;
   }
 
   // Get the length of the file
   mFileLen = mFile.Seek(0, wxFromEnd);
 
   if (mFileLen == wxInvalidOffset || mFile.Error())
   {
      mFile.Close();
      return false;
   }
 
   if (mFile.Seek(0, wxFromStart) == wxInvalidOffset || mFile.Error())
   {
      mFile.Close();
      return false;
   }
 
   // Check if file is an MP3
   auto errorCode = mpg123_open_handle(mHandle, this);
 
   if (errorCode != MPG123_OK)
      return false;
 
   // Scan the file
   errorCode = mpg123_scan(mHandle);
 
   if (errorCode != MPG123_OK)
      return false;
 
   // Read the output format
   errorCode = mpg123_decode_frame(mHandle, nullptr, nullptr, nullptr);
 
   // First decode should read the format
   if (errorCode != MPG123_NEW_FORMAT)
      return false;
 
   return true;
}

References ImportFileHandleEx::GetFilename(), mFile, mFileLen, and mHandle.

Here is the call graph for this function:

ReadCallback()

ptrdiff_t anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::ReadCallback ( void *  handle, void *  buffer, size_t  size  )

staticprivate

Definition at line 501 of file ImportMP3_MPG123.cpp.

{
   return static_cast<MP3ImportFileHandle*>(handle)->mFile.Read(buffer, size);
}

References mFile, and size.

Referenced by MP3ImportFileHandle().

Here is the caller graph for this function:

ReadTags()

void anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::ReadTags

(

Tags *

tags

)

Definition at line 378 of file ImportMP3_MPG123.cpp.

{
   mpg123_id3v1* v1;
   mpg123_id3v2* v2;
   int meta;
 
   meta = mpg123_meta_check(mHandle);
 
   if (meta & MPG123_ID3 && mpg123_id3(mHandle, &v1, &v2) == MPG123_OK)
   {
      if (v2 != nullptr && v2->title != nullptr && v2->title->fill > 0)
         tags->SetTag(TAG_TITLE, audacity::ToWXString(v2->title->p));
      else if (v1 != nullptr && v1->title[0] != '\0')
         tags->SetTag(TAG_TITLE, audacity::ToWXString(v1->title));
 
      if (v2 != nullptr && v2->artist != nullptr && v2->artist->fill > 0)
         tags->SetTag(TAG_ARTIST, audacity::ToWXString(v2->artist->p));
      else if (v1 != nullptr && v1->artist[0] != '\0')
         tags->SetTag(TAG_ARTIST, audacity::ToWXString(v1->artist));
 
      if (v2 != nullptr && v2->album != nullptr && v2->album->fill > 0)
         tags->SetTag(TAG_ALBUM, audacity::ToWXString(v2->album->p));
      else if (v1 != nullptr && v1->album[0] != '\0')
         tags->SetTag(TAG_ALBUM, audacity::ToWXString(v1->album));
 
      if (v2 != nullptr && v2->year != nullptr && v2->year->fill > 0)
         tags->SetTag(TAG_YEAR, audacity::ToWXString(v2->year->p));
      else if (v1 != nullptr && v1->year[0] != '\0')
         tags->SetTag(TAG_YEAR, audacity::ToWXString(std::string(v1->year, 4)));
 
      if (v2 != nullptr && v2->genre != nullptr && v2->genre->fill > 0)
         tags->SetTag(TAG_GENRE, GetId3v2Genre(*tags, v2->genre->p));
      else if (v1 != nullptr)
         tags->SetTag(TAG_GENRE, tags->GetGenre(v1->genre));
 
      if (v2 != nullptr && v2->comment != nullptr && v2->comment->fill > 0)
         tags->SetTag(TAG_COMMENTS, audacity::ToWXString(v2->comment->p));
      else if (v1 != nullptr && v1->comment[0] != '\0')
         tags->SetTag(TAG_COMMENTS, audacity::ToWXString(v1->comment));
 
      if (v2 != nullptr)
      {
         for (size_t i = 0; i < v2->comments; ++i)
         {
            if (v2->comment_list[i].text.fill == 0)
               continue;
 
            tags->SetTag(
               audacity::ToWXString(std::string(v2->comment_list[i].id, 4)),
               audacity::ToWXString(v2->comment_list[i].text.p));
         }
 
         for (size_t i = 0; i < v2->extras; ++i)
         {
            if (v2->extra[i].text.fill == 0)
               continue;
 
            tags->SetTag(
               audacity::ToWXString(std::string(v2->extra[i].id, 4)),
               audacity::ToWXString(v2->extra[i].text.p));
         }
 
         // libmpg123 does not parse TRCK tag, we have to do it ourselves
         for (size_t i = 0; i < v2->texts; ++i)
         {
            if (memcmp(v2->text[i].id, "TRCK", 4) == 0)
            {
               tags->SetTag(
                  TAG_TRACK, audacity::ToWXString(v2->text[i].text.p));
            }
         }
      }
   }
}

References Tags::GetGenre(), anonymous_namespace{ImportMP3_MPG123.cpp}::GetId3v2Genre(), mHandle, Tags::SetTag(), TAG_ALBUM, TAG_ARTIST, TAG_COMMENTS, TAG_GENRE, TAG_TITLE, TAG_TRACK, TAG_YEAR, and audacity::ToWXString().

Referenced by Import().

Here is the call graph for this function:

Here is the caller graph for this function:

SeekCallback()

off_t anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::SeekCallback ( void *  handle, off_t  offset, int  whence  )

staticprivate

Definition at line 525 of file ImportMP3_MPG123.cpp.

{
   return static_cast<MP3ImportFileHandle*>(handle)->mFile.Seek(
      offset, GetWXSeekMode(whence));
}

References anonymous_namespace{ImportMP3_MPG123.cpp}::GetWXSeekMode(), and mFile.

Referenced by MP3ImportFileHandle().

Here is the call graph for this function:

Here is the caller graph for this function:

SetStreamUsage()

void anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::SetStreamUsage ( wxInt32  StreamID, bool  Use  )

overridevirtual

Implements ImportFileHandle.

Definition at line 259 of file ImportMP3_MPG123.cpp.

{
}

SetupOutputFormat()

bool anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::SetupOutputFormat

(

)

Definition at line 351 of file ImportMP3_MPG123.cpp.

{
   long rate;
   int channels;
   int encoding = MPG123_ENC_FLOAT_32;
   mpg123_getformat(mHandle, &rate, &channels, &encoding);
 
   mNumChannels = channels == MPG123_MONO ? 1 : 2;
 
   if (encoding != MPG123_ENC_FLOAT_32 && encoding != MPG123_ENC_FLOAT_64)
   {
      wxLogError("MPG123 returned unexpected encoding");
 
      return false;
   }
 
   mFloat64Output = encoding == MPG123_ENC_FLOAT_64;
 
   mTrack = ImportUtils::NewWaveTrack(
      *mTrackFactory,
      mNumChannels,
      floatSample,
      rate);
 
   return true;
}

References floatSample, mFloat64Output, mHandle, mNumChannels, mTrack, mTrackFactory, and ImportUtils::NewWaveTrack().

Referenced by Import().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mFile

wxFile anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::mFile

private

Definition at line 151 of file ImportMP3_MPG123.cpp.

Referenced by Open(), ReadCallback(), and SeekCallback().

mFileLen

wxFileOffset anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::mFileLen { 0 }

private

Definition at line 152 of file ImportMP3_MPG123.cpp.

Referenced by Open().

mFloat64Output

bool anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::mFloat64Output {}

private

Definition at line 160 of file ImportMP3_MPG123.cpp.

Referenced by Import(), and SetupOutputFormat().

mHandle

mpg123_handle* anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::mHandle { nullptr }

private

Definition at line 158 of file ImportMP3_MPG123.cpp.

Referenced by Import(), MP3ImportFileHandle(), Open(), ReadTags(), SetupOutputFormat(), and ~MP3ImportFileHandle().

mNumChannels

unsigned anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::mNumChannels { 0 }

private

Definition at line 156 of file ImportMP3_MPG123.cpp.

Referenced by Import(), and SetupOutputFormat().

MP3ImportPlugin

friend anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::MP3ImportPlugin

private

Definition at line 162 of file ImportMP3_MPG123.cpp.

mTrack

WaveTrack::Holder anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::mTrack

private

Definition at line 155 of file ImportMP3_MPG123.cpp.

Referenced by Import(), and SetupOutputFormat().

mTrackFactory

WaveTrackFactory* anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::mTrackFactory { nullptr }

private

Definition at line 154 of file ImportMP3_MPG123.cpp.

Referenced by Import(), and SetupOutputFormat().

---

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

• ImportMP3_MPG123.cpp