Example #1
0
//following routine courtesy of John George
size_t ID3_GetPictureDataOfPicType(ID3_Tag* tag, const char* TempPicPath, ID3_PictureType pictype)
{
    if (NULL == tag)
        return 0;
    else
    {
        ID3_Frame* frame = NULL;
        ID3_Tag::Iterator* iter = tag->CreateIterator();

        while (NULL != (frame = iter->GetNext() ))
        {
            if(frame->GetID() == ID3FID_PICTURE)
            {
                if(frame->GetField(ID3FN_PICTURETYPE)->Get() == (uint32)pictype)
                    break;
            }
        }
        delete iter;

        if (frame != NULL)
        {
            ID3_Field* myField = frame->GetField(ID3FN_DATA);
            if (myField != NULL)
            {
                myField->ToFile(TempPicPath);
                return (size_t)myField->Size();
            }
            else return 0;
        }
        else return 0;
    }
}
Example #2
0
//following routine courtesy of John George
char* ID3_GetDescriptionOfPicType(ID3_Tag* tag, ID3_PictureType pictype)
{
    char* sPicDescription = NULL;
    if (NULL == tag)
        return sPicDescription;

    ID3_Frame* frame = NULL;
    ID3_Tag::Iterator* iter = tag->CreateIterator();

    while (NULL != (frame = iter->GetNext()))
    {
        if(frame->GetID() == ID3FID_PICTURE)
        {
            if(frame->GetField(ID3FN_PICTURETYPE)->Get() == (uint32)pictype)
                break;
        }
    }
    delete iter;

    if (frame != NULL)
    {
        sPicDescription = ID3_GetString(frame, ID3FN_DESCRIPTION);
    }
    return sPicDescription;
}
Example #3
0
//following routine courtesy of John George
size_t ID3_RemovePictureType(ID3_Tag* tag, ID3_PictureType pictype)
{
    size_t bremoved = 0;
    ID3_Frame* frame = NULL;

    if (NULL == tag)
        return bremoved;

    ID3_Tag::Iterator* iter = tag->CreateIterator();

    while (NULL != (frame = iter->GetNext()))
    {
        if (frame->GetID() == ID3FID_PICTURE)
        {
            if (frame->GetField(ID3FN_PICTURETYPE)->Get() == (uint32)pictype)
                break;
        }
    }
    delete iter;

    if (NULL != frame)
    {
        frame = tag->RemoveFrame(frame);
        delete frame;
        bremoved = 1;
    }
    return bremoved;
}
Example #4
0
ID3_Frame* ID3_AddComment(ID3_Tag *tag, const char *text,
                          const char *desc, const char* lang, bool replace)
{
    ID3_Frame* frame = NULL;
    if (NULL != tag  &&
            NULL != text &&
            NULL != desc &&
            strlen(text) > 0)
    {
        bool bAdd = true;
        if (replace)
        {
            ID3_RemoveComments(tag, desc);
        }
        else
        {
            // See if there is already a comment with this description
            ID3_Tag::Iterator* iter = tag->CreateIterator();
            ID3_Frame* frame = NULL;
            while ((frame = iter->GetNext()) != NULL)
            {
                if (frame->GetID() == ID3FID_COMMENT)
                {
                    char *tmp_desc = ID3_GetString(frame, ID3FN_DESCRIPTION);
                    if (strcmp(tmp_desc, desc) == 0)
                    {
                        bAdd = false;
                    }
                    delete [] tmp_desc;
                    if (!bAdd)
                    {
                        break;
                    }
                }
            }
            delete iter;
        }
        if (bAdd)
        {
            frame = new ID3_Frame(ID3FID_COMMENT);
            if (NULL != frame)
            {
                frame->GetField(ID3FN_LANGUAGE)->Set(lang);
                frame->GetField(ID3FN_DESCRIPTION)->Set(desc);
                frame->GetField(ID3FN_TEXT)->Set(text);
                tag->AttachFrame(frame);
            }
        }
    }
    return frame;
}
Example #5
0
// Remove all comments with the given description (remove all comments if
// desc is NULL)
size_t ID3_RemoveComments(ID3_Tag *tag, const char *desc)
{
    size_t num_removed = 0;

    if (NULL == tag)
    {
        return num_removed;
    }

    ID3_Tag::Iterator* iter = tag->CreateIterator();
    ID3_Frame* frame = NULL;
    while ((frame = iter->GetNext()) != NULL)
    {
        if (frame->GetID() == ID3FID_COMMENT)
        {
            bool remove = false;
            // A null description means remove all comments
            if (NULL == desc)
            {
                remove = true;
            }
            else
            {
                // See if the description we have matches the description of the
                // current comment.  If so, set the "remove the comment" flag to true.
                char *tmp_desc = ID3_GetString(frame, ID3FN_DESCRIPTION);
                remove = (strcmp(tmp_desc, desc) == 0);
                delete [] tmp_desc;
            }
            if (remove)
            {
                frame = tag->RemoveFrame(frame);
                delete frame;
                num_removed++;
            }
        }
    }
    delete iter;

    return num_removed;
}
Example #6
0
//***************************************************************************
bool Kwave::MP3Decoder::parseID3Tags(ID3_Tag &tag)
{
    if (tag.NumFrames() < 1) return true; // no tags, nothing to do

    QDate creation_date;
    QTime creation_time;
    int year  = -1;
    int month = -1;
    int day   = -1;

    ID3_Tag::Iterator *it = tag.CreateIterator();
    ID3_Frame *frame = 0;
    Kwave::FileInfo info(metaData());
    while (it && (frame = it->GetNext())) {
	const ID3_FrameID id = frame->GetID();
	const Kwave::FileProperty property = m_property_map.property(id);
	const ID3_PropertyMap::Encoding encoding = m_property_map.encoding(id);
	switch (encoding) {
	    case ID3_PropertyMap::ENC_TEXT_PARTINSET:
	    {
		QString s = parseId3Frame2String(frame);
		int cd  = 0;
		int cds = 0;
		if (s.contains(QLatin1Char('/'))) {
		    int i = s.indexOf(QLatin1Char('/'));
		    cd = s.left(i).toInt();
		    cds = s.mid(i + 1).toInt();
		} else {
		    cd = s.toInt();
		}
		if (cd  > 0) info.set(Kwave::INF_CD , QVariant(cd));
		if (cds > 0) info.set(Kwave::INF_CDS, QVariant(cds));
		break;
	    }
	    case ID3_PropertyMap::ENC_TRACK_NUM:
	    {
		QString s = parseId3Frame2String(frame);
		int track  = 0;
		int tracks = 0;
		if (s.contains(QLatin1Char('/'))) {
		    int i = s.indexOf(QLatin1Char('/'));
		    track = s.left(i).toInt();
		    tracks = s.mid(i + 1).toInt();
		} else {
		    track = s.toInt();
		}
		if (track  > 0) info.set(Kwave::INF_TRACK , QVariant(track));
		if (tracks > 0) info.set(Kwave::INF_TRACKS, QVariant(tracks));
		break;
	    }
	    case ID3_PropertyMap::ENC_TERMS_OF_USE:
		// the same as ENC_COMMENT, but without "Description"
		/* FALLTHROUGH */
	    case ID3_PropertyMap::ENC_COMMENT:
	    {
		QString s = parseId3Frame2String(frame);

		// optionally prepend language
		char *lang = ID3_GetString(frame, ID3FN_LANGUAGE);
		if (lang) {
		    s = _("[") + _(lang) + _("] ") + s;
		    ID3_FreeString(lang);
		}

		// append to already existing tag, separated by a slash
		if (info.contains(property))
		    s = info.get(property).toString() + _(" / ") + s;
		info.set(property, QVariant(s));
		break;
	    }
	    case ID3_PropertyMap::ENC_GENRE_TYPE:
	    {
		QString s = parseId3Frame2String(frame);
		int genre = Kwave::GenreType::fromID3(s);
		if (genre >= 0)
		    s = Kwave::GenreType::name(genre, false);
		info.set(property, QVariant(s));
		break;
	    }
	    case ID3_PropertyMap::ENC_LENGTH:
	    {
		// length in ms -> convert this to samples
		QString       s    = parseId3Frame2String(frame);
		const double  rate = info.rate();
		bool          ok   = false;
		const double  ms   = s.toDouble(&ok) + 0.5;
		if (ok && (rate > 0)) {
		    // NOTE: this overwrites the length found in the header!
		    sample_index_t length = static_cast<sample_index_t>(
			(rate * ms) / 1000.0);
		    info.setLength(length);
		}
		break;
	    }
	    case ID3_PropertyMap::ENC_TEXT_TIMESTAMP:
	    {
		if (!creation_date.isValid()) {
		    QString s = parseId3Frame2String(frame);
		    switch (id)
		    {
			case ID3FID_RECORDINGDATES:
			    // should be a ISO 8601 timestamp or similar
			    s = Kwave::string2date(s);
			    if (s.length())
				creation_date =
				    QDate::fromString(s, Qt::ISODate);
			    break;
			case ID3FID_DATE: {
			    // DDMM
			    unsigned int ddmm = s.toUInt();
			    day   = ddmm / 100;
			    month = ddmm % 100;
			    break;
			}
			case ID3FID_YEAR: /* FALLTHROUGH */
			case ID3FID_ORIGYEAR:
			    // YYYY
			    year = s.toUInt();
			    break;
			default:
			    break;
		    }
		}

		if (creation_time.isValid()) {
		    switch (id)
		    {
			case ID3FID_TIME:
			    creation_time = QTime::fromString(_("hhmm"));
			    break;
			default:
			    break;
		    }
		}
		break;
	    }
	    case ID3_PropertyMap::ENC_TEXT_SLASH:
	    {
		// append to already existing tag, separated by a slash
		QString s = parseId3Frame2String(frame);
		if (info.contains(property))
		    s = info.get(property).toString() + _(" / ") + s;
		info.set(property, QVariant(s));
		break;
	    }
	    case ID3_PropertyMap::ENC_TEXT_URL:   /* FALLTHROUGH */
	    case ID3_PropertyMap::ENC_TEXT:
		info.set(property, QVariant(parseId3Frame2String(frame)));
		break;
	    case ID3_PropertyMap::ENC_NONE: /* FALLTHROUGH */
	    default:
	    {
		QString s = parseId3Frame2String(frame);
		qWarning("unsupported ID3 tag: %d, descr: '%s', text: '%s'",
			 id, frame->GetDescription(), DBG(s));
		break;
	    }
	}
    }

    /*
     * try to build a valid creation date/time
     */
    if (!creation_date.isValid()) {
	// no complete creation date - try to reassemble from found y/m/d
	creation_date = QDate(year, month, day);
    }
    if (creation_date.isValid() && creation_time.isValid()) {
	// full date + time
	QDateTime dt(creation_date, creation_time);
	info.set(Kwave::INF_CREATION_DATE, dt.toString(
	    _("yyyy-MM-ddTHH:mm:ss")));
    } else if (creation_date.isValid()) {
	// date without time
	info.set(Kwave::INF_CREATION_DATE, creation_date.toString(
	    _("yyyy-MM-dd")));
    } else if (year > 0) {
	// only year
	creation_date = QDate(year, 1, 1);
	info.set(Kwave::INF_CREATION_DATE, creation_date.toString(_("yyyy")));
    }

    metaData().replace(Kwave::MetaDataList(info));

    return true;
}
MP3Data * MP3DataGenerator::readMetadata( const char * p_filePath)
{
	// Set up file connection.
	myID3_Tag = new ID3_Tag();
	myID3_Tag->Link( p_filePath);

	// Storage with default initialization.
	MP3Data * myMP3Data = new MP3Data();
	myMP3Data->setAll( "<undefinded>");

	// Retrieve metadata.
	ID3_Tag::Iterator * tagIter = myID3_Tag->CreateIterator();
	ID3_Frame * myFrame = NULL;
	while( NULL != ( myFrame = tagIter->GetNext()))
	{			
		if( NULL != myFrame)
		{			
			ID3_Field * myField = myFrame->GetField( ID3FN_TEXT);
			// Check if current frame is part of the set aka a field of interest.
			std::set<ID3_FrameID>::iterator current = interestingID3_FrameIDs->find( myFrame->GetID());
			if ( NULL != myField && current != interestingID3_FrameIDs->end())
			{
				ID3_FrameID_LUT * myLUT = new ID3_FrameID_LUT();
				std::string frameRealname = std::string( myLUT->getRealname( myFrame->GetID()));
				// @TODO Show encoding in gui (optional)
				if( myField->GetEncoding() == ID3TE_ASCII || ID3TE_ISO8859_1)
				{
					encoding += frameRealname + ": ISO8859_1 , ";
					// Genre needs to be converted.
					if( myFrame->GetID() == ID3FID_CONTENTTYPE) // ID3_FrameID = 32
					{
						const char * genre = myField->GetRawText();
						// ID3V1 genre has is an int surrounded by round brackets; ID3V2 genre is text.
						unsigned int genreIntegerAlias = removeBrackets( genre);
						if( genreIntegerAlias < ID3_NR_OF_V1_GENRES && genre[0] == '(')
							myMP3Data->setGenre( ID3_v1_genre_description[ genreIntegerAlias]);
						else 
							myMP3Data->setGenre( genre);
					}
					// All other tags.
					else if( myFrame->GetID() == ID3FID_TITLE)
						myMP3Data->setTitle( myField->GetRawText());
					else if( myFrame->GetID() == ID3FID_ALBUM)
						myMP3Data->setAlbum( myField->GetRawText());
					else if( myFrame->GetID() == ID3FID_YEAR)
						myMP3Data->setYear( myField->GetRawText());
					else if( myFrame->GetID() == ID3FID_TRACKNUM)
						myMP3Data->setTracknumber( myField->GetRawText());
					else if( myFrame->GetID() == ID3FID_LEADARTIST)
						myMP3Data->setArtist( myField->GetRawText());
				}
				else if( myField->GetEncoding() == ID3TE_UTF8)
				{
					encoding += frameRealname + ": utf8 , ";
					myMP3Data->setAll( "<unicode utf8 encoding>");
				}
				else if( myField->GetEncoding() == ID3TE_UNICODE || ID3TE_UTF16)
				{
					encoding += frameRealname + ": utf16 ,";
					// @TODO Conversion to std::string ... myField->GetRawUnicodeText();
					myMP3Data->setAll( "<unicode utf16 encoding>");
				}
				else if( myField->GetEncoding() == ID3TE_UTF16BE)
				{
					encoding += frameRealname + ": utf16be , ";
					myMP3Data->setAll( "<unicode utf16be encoding>");
				}
				else if( myField->GetEncoding() == ID3TE_NUMENCODINGS)
				{
					encoding += frameRealname + ": numencodings , ";
					myMP3Data->setAll( "<numencoding>");
				}
				else
				{
					encoding += frameRealname + ": unknown , ";
					myMP3Data->setAll( "<<unknown encoding>");
				}
			}
		}
	}
	// Retrieve file path and file name.
	myMP3Data->setFilepath( p_filePath);
	myMP3Data->setFilename( getFilename( p_filePath).c_str());
	return myMP3Data;
}
void MP3TagReader::ImportTags(MatroskaTagInfo *target) {
#ifdef USING_ID3LIB
	
	// use an std::auto_ptr here to handle object cleanup automatically
  ID3_Tag::Iterator *iter = m_Tag.CreateIterator();
  ID3_Frame *myFrame = NULL;
  while (NULL != (myFrame = iter->GetNext())) {
		// do something with myFrame
		//myFrame;
		ID3_Field *textField = myFrame->GetField(ID3FN_TEXTENC);
		ID3_Field *intField = myFrame->GetField(ID3FN_COUNTER);
		
		if (myFrame->GetID() == ID3FID_PLAYCOUNTER) {
			target->Tag_PlayCounter = intField->Get();

		} else if (myFrame->GetID() == ID3FID_POPULARIMETER) {
			target->Tag_Popularimeter = intField->Get();

		} else if (myFrame->GetID() == ID3FID_ALBUM) {
			MatroskaTagMultiTitleItem *newTagItem = new MatroskaTagMultiTitleItem();
			newTagItem->Type = KaxTagMultiTitleType_AlbumMovieShowTitle;
			newTagItem->Name = textField->GetRawUnicodeText();
			target->AddMultiTitleItem(newTagItem);

		} else if (myFrame->GetID() == ID3FID_BPM) {
			target->Tag_BPM = intField->Get();

		} else if (myFrame->GetID() == ID3FID_COMPOSER) {
			MatroskaTagMultiEntityItem *newTagItem = new MatroskaTagMultiEntityItem();
			newTagItem->Type = KaxTagMultiEntitiesType_Composer;
			newTagItem->Name = textField->GetRawUnicodeText();
			target->AddMultiEntityItem(newTagItem);

		} else if (myFrame->GetID() == ID3FID_PLAYLISTDELAY) {	
			target->Tag_PlaylistDelay = intField->Get();

		} else if (myFrame->GetID() == ID3FID_ENCODEDBY) {	
			MatroskaTagMultiEntityItem *newTagItem = new MatroskaTagMultiEntityItem();
			newTagItem->Type = KaxTagMultiEntitiesType_EncodedBy;
			newTagItem->Name = textField->GetRawUnicodeText();
			target->AddMultiEntityItem(newTagItem);

		} else if (myFrame->GetID() == ID3FID_LYRICIST) {	
			MatroskaTagMultiEntityItem *newTagItem = new MatroskaTagMultiEntityItem();
			newTagItem->Type = KaxTagMultiEntitiesType_LyricistTextWriter;
			newTagItem->Name = textField->GetRawUnicodeText();
			target->AddMultiEntityItem(newTagItem);

		} else if (myFrame->GetID() == ID3FID_TITLE) {
			MatroskaTagMultiTitleItem *newTagItem = new MatroskaTagMultiTitleItem();
			newTagItem->Type = KaxTagMultiTitleType_TrackTitle;
			newTagItem->Name = textField->GetRawUnicodeText();
			target->AddMultiTitleItem(newTagItem);

		} else if (myFrame->GetID() == ID3FID_SUBTITLE) {
			MatroskaTagMultiTitleItem *newTagItem = new MatroskaTagMultiTitleItem();
			newTagItem->Type = KaxTagMultiTitleType_TrackTitle;
			newTagItem->SubTitle = textField->GetRawUnicodeText();
			target->AddMultiTitleItem(newTagItem);

		} 
		
  }
  delete iter;

#endif
};
Example #9
0
void play_debug_meta(char* filename){
  ID3_Tag tag(filename);

  ID3_Tag::Iterator* iter = tag.CreateIterator();
  ID3_Frame* frame = NULL;
  char buf[1000];

  // Iconv conversion descriptor: UTF-16 -> UTF-8
  iconv_t cd = iconv_open("UTF8","UTF16BE");

  while (NULL != (frame = iter->GetNext()))
  {
    char* val = NULL;
    field_text(&val, frame); 
    printf("Frame: type %d %s %s:\n", frame->GetID(), frame->GetTextID(), frame->GetDescription());
    ID3_Frame::Iterator* fieldIter = frame->CreateIterator();
    ID3_Field* field = NULL;

    while (NULL != (field = fieldIter->GetNext())) {
      printf("  Field: type ");
      ID3_FieldType type = field->GetType();
      switch(type) {
      case ID3FTY_NONE:
        printf("none"); break;
      case ID3FTY_INTEGER:
        printf("int"); break;
      case ID3FTY_BINARY:
        printf("binary"); break;
      case ID3FTY_TEXTSTRING:
        field->Get(buf, 1000);
        printf("text with %d items, encoding ", field->GetNumTextItems());
        switch(field->GetEncoding()){
        case ID3TE_UTF16: printf("UTF-16"); 

          if ( cd != (iconv_t) -1 ) {
            char* in = (char*) field->GetRawUnicodeText();
            size_t insize = field->Size();

            char* bufptr = buf;
            size_t bufsize = 1000;
            size_t rc = 0;

            // Initialize iconv state
            if( iconv(cd, NULL, NULL, &bufptr, &bufsize) == (size_t) -1 ){
              printf("iconv init Failed\n");
            }
            if ( (rc = iconv(cd, &in, &insize, &bufptr, &bufsize)) != (size_t) -1 ) {
              *bufptr = '\0';
              printf(": '%s' (%d chars)\n", buf, rc);
            } else {
              printf("<conversion using iconv failed>");
              perror("iconv");
            }
          }
          break;
        case ID3TE_UTF16BE: printf("UTF-16BE"); 
          printf(": '%s'", buf);
          break;
        case ID3TE_UTF8: printf("UTF-8");
          printf(": '%s'", buf);
          break;
        case ID3TE_NONE: printf("none");
          printf(": '%s'", buf);
          break;
        case ID3TE_ISO8859_1: printf("ISO-8859-1/ASCII");
          printf(": '%s'", buf);
          break;
        }
        break;
      }
      printf("\n");
    }
    delete fieldIter;
    delete [] val;
  }
  delete iter;

  iconv_close(cd);
}