Извлечение GUID из файла MP3 с использованием TagLib

Question

итак, моя финальная игра получает обложки альбомов из моих аудиофайлов. я использую taglib и c ++. Я нашел информацию о том, как извлечь данные встроенного изображения, но, похоже, Windows Media Player не встраивает само изображение. вместо этого он сохраняет JPG с именем что-то вроде AlbumArt_ {E3208100-4FAA-4030-BB9D-6DA5F9D93D18} _Large.jpg. очевидно, что он использует guid, который, как я считаю, сохраняется в теге PRIV. мой вопрос к вам, ребята, как я могу получить к нему? Я думал, что-то вроде этого может работать:

    ID3v2::PrivateFrame* privFrame = static_cast<ID3v2::PrivateFrame*>(*privIter);
    if(privFrame != NULL)
    {
        std::string owner = privFrame->owner().toCString();
        if (owner == "WM/WMCollectionID" || owner == "WM/WMCollectionGroupID")
        {
            const char* data = privFrame->render().data();
            GUID guid;
            memcpy(&guid.Data1, data, sizeof(long));
        }
    }

но данные, похоже, не имеют ничего полезного. есть идеи?

Answer 1

для тех, у кого похожие проблемы, насколько я могу судить, PrivateFrame taglib не работает.таким образом, я свернул свой собственный:

bool MetadataReader::getAlbumGUID(const char* filename, GUID &guid)
{
    const int HEADER_LENGTH = 10;
    const int TAG_INDICATOR_LENGTH = 3;
    const string TAG_TYPE = "ID3";
    const int TAG_MAJOR = 3;
    const int TAG_MINOR = 0;
    const int HEADER_SIZE_BEGIN = 6;
    const int HEADER_SIZE_END = 9;
    const int EXTENDED_HEADER_POS = 5;
    const int EXTENDED_HEADER_SIZE_LENGTH = 4;
    const int FRAME_HEADER_LENGTH = 10;
    const int FRAME_ID_LENGTH = 4;
    const string FRAME_MEDIA_PLAYER_OWNER1 = "WM/WMCollectionID";
    const string FRAME_MEDIA_PLAYER_OWNER2 = "WM/WMCollectionGroupID";
    const string FRAME_MEDIA_PLAYER_ID = "PRIV";
    const int FRAME_SIZE_BEGIN = 4;
    const int FRAME_SIZE_END = 7;


    bool retValue = false;
    try
    {
        // read in file
        ifstream infile(filename, ios::binary);

        infile.seekg(0, ios::beg);

        char header[HEADER_LENGTH];
        infile.read(header, HEADER_LENGTH);

        string tagType(TAG_INDICATOR_LENGTH, '0');
        for (int i = 0; i < TAG_INDICATOR_LENGTH; i++)
        {
            tagType[i] = header[i];
        }
        int majorVersion = (int)header[TAG_INDICATOR_LENGTH];
        int minorVersion = (int)header[TAG_INDICATOR_LENGTH + 1];
        if (tagType == TAG_TYPE && majorVersion == TAG_MAJOR && minorVersion == TAG_MINOR)
        {
            // get extended header bit
            bool extHeader = (header[EXTENDED_HEADER_POS] & 0x0010000);

            // get size of extended header
            int extHeaderSize = 0;
            if (extHeader)
            {
                char extHeaderData[EXTENDED_HEADER_SIZE_LENGTH];
                infile.seekg(HEADER_LENGTH, ios::beg);
                infile.read(extHeaderData, EXTENDED_HEADER_SIZE_LENGTH);
                for (int i = 0; i <= EXTENDED_HEADER_SIZE_LENGTH; i++)
                {
                    extHeaderSize = extHeaderSize << 8;
                    extHeaderSize |= (unsigned char)extHeaderData[i];
                }
                extHeaderSize += EXTENDED_HEADER_SIZE_LENGTH;

            }
            // get size of tag.
            // 4 bytes with the most significant bit ignored
            int tagSize = 0;
            for (int i = HEADER_SIZE_BEGIN; i <= HEADER_SIZE_END; i++)
            {
                tagSize = tagSize << 7;
                tagSize |= (header[i] & 0x7f);
            }
            // tagSize includes extended header
            tagSize += HEADER_LENGTH;

            // read tags
            int currPos = HEADER_LENGTH + extHeaderSize;
            while (currPos < tagSize)
            {
                infile.seekg(currPos, ios::beg);

                char frameHeader[FRAME_HEADER_LENGTH];
                infile.read(frameHeader, FRAME_HEADER_LENGTH);

                // frame id
                string frameType(FRAME_ID_LENGTH, '0');
                for (int i = 0; i < FRAME_ID_LENGTH; i++)
                {
                    frameType[i] = frameHeader[i];
                }
                // frame length
                int frameLength = 0;
                for (int i = FRAME_SIZE_BEGIN; i <= FRAME_SIZE_END; i++)
                {
                    frameLength = frameLength << 8;
                    frameLength |= (unsigned char)frameHeader[i];
                }
                if (frameType == FRAME_MEDIA_PLAYER_ID)
                {
                    char* frameData = new char[frameLength];
                    infile.read(frameData, frameLength);
                    string owner = frameData;
                    if (owner == FRAME_MEDIA_PLAYER_OWNER1 || owner == FRAME_MEDIA_PLAYER_OWNER2)
                    {
                        memcpy(&guid, frameData + owner.length() + 1, sizeof(GUID));
                        retValue = true;
                    }
                    delete[] frameData;
                }

                currPos += FRAME_HEADER_LENGTH + frameLength;
            }
            infile.close();
        }
    }
    catch (...)
    {
        retValue = false;
    }

    return retValue;
}