{

MP3ImportPlugin();

~MP3ImportPlugin();

wxString GetPluginStringID() override;

TranslatableString GetPluginFormatDescription() override;

std::unique_ptr<ImportFileHandle> Open(const FilePath &Filename, AudacityProject*) override;

{

MP3ImportFileHandle(const FilePath &filename);

~MP3ImportFileHandle();

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;

bool Open();

void CheckTags();

void CheckAPETags(bool atEnd);

void CheckID3V1Tags();

void CheckID3V2Tags(bool atEnd);

void CheckLyrics();

bool CheckMP3();

bool FillBuffer();

void LoadID3(Tags *tags);

// The MAD callbacks

static mad_flow input_cb(void *that,

struct mad_stream *stream);

mad_flow InputCB(struct mad_stream *stream);

static mad_flow filter_cb(void *that,

struct mad_stream const *stream,

struct mad_frame *frame);

mad_flow FilterCB(struct mad_stream const *stream, struct mad_frame *frame);

static mad_flow output_cb(void *that,

struct mad_header const *header,

struct mad_pcm *pcm);

mad_flow OutputCB(struct mad_header const *header, struct mad_pcm *pcm);

static mad_flow error_cb(void *that,

struct mad_stream *stream,

struct mad_frame *frame);

mad_flow ErrorCB(struct mad_stream *stream, struct mad_frame *frame);

mad_decoder mDecoder;

wxFile mFile;

wxFileOffset mFilePos;

wxFileOffset mFileLen;

unsigned char mInputBuffer[INPUT_BUFFER_SIZE + MAD_BUFFER_GUARD];

int mInputBufferLen;

WaveTrackFactory *mTrackFactory;

NewChannelGroup mChannels;

unsigned mNumChannels;

ProgressResult mUpdateResult;

int mDelay;

int mPadding;

bool mHaveID3;

friend MP3ImportPlugin;

const FilePath &Filename, AudacityProject *)

{

auto handle = std::make_unique<MP3ImportFileHandle>(Filename);

if (!handle->Open())

{

return nullptr;

}

return handle;

{

// TODO

return 0;

TrackHolders &outTracks,

Tags *tags)

{

outTracks.clear();

CreateProgress();

mTrackFactory = trackFactory;

mUpdateResult = ProgressResult::Success;

mNumChannels = 0;

// Set delay and padding to best possible in case the LAME tag is not present

mDelay = MAD_DELAY;

mPadding = 0;

// Initialize decoder

mad_decoder_init(&mDecoder, this, input_cb, 0, filter_cb, output_cb, error_cb, 0);

// Send the decoder on its way!

auto res = mad_decoder_run(&mDecoder, MAD_DECODER_MODE_SYNC);

// Terminate decoder

mad_decoder_finish(&mDecoder);

// Decoding failed, so pass it on

if (res != 0)

{

return ProgressResult::Failed;

}

// The user canceled the decoding, so bail without saving tracks or tags

if (mUpdateResult == ProgressResult::Cancelled)

{

return mUpdateResult;

}

// Flush and trim the channels

for (const auto &channel : mChannels)

{

channel->Flush();

// Trim any padding

if (mPadding)

{

double et = channel->GetEndTime();

double t1 = et - channel->LongSamplesToTime(mPadding);

channel->Clear(t1, et);

}

// And delay

if (mDelay)

{

double st = channel->GetStartTime();

double t0 = st + channel->LongSamplesToTime(mDelay);

channel->Clear(st, t0);

}

}

// Copy the WaveTrack pointers into the Track pointer list that

// we are expected to fill

outTracks.push_back(std::move(mChannels));

// Load ID3 tags from the file

LoadID3(tags);

return mUpdateResult;

{

mInputBufferLen = 0;

mFilePos = 0;

mHaveID3 = 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 for ID3 tags

CheckTags();

// Scan for the first MP3 frame

if (!CheckMP3())

{

mFile.Close();

return false;

}

return true;

{

// We do this twice to allow them to be in any order

for (int i = 0; i < 2; ++i)

{

CheckAPETags(false);

CheckID3V2Tags(false);

}

// We do this twice to allow them to be in any order. Even though ID3v1 is

// supposed to at the end, some apps put the v2 tags after the v1 tags.

for (int i = 0; i < 2; ++i)

{

CheckAPETags(true);

CheckID3V1Tags();

CheckLyrics();

CheckID3V2Tags(true);

}

return;

{

int offset = atEnd ? mFileLen - 32 : mFilePos;

// Ensure file is positioned to start of (possible) tags

if (mFile.Seek(offset, wxFromStart) == wxInvalidOffset || mFile.Error())

{

return;

}

// An APE tag header is 32 bytes

if (mFile.Read(mInputBuffer, 32) != 32 || mFile.Error())

{

return;

}

// Do we have an APE preamble?

if (memcmp(mInputBuffer, "APETAGEX", 8) != 0)

{

return;

}

// Get the (little endian) length

wxFileOffset len = (mInputBuffer[12] & 0xff) |

((mInputBuffer[13] & 0xff) << 8) |

((mInputBuffer[14] & 0xff) << 16) |

((mInputBuffer[15] & 0xff) << 24);

// Get needed flags

bool hasHeader = mInputBuffer[23] & 0x80;

// Skip the tags

if (!atEnd)

{

mFilePos += (32 + len);

}

else

{

mFileLen -= ((hasHeader ? 32 : 0) + len);

}

{

// Ensure file is positioned to start of (possible) tags

if (mFile.Seek(mFileLen - 128, wxFromStart) == wxInvalidOffset || mFile.Error())

{

return;

}

// An ID3v1 tag header is 3 bytes

if (mFile.Read(mInputBuffer, 3) != 3 || mFile.Error())

{

return;

}

// Do we have ID3v1 tags?

if (memcmp(mInputBuffer, "TAG", 3) != 0)

{

return;

}

// Adjust file length

mFileLen -= 128;

// Remember that we have tags

mHaveID3 = true;

{

int offset = mFileLen - 9;

// Ensure file is positioned to start of (possible) lyrics

if (mFile.Seek(offset, wxFromStart) == wxInvalidOffset || mFile.Error())

{

return;

}

// An Lyrics3 footeris 9 bytes

if (mFile.Read(mInputBuffer, 9) != 9 || mFile.Error())

{

return;

}

// Found a v1 Lyrics footer?

if (memcmp(mInputBuffer, "LYRICSEND", 9) == 0)

{

wxFileOffset pos = wxMax(offset - 5100, 0);

size_t len = offset - pos;

// Ensure file is positioned to start of (possible) lyrics

if (mFile.Seek(pos, wxFromStart) == wxInvalidOffset || mFile.Error())

{

return;

}

// Read the lyrics

if (mFile.Read(mInputBuffer, len) != len || mFile.Error())

{

return;

}

// Search forward to find the beginning of the lyrics

for (size_t i = 0; i < len; ++i)

{

if (memcmp(&mInputBuffer[i], "LYRICSBEGIN", 11) == 0)

{

// Adjust the file length to exclude the lyrics

mFileLen = pos + i;

break;

}

}

}

// Found a v2 Lyrics footer?

else if (memcmp(mInputBuffer, "LYRICS200", 9) == 0)

{

// Ensure file is positioned to start of (possible) lyrics

if (mFile.Seek(-15, wxFromCurrent) == wxInvalidOffset || mFile.Error())

{

return;

}

// An Lyrics3v2 length is 6 bytes

if (mFile.Read(mInputBuffer, 6) != 6 || mFile.Error())

{

return;

}

// Adjust the file length to exclude the lyrics

mInputBuffer[6] = 0;

mFileLen -= (wxAtoi((char *) mInputBuffer) + 15);

}

{

int offset = atEnd ? mFileLen - 10 : mFilePos;

// Ensure file is positioned to start of (possible) tags

if (mFile.Seek(offset, wxFromStart) == wxInvalidOffset || mFile.Error())

{

return;

}

// An ID3v2 tag header is 10 bytes

if (mFile.Read(mInputBuffer, 10) != 10 || mFile.Error())

{

return;

}

// Do we have an ID3v2 header or footer?

if (memcmp(mInputBuffer, atEnd ? "3DI" : "ID3", 3) != 0)

{

return;

}

// Get and decode the length

wxFileOffset len = (mInputBuffer[6] & 0x7f);

len = (len << 7) | (mInputBuffer[7] & 0x7f);

len = (len << 7) | (mInputBuffer[8] & 0x7f);

len = (len << 7) | (mInputBuffer[9] & 0x7f);

// Skip the tags

if (!atEnd)

{

mFilePos += (10 + len);

}

else

{

mFileLen -= (10 + len + 10);

}

// Remember that we have tags

mHaveID3 = true;

{

wxFileOffset savedPos = mFilePos;

// Ensure file is positioned to start of 1st mp3 frame

if (mFile.Seek(mFilePos, wxFromStart) == wxInvalidOffset || mFile.Error())

{

return false;

}

// Load as much as will fit into the buffer

if (!FillBuffer())

{

return false;

}

// Initialize mad stream

mad_stream stream;

mad_stream_init(&stream);

mad_stream_buffer(&stream, mInputBuffer, mInputBufferLen);

// And header

mad_header header;

mad_header_init(&header);

// Scan the input buffer for 2 consecutive MP3 frames. When the header

// decoder finds a frame, it decodes it and ensures it is followed by

// another frame or EOF...thus 2 (or 1) consecutive frame(s) are detected.

int consecutive = 1;

while (consecutive > 0)

{

// Decode the header at the current stream position.

if (mad_header_decode(&header, &stream))

{

// End of buffer.

if (stream.error != MAD_ERROR_NONE)

{

break;

}

}

consecutive -= 1;

}

// Remember how many bytes were processed

int used = stream.this_frame - stream.buffer;

// Cleanup

mad_header_finish(&header);

mad_stream_finish(&stream);

// Did we find all that we wanted?

if (consecutive)

{

return false;

}

// Reset file controls

mInputBufferLen = 0;

// Reposition file to start of mp3 frames to prepare for the Import.

mFilePos = savedPos + used;

if (mFile.Seek(mFilePos, wxFromStart) == wxInvalidOffset || mFile.Error())

{

return false;

}

// Looks like an MP3...

return true;

{

// We either want enough to fill the input buffer or what's left in the file

auto want = wxMin(INPUT_BUFFER_SIZE - mInputBufferLen, mFileLen - mFilePos);

if (want > 0)

{

// We should always get what we ask for

auto got = mFile.Read(&mInputBuffer[mInputBufferLen], want);

if (got != want || mFile.Error())

{

return false;

}

// Adjust input control

mInputBufferLen += got;

mFilePos += got;

}

// MAD requires that we add MAD_BUFFER_GUARD extra bytes when we've processed

// all of the MP3 frames. Otherwise, we will drop the last frame.

if (mFilePos == mFileLen)

{

memset(&mInputBuffer[mInputBufferLen], 0, MAD_BUFFER_GUARD);

mInputBufferLen += MAD_BUFFER_GUARD;

}

return true;

{

#ifdef USE_LIBID3TAG

struct id3_file *id3file = NULL;

auto cleanup = finally([&]

{

if (id3file)

{

id3_file_close(id3file);

}

});

// Use id3_file_fdopen() instead of id3_file_open since wxWidgets can open a

// file with a Unicode name and id3_file_open() can't (under Windows).

id3file = id3_file_fdopen(mFile.fd(), ID3_FILE_MODE_READONLY);

if (!id3file)

{

return;

}

// The file descriptor is now owned by "id3file", so we must tell "mFile" to forget

// about it.

mFile.Detach();

// Load the tags

struct id3_tag *id3tags = id3_file_tag(id3file);

if (!id3tags || id3tags->nframes == 0)

{

return;

}

// Convert from libid3tag's ucs4 type to wxString.

//

// The ucs4 type is unsigned long which can be 8 bytes instead

// of the expected 4 bytes for a UTF-32 character, so we have

// to convert to unsigned int and then to wxString.

wxMBConvUTF32 converter;

auto toString = [=](const id3_ucs4_t *in)

{

// Count the number of characters

size_t len = 0;

for (const id3_ucs4_t *p = in; *p; p++)

{

len++;

}

// Would like to use std::dynarray or runtime-sized array,

// but VS doesn't support either.

wxUint32 *buf = (wxUint32 *) alloca((len + 1) * sizeof(wxUint32));

// Copy and convert to unsigned int

wxUint32 *out;

for (out = buf; *in; in++, out++)

{

*out = (wxUint32) (*in);

}

*out = 0;

// Finally convert to and return wxString

return wxString((char *) buf, converter);

};

tags->Clear();

// Extract tags from ID3 frames and add to our tags

bool have_year = false;

for (unsigned int i = 0; i < id3tags->nframes; ++i)

{

struct id3_frame *frame = id3tags->frames[i];

#if 0

wxLogDebug("ID: %08x '%4s'", (int) *(int *)frame->id, frame->id);

wxLogDebug("Desc: %s", frame->description);

wxLogDebug("Num fields: %d", frame->nfields);

for (unsigned int j = 0; j < frame->nfields; ++j)

{

wxLogDebug("field %d type %d", j, frame->fields[j].type);

if (frame->fields[j].type == ID3_FIELD_TYPE_STRINGLIST)

{

wxLogDebug("num strings %d", frame->fields[j].stringlist.nstrings);

}

}

#endif

wxString n;

wxString v;

// Determine the tag name

if (strcmp(frame->id, ID3_FRAME_TITLE) == 0)

{

n = TAG_TITLE;

}

else if (strcmp(frame->id, ID3_FRAME_ARTIST) == 0)

{

n = TAG_ARTIST;

}

else if (strcmp(frame->id, ID3_FRAME_ALBUM) == 0)

{

n = TAG_ALBUM;

}

else if (strcmp(frame->id, ID3_FRAME_TRACK) == 0)

{

n = TAG_TRACK;

}

else if (strcmp(frame->id, ID3_FRAME_YEAR) == 0)

{

// LLL: When libid3tag encounters the "TYER" tag, it converts it to a

// "ZOBS" (obsolete) tag and adds a "TDRC" tag at the end of the

// list of tags using the first 4 characters of the "TYER" tag.

// Since we write both the "TDRC" and "TYER" tags, the "TDRC" tag

// will always be encountered first in the list. We want to use

// it since the converted "TYER" tag may have been truncated.

if (have_year)

{

continue;

}

n = TAG_YEAR;

have_year = true;

}

else if (strcmp(frame->id, ID3_FRAME_COMMENT) == 0)

{

n = TAG_COMMENTS;

}

else if (strcmp(frame->id, ID3_FRAME_GENRE) == 0)

{

n = TAG_GENRE;

}

else

{

// Use frame description as default tag name. The descriptions

// may include several "meanings" separated by "/" characters, so

// we just use the first meaning

n = UTF8CTOWX(frame->description).BeforeFirst(wxT('/'));

}

// Now get the tag value

const id3_ucs4_t *ustr = NULL;

if (n == TAG_COMMENTS)

{

ustr = id3_field_getfullstring(&frame->fields[3]);

}

else if (frame->nfields == 3)

{

ustr = id3_field_getstring(&frame->fields[1]);

if (ustr)

{

n = toString(ustr);

}

ustr = id3_field_getstring(&frame->fields[2]);

}

else if (frame->nfields >= 2)

{

ustr = id3_field_getstrings(&frame->fields[1], 0);

}

// Convert the value

if (ustr)

{

v = toString(ustr);

}

// And add it to the list of tags

if (!n.empty() && !v.empty())

{

tags->SetTag(n, v);

}

}

// Convert v1 genre to name

if (tags->HasTag(TAG_GENRE))

{

long g = -1;

if (tags->GetTag(TAG_GENRE).ToLong(&g))

{

tags->SetTag(TAG_GENRE, tags->GetGenre(g));

}

}

#else

(void) tags;

#endif

struct mad_stream *stream)

{

auto cb = [&]()

{

return ((MP3ImportFileHandle *) that)->InputCB(stream);

};

return GuardedCall<mad_flow>(cb, MakeSimpleGuard(MAD_FLOW_BREAK));

{

// Update the progress

mUpdateResult = mProgress->Update((wxLongLong_t) mFilePos, (wxLongLong_t) mFileLen);

if (mUpdateResult != ProgressResult::Success)

{

return MAD_FLOW_STOP;

}

// Stop if we've consumed all of the MP3 data

if (mFilePos == mFileLen)

{

return MAD_FLOW_STOP;

}

// "Each time you refill your buffer, you need to preserve the data in

// your existing buffer from stream.next_frame to the end.

//

// This usually amounts to calling memmove() on this unconsumed portion

// of the buffer and appending NEW data after it, before calling

// mad_stream_buffer()

// -- Rob Leslie, on the mad-dev mailing list

if (stream->next_frame)

{

mInputBufferLen -= (stream->next_frame - mInputBuffer);

memmove(mInputBuffer, stream->next_frame, mInputBufferLen);

}

// Refill the buffer

if (!FillBuffer())

{

return MAD_FLOW_BREAK;

}

// And give it back to MAD

mad_stream_buffer(stream, mInputBuffer, mInputBufferLen);

return MAD_FLOW_CONTINUE;

struct mad_stream const *stream,

struct mad_frame *frame)

{

auto cb = [&]()

{

return ((MP3ImportFileHandle *) that)->FilterCB(stream, frame);

};

return GuardedCall<mad_flow>(cb, MakeSimpleGuard(MAD_FLOW_BREAK));

struct mad_frame *frame)

{

// We only want to jinspect the first frame, so disable future calls

mDecoder.filter_func = nullptr;

// Is it a VBRI info frame?

if (memcmp(&stream->this_frame[4 + 32], "VBRI", 4) == 0)

{

mDelay = (stream->this_frame[4 + 32 + 6] & 0xff) << 8 |

(stream->this_frame[4 + 32 + 7] & 0xff);

return MAD_FLOW_CONTINUE;

}

// Look for Xing/Info information

// Get the ancillary data ptr and length. If the frame has CRC protection, we make

// a small adjustment to get around an apparent bug in libmad.

auto ptr = stream->anc_ptr.byte - (frame->header.flags & MAD_FLAG_PROTECTION ? 2 : 0);

int len = stream->anc_bitlen / 8;

// Ensure it's something we can understand

if (len < 4 || (memcmp(ptr, "Xing", 4) != 0 && memcmp(ptr, "Info", 4) != 0))

{

return MAD_FLOW_CONTINUE;

}

// Skip the tag

ptr += 4;

len -= 4;

enum flagBits

{

hasFrames = 0x0001,

hasBytes = 0x0002,

hasToc = 0x0004,

hasScale = 0x0008

};

// Extract the flags

unsigned int flags = (((((ptr[0] << 8) + ptr[1]) << 8) + ptr[2]) << 8) + ptr[3];

ptr += 4;

len -= 4;

// Skip the number of frames

if (len >= 4 && flags & hasFrames)

{

ptr += 4;

len -= 4;

}

// Skip the number of bytes

if (len >= 4 && flags & hasBytes)

{

ptr += 4;

len -= 4;

}

// Skip the TOC

if (len >= 100 && flags & hasToc)

{

ptr += 100;

len -= 100;

}

// Skip the VBR Scale

if (len >= 4 && flags & hasScale)

{

ptr += 4;

len -= 4;

}

// Bail if LAME wasn't the encoder or we don't have enough ancillary data left

if (len < 24 || memcmp(ptr, "LAME", 4) != 0)

{

return MAD_FLOW_IGNORE;

}

// Skip down to the delay and padding

ptr += 21;

len -= 21;

// Extract the delay and padding and adjust for decoder delay

mDelay = (ptr[0] << 4) + (ptr[1] >> 4) + MAD_DELAY;