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
ProgressResult	Import (WaveTrackFactory *trackFactory, TrackHolders &outTracks, Tags *tags) 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 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 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 }
NewChannelGroup	mChannels
unsigned	mNumChannels { 0 }
ProgressResult	mUpdateResult { ProgressResult::Success }
mpg123_handle *	mHandle { nullptr }
bool	mFloat64Output {}
friend	MP3ImportPlugin

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

Constructor & Destructor Documentation

MP3ImportFileHandle()

MP3ImportFileHandle::MP3ImportFileHandle

(

const FilePath &

filename

)

Definition at line 188 of file ImportMP3_MPG123.cpp.

    : ImportFileHandle(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_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()

MP3ImportFileHandle::~MP3ImportFileHandle

(

)

Definition at line 232 of file ImportMP3_MPG123.cpp.

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

References mHandle.

Member Function Documentation

GetFileDescription()

TranslatableString MP3ImportFileHandle::GetFileDescription ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 238 of file ImportMP3_MPG123.cpp.

{
   return DESC;
}

References DESC.

GetFileUncompressedBytes()

auto MP3ImportFileHandle::GetFileUncompressedBytes ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 243 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 MP3ImportFileHandle::GetStreamCount ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 250 of file ImportMP3_MPG123.cpp.

{
   return 1;
}

GetStreamInfo()

const TranslatableStrings & MP3ImportFileHandle::GetStreamInfo ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 255 of file ImportMP3_MPG123.cpp.

{
   static TranslatableStrings empty;
   return empty;
}

Import()

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

overridevirtual

Implements ImportFileHandle.

Definition at line 265 of file ImportMP3_MPG123.cpp.

{
   auto finalAction = finally([handle = mHandle]() { mpg123_close(handle); });
 
   outTracks.clear();
   mTrackFactory = trackFactory;
 
   CreateProgress();
 
   long long framesCount = mpg123_framelength(mHandle);
 
   mUpdateResult = mProgress->Update(0ll, framesCount);
 
   if (mUpdateResult == ProgressResult::Cancelled)
      return ProgressResult::Cancelled;
 
   if (!SetupOutputFormat())
      return ProgressResult::Failed;
 
   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)
   {
      mUpdateResult = mProgress->Update(
         static_cast<long long>(frameIndex), framesCount);
 
      if (mUpdateResult == ProgressResult::Cancelled)
         return ProgressResult::Cancelled;
 
      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
      for (unsigned channel = 0; channel < mNumChannels; ++channel)
      {
         mChannels[channel]->Append(
            samples + sizeof(float) * channel, floatSample, samplesCount,
            mNumChannels, floatSample);
      }
   }
 
   if (ret != MPG123_DONE)
   {
      wxLogError(
         "Failed to decode MP3 file: %s", mpg123_plain_strerror(ret));
 
      return ProgressResult::Failed;
   }
 
   // Flush and trim the channels
   for (const auto &channel : mChannels)
      channel->Flush();
 
   // Copy the WaveTrack pointers into the Track pointer list that
   // we are expected to fill
   outTracks.push_back(std::move(mChannels));
 
   ReadTags(tags);
 
   return mUpdateResult;
}

References RefreshCode::Cancelled, ImportFileHandle::CreateProgress(), floatSample, mChannels, mFloat64Output, mHandle, mNumChannels, ImportFileHandle::mProgress, mTrackFactory, mUpdateResult, ReadTags(), and SetupOutputFormat().

Here is the call graph for this function:

Open()

bool MP3ImportFileHandle::Open ( )

private

Definition at line 451 of file ImportMP3_MPG123.cpp.

{
   if (mHandle == nullptr)
      return false;
 
   // Open the file
   if (!mFile.Open(mFilename))
   {
      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 mFile, mFileLen, ImportFileHandle::mFilename, and mHandle.

ReadCallback()

ptrdiff_t MP3ImportFileHandle::ReadCallback ( void *  handle, void *  buffer, size_t  size  )

staticprivate

Definition at line 499 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 MP3ImportFileHandle::ReadTags

(

Tags *

tags

)

Definition at line 376 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 MP3ImportFileHandle::SeekCallback ( void *  handle, off_t  offset, int  whence  )

staticprivate

Definition at line 523 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.

SetupOutputFormat()

bool 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;
   mChannels.resize(mNumChannels);
 
   if (encoding != MPG123_ENC_FLOAT_32 && encoding != MPG123_ENC_FLOAT_64)
   {
      wxLogError("MPG123 returned unexpected encoding");
 
      return false;
   }
 
   mFloat64Output = encoding == MPG123_ENC_FLOAT_64;
 
   for (unsigned i = 0; i < mNumChannels; ++i)
      mChannels[i] = NewWaveTrack(*mTrackFactory, floatSample, rate);
 
   return true;
}

References floatSample, mChannels, mFloat64Output, mHandle, mNumChannels, mTrackFactory, and ImportFileHandle::NewWaveTrack().

Referenced by Import().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mChannels

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

private

Definition at line 155 of file ImportMP3_MPG123.cpp.

Referenced by Import(), and SetupOutputFormat().

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 162 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 160 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 164 of file ImportMP3_MPG123.cpp.

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().

mUpdateResult

ProgressResult anonymous_namespace{ImportMP3_MPG123.cpp}::MP3ImportFileHandle::mUpdateResult { ProgressResult::Success }

private

Definition at line 158 of file ImportMP3_MPG123.cpp.

Referenced by Import().

---

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

• ImportMP3_MPG123.cpp