int main(int argc, char ** argv) {
if (argc != 2) {
cout << "usage: " << argv[0] << " output.mp3" << endl;
return 1;
}
const char * filename = argv[1];
ID3_Tag tag;
tag.Link(filename);
AddTextFrame(tag, ID3FID_TITLE, "Dummy Title");
AddTextFrame(tag, ID3FID_LEADARTIST, "Dummy Artist");
AddTextFrame(tag, ID3FID_ALBUM, "Dummy Album");
AddTextFrame(tag, ID3FID_TRACKNUM, "1/10");
AddTextFrame(tag, ID3FID_YEAR, "2000");
AddTextFrame(tag, ID3FID_COMMENT, "Dummy Comment");
AddTextFrame(tag, ID3FID_COMMENT, "Dummy Comment 2");
AddTextFrame(tag, ID3FID_CONTENTTYPE, "Pop");
ID3_Frame userFrame(ID3FID_USERTEXT);
userFrame.Field(ID3FN_DESCRIPTION).Set("MusicBrainz Album Id");
userFrame.Field(ID3FN_TEXT).Set("992dc19a-5631-40f5-b252-fbfedbc328a9");
tag.AddFrame(userFrame);
tag.Update();
return 0;
}
int main( int argc, char *argv[])
{
ID3D_INIT_DOUT();
ID3D_INIT_WARNING();
ID3D_INIT_NOTICE();
ID3_Tag tag;
ID3_Frame frame;
tag.Link("test-230-compressed.tag");
tag.Strip(ID3TT_ALL);
tag.Clear();
frame.SetID(ID3FID_USERTEXT);
frame.GetField(ID3FN_DESCRIPTION)->Set("compression example");
frame.GetField(ID3FN_TEXT)->Set("This sample user text frame came from an ID3v2-3.0 tag. The frame has the 'compression' bit set in it's frame header. This is the new method for compressing frames, which supercedes the 2.01 Compressed Data Metaframe.");
frame.SetCompression(true);
tag.AddFrame(frame);
tag.SetPadding(false);
tag.SetUnsync(false);
tag.Update(ID3TT_ID3V2);
return 0;
}
void StripTags(char *file)
{
ID3_Tag myTag;
myTag.Link(file);
myTag.Strip();
return;
}
int main( int argc, char ** argv ) {
ID3_Tag tag;
tag.Link( argv[1] );
AddTextFrame(tag, ID3FID_TITLE, "Dummy Title");
AddTextFrame(tag, ID3FID_LEADARTIST, "Dummy Artist");
AddTextFrame(tag, ID3FID_ALBUM, "Dummy Album");
AddTextFrame(tag, ID3FID_TRACKNUM, "1/10");
AddTextFrame(tag, ID3FID_YEAR, "2000");
AddTextFrame(tag, ID3FID_COMMENT, "Dummy Comment");
AddTextFrame(tag, ID3FID_COMMENT, "Dummy Comment 2");
AddTextFrame(tag, ID3FID_CONTENTTYPE, "Pop");
tag.Update();
return 0;
}
int main( int argc, char *argv[])
{
ID3_Tag tag;
ID3_Frame frame;
tag.Link("test-230-unicode.tag");
tag.Strip(ID3TT_ALL);
tag.Clear();
frame.SetID(ID3FID_USERTEXT);
frame.GetField(ID3FN_DESCRIPTION)->Set("example text frame");
frame.GetField(ID3FN_TEXT)->Set("This text and the description should be in Unicode.");
frame.GetField(ID3FN_TEXTENC)->Set(ID3TE_UNICODE);
tag.AddFrame(frame);
tag.SetPadding(false);
tag.SetUnsync(false);
tag.Update(ID3TT_ID3V2);
return 0;
}
void ListTag(int argc, char *argv[], int optind)
{
bool id3v1_tag = false;
bool id3v2_tag = false;
int ret = 0;
for (int nIndex = optind; nIndex < argc; nIndex++)
{
ID3_Tag myTag;
ret = PrintID3v1Tag(argv[nIndex]);
if (ret == -1)
{
continue;
}
else if(ret == 0)
{
id3v1_tag = true;
}
myTag.Link(argv[nIndex], ID3TT_ID3V2);
if(!PrintInformation(argv[nIndex],myTag))
id3v2_tag = true;
if(!id3v1_tag && !id3v2_tag)
std::cout << argv[nIndex] << ": No ID3 tag" << std::endl;
else {
if (!id3v1_tag)
std::cout << argv[nIndex] << ": No ID3v1 tag" << std::endl;
if (!id3v2_tag)
std::cout << argv[nIndex] << ": No ID3v2 tag" << std::endl;
}
id3v1_tag = false;
id3v2_tag = false;
}
return;
}
int main( unsigned int argc, char * const argv[])
{
ID3D_INIT_DOUT();
gengetopt_args_info args;
if (cmdline_parser(argc, argv, &args) != 0)
{
exit(1);
}
#if defined ID3_ENABLE_DEBUG
if (args.warning_flag)
{
ID3D_INIT_WARNING();
ID3D_WARNING ( "warnings turned on" );
}
if (args.notice_flag)
{
ID3D_INIT_NOTICE();
ID3D_NOTICE ( "notices turned on" );
}
#endif
const char* filename = NULL;
for (size_t i = 0; i < args.inputs_num; ++i)
{
filename = args.inputs[i];
ID3_Tag myTag;
myTag.Link(filename, ID3TT_ALL);
const Mp3_Headerinfo* mp3info;
mp3info = myTag.GetMp3HeaderInfo();
cout << endl << "*** Tag information for " << filename << endl;
if (!args.assign_given)
{
PrintInformation(myTag);
}
else
{
cout << "*** Testing assignment operator" << endl;
ID3_Tag tmpTag(myTag);
PrintInformation(tmpTag);
}
if (mp3info)
{
cout << "*** mp3 info\n";
switch (mp3info->version)
{
case MPEGVERSION_2_5:
cout << "MPEG2.5/";
break;
case MPEGVERSION_2:
cout << "MPEG2/";
break;
case MPEGVERSION_1:
cout << "MPEG1/";
break;
default:
break;
}
switch (mp3info->layer)
{
case MPEGLAYER_III:
cout << "layer III\n";
break;
case MPEGLAYER_II:
cout << "layer II\n";
break;
case MPEGLAYER_I:
cout << "layer I\n";
break;
default:
break;
}
cout << "Bitrate: " << mp3info->bitrate/1000 << "KBps\n";
cout << "Frequency: " << mp3info->frequency/1000 << "KHz\n";
}
}
return 0;
}
int main( int argc, char *argv[])
{
ID3D_INIT_DOUT();
ID3D_INIT_WARNING();
ID3D_INIT_NOTICE();
ID3_Tag tag;
ID3_Frame frame;
tag.Link("test-230-picture.tag");
tag.Strip(ID3TT_ALL);
tag.Clear();
frame.SetID(ID3FID_TITLE);
frame.GetField(ID3FN_TEXT)->Set("Aquarium");
tag.AddFrame(frame);
frame.SetID(ID3FID_CONTENTGROUP);
frame.GetField(ID3FN_TEXT)->Set("Short fraction of 'Carnival of the Animals: A Grand Zoological Fantasy'");
tag.AddFrame(frame);
frame.SetID(ID3FID_COMPOSER);
frame.GetField(ID3FN_TEXT)->Set("Camille Saint-Saëns");
tag.AddFrame(frame);
frame.SetID(ID3FID_BAND);
frame.GetField(ID3FN_TEXT)->Set("Slovakia Radio Symphony Orchestra");
tag.AddFrame(frame);
frame.SetID(ID3FID_CONDUCTOR);
frame.GetField(ID3FN_TEXT)->Set("Ondrej Lenárd");
tag.AddFrame(frame);
frame.SetID(ID3FID_COPYRIGHT);
frame.GetField(ID3FN_TEXT)->Set("1996 HNH international Ltd.");
tag.AddFrame(frame);
frame.SetID(ID3FID_CONTENTTYPE);
frame.GetField(ID3FN_TEXT)->Set("(32)");
tag.AddFrame(frame);
frame.SetID(ID3FID_INVOLVEDPEOPLE);
frame.GetField(ID3FN_TEXT)->Add("Producer");
frame.GetField(ID3FN_TEXT)->Add("Martin Sauer");
frame.GetField(ID3FN_TEXT)->Add("Piano");
frame.GetField(ID3FN_TEXT)->Add("Peter Toperczer");
tag.AddFrame(frame);
frame.SetID(ID3FID_PICTURE);
frame.GetField(ID3FN_MIMETYPE)->Set("image/jpeg");
frame.GetField(ID3FN_PICTURETYPE)->Set(11);
frame.GetField(ID3FN_DESCRIPTION)->Set("B/W picture of Saint-Saëns");
frame.GetField(ID3FN_DATA)->FromFile("composer.jpg");
tag.AddFrame(frame);
tag.SetPadding(false);
tag.SetUnsync(true);
tag.Update(ID3TT_ID3V2);
return 0;
}
int main(int argc, char * const argv[])
{
int ulFlag = ID3TT_ID3;
ID3D_INIT_DOUT();
gengetopt_args_info args;
if (cmdline_parser(argc, argv, &args) != 0)
{
exit(1);
}
#if defined ID3_ENABLE_DEBUG
if (args.warning_flag)
{
ID3D_INIT_WARNING();
ID3D_WARNING ( "warnings turned on" );
}
if (args.notice_flag)
{
ID3D_INIT_NOTICE();
ID3D_NOTICE ( "notices turned on" );
}
#endif
if (args.v1tag_flag)
{
ulFlag = ID3TT_ID3V1;
}
if (args.v2tag_flag)
{
ulFlag = ID3TT_ID3V2;
}
const char
*sArtist = "",
*sAlbum = "",
*sTitle = "",
*sComment = "",
*sYear = "",
*sDesc = "";
unsigned short
nYear = 0,
nTrack = 0,
nTotal = 0,
nGenre = 0;
if (args.artist_given)
{
sArtist = args.artist_arg;
cout << "+++ Artist = " << sArtist << endl;
}
if (args.album_given)
{
sAlbum = args.album_arg;
cout << "+++ Album = " << sAlbum << endl;
}
if (args.song_given)
{
sTitle = args.song_arg;
cout << "+++ Song = " << sTitle << endl;
}
if (args.year_given)
{
sYear = args.year_arg;
nYear = ::strtol(sYear, NULL, 10);
cout << "+++ Year = " << nYear << endl;
}
if (args.comment_given)
{
sComment = args.comment_arg;
cout << "+++ Comment = " << sComment << endl;
if (args.desc_given)
{
sDesc = args.desc_arg;
cout << "+++ Comment Description" << endl;
cout << " = " << sDesc << endl;
}
else
{
sDesc = "";
}
}
if (args.genre_given && args.genre_arg > 0 && args.genre_arg < 0xFF)
{
nGenre = args.genre_arg;
cout << "+++ Genre = " << args.genre_arg << endl;
}
if (args.track_given)
{
nTrack = ::strtol(args.track_arg, NULL, 10);
cout << "+++ Track = " << nTrack << endl;
}
if (args.total_given)
{
nTotal = ::strtol(args.total_arg, NULL, 10);
cout << "+++ Total = " << nTotal << endl;
}
const char* filename = NULL;
for (size_t i = 0; i < args.inputs_num; ++i)
{
filename = args.inputs[i];
ID3_Tag myTag;
cout << "Tagging " << filename << ": ";
myTag.Link(filename);
cout << "attempting ";
DisplayTags(cout, ulFlag);
if (args.artist_given)
{
ID3_AddArtist(&myTag, sArtist, true);
}
if (args.album_given)
{
ID3_AddAlbum(&myTag, sAlbum, true);
}
if (args.song_given)
{
ID3_AddTitle(&myTag, sTitle, true);
}
if (args.year_given)
{
ID3_AddYear(&myTag, sYear, true);
}
if (args.comment_given)
{
ID3_AddComment(&myTag, sComment, sDesc, true);
}
if (args.genre_given)
{
ID3_AddGenre(&myTag, nGenre, true);
}
if (args.track_given)
{
ID3_AddTrack(&myTag, nTrack, nTotal, true);
}
luint nTags = myTag.Update(ulFlag);
cout << ", tagged ";
DisplayTags(cout, nTags);
cout << endl;
}
return 0;
}
int main( unsigned int argc, char * const argv[])
{
flags_t ulFlag = ID3TT_ALL;
gengetopt_args_info args;
if (cmdline_parser(argc, argv, &args) != 0)
{
exit(1);
}
#if defined ID3_ENABLE_DEBUG
if (args.warning_flag)
{
ID3D_INIT_WARNING();
ID3D_WARNING ( "warnings turned on" );
}
if (args.notice_flag)
{
ID3D_INIT_NOTICE();
ID3D_NOTICE ( "notices turned on" );
}
#endif
if (args.v1tag_flag)
{
ulFlag = ID3TT_ID3V1;
}
if (args.v2tag_flag)
{
ulFlag = ID3TT_ID3V2;
}
const char* filename = NULL;
for (size_t i = 0; i < args.inputs_num; ++i)
{
filename = args.inputs[i];
ID3_Tag myTag;
if (args.strip_given)
{
cout << "Stripping ";
}
else
{
cout << "Converting ";
}
cout << filename << ": ";
myTag.Clear();
myTag.Link(filename, ID3TT_ALL);
myTag.SetPadding(args.padding_flag);
cout << "attempting ";
DisplayTags(cout, ulFlag);
luint nTags;
if (args.strip_flag)
{
nTags = myTag.Strip(ulFlag);
cout << ", stripped ";
}
else
{
nTags = myTag.Update(ulFlag);
cout << ", converted ";
}
DisplayTags(cout, nTags);
cout << endl;
}
return 0;
}
//***************************************************************************
bool Kwave::MP3Decoder::open(QWidget *widget, QIODevice &src)
{
qDebug("MP3Decoder::open()");
metaData().clear();
Q_ASSERT(!m_source);
if (m_source) qWarning("MP3Decoder::open(), already open !");
/* open the file in readonly mode with seek enabled */
if (src.isSequential()) return false;
if (!src.open(QIODevice::ReadOnly)) {
qWarning("unable to open source in read-only mode!");
return false;
}
/* read all available ID3 tags */
ID3_Tag tag;
ID3_QIODeviceReader adapter(src);
tag.Link(adapter, static_cast<flags_t>(ID3TT_ALL));
qDebug("NumFrames = %u", Kwave::toUint(tag.NumFrames()));
/** @bug: id3lib crashes in this line on some MP3 files */
if (tag.GetSpec() != ID3V2_UNKNOWN) {
qDebug("Size = %u", Kwave::toUint(tag.Size()));
}
qDebug("HasLyrics = %d", tag.HasLyrics());
qDebug("HasV1Tag = %d", tag.HasV1Tag());
qDebug("HasV2Tag = %d", tag.HasV2Tag());
m_prepended_bytes = tag.GetPrependedBytes();
m_appended_bytes = tag.GetAppendedBytes();
qDebug("prepended=%lu, appended=%lu", m_prepended_bytes, m_appended_bytes);
const Mp3_Headerinfo *mp3hdr = tag.GetMp3HeaderInfo();
if (!mp3hdr) {
Kwave::MessageBox::sorry(widget,
i18n("The opened file is no MPEG file or it is damaged.\n"
"No header information has been found."));
return false;
}
/* parse the MP3 header */
if (!parseMp3Header(*mp3hdr, widget)) return false;
/* parse the ID3 tags */
if (!parseID3Tags(tag)) return false;
/* accept the source */
m_source = &src;
Kwave::FileInfo info(metaData());
info.set(Kwave::INF_MIMETYPE, _("audio/mpeg"));
metaData().replace(Kwave::MetaDataList(info));
// allocate a transfer buffer with 128 kB
if (m_buffer) free(m_buffer);
m_buffer_size = (128 << 10);
m_buffer = static_cast<unsigned char *>(malloc(m_buffer_size));
if (!m_buffer) return false; // out of memory :-(
return true;
}
int main( int argc, char *argv[])
{
ID3_Tag tag;
ID3_Frame frame;
if (argc == 2)
{
tag.Link(argv[1]);
cerr << "removed " << RemoveFrame(tag, ID3FID_COMMENT, "") << " descriptionless comment frames" << endl;
tag.Update();
}
else
{
tag.Link("test-remove.tag");
tag.Strip(ID3TT_ALL);
tag.Clear();
frame.SetID(ID3FID_TITLE);
frame.GetField(ID3FN_TEXT)->Set("Test title");
tag.AddFrame(frame);
frame.SetID(ID3FID_COMPOSER);
frame.GetField(ID3FN_TEXT)->Set("Test composer");
tag.AddFrame(frame);
frame.SetID(ID3FID_BAND);
frame.GetField(ID3FN_TEXT)->Set("Test band");
tag.AddFrame(frame);
frame.SetID(ID3FID_CONDUCTOR);
frame.GetField(ID3FN_TEXT)->Set("Test conductor");
tag.AddFrame(frame);
frame.SetID(ID3FID_COMMENT);
frame.GetField(ID3FN_LANGUAGE)->Set("eng");
frame.GetField(ID3FN_TEXT)->Set("Test comment");
frame.GetField(ID3FN_DESCRIPTION)->Set("A Description");
tag.AddFrame(frame);
frame.SetID(ID3FID_COMMENT);
frame.GetField(ID3FN_LANGUAGE)->Set("eng");
frame.GetField(ID3FN_TEXT)->Set("Test comment 2");
frame.GetField(ID3FN_DESCRIPTION)->Set("");
tag.AddFrame(frame);
frame.SetID(ID3FID_COMMENT);
frame.GetField(ID3FN_LANGUAGE)->Set("eng");
frame.GetField(ID3FN_TEXT)->Set("ID3v1 comment text?");
frame.GetField(ID3FN_DESCRIPTION)->Set(STR_V1_COMMENT_DESC);
tag.AddFrame(frame);
tag.SetPadding(false);
tag.Update(ID3TT_ID3V2);
cerr << "removed " << ID3_RemoveArtists(&tag) << " artist frames" << endl;
tag.Update();
cerr << "removed " << ID3_RemoveTitles(&tag) << " title frames" << endl;
tag.Update();
cerr << "removed " << RemoveFrame(tag, ID3FID_COMMENT, "") << " descriptionless comment frames" << endl;
tag.Update();
}
return 0;
}
int main( int argc, char *argv[])
{
int iOpt;
int argCounter = 0;
int ii;
char tmp[TMPSIZE];
FILE * fp;
struct frameInfo {
enum ID3_FrameID id;
char *data;
} frameList[MAXNOFRAMES];
int frameCounter = 0;
while (true)
{
int option_index = 0;
int iLongOpt = 0;
int optFrameID = ID3FID_NOFRAME;
static struct option long_options[] =
{
// help and info
{ "help", no_argument, &iLongOpt, 'h' },
{ "list-frames",
no_argument, &iLongOpt, 'f' },
{ "list-genres",
no_argument, &iLongOpt, 'L' },
{ "version", no_argument, &iLongOpt, 'v' },
// list / remove / convert
{ "list", no_argument, &iLongOpt, 'l' },
{ "list-rfc822",
no_argument, &iLongOpt, 'R' },
{ "delete-v2", no_argument, &iLongOpt, 'd' },
{ "delete-v1",
no_argument, &iLongOpt, 's' },
{ "delete-all",
no_argument, &iLongOpt, 'D' },
{ "convert", no_argument, &iLongOpt, 'C' },
{ "id3v1-only", no_argument, &iLongOpt, '1' },
{ "id3v2-only", no_argument, &iLongOpt, '2' },
// infomation to tag
{ "artist", required_argument, &iLongOpt, 'a' },
{ "album", required_argument, &iLongOpt, 'A' },
{ "song", required_argument, &iLongOpt, 't' },
{ "comment", required_argument, &iLongOpt, 'c' },
{ "genre", required_argument, &iLongOpt, 'g' },
{ "year", required_argument, &iLongOpt, 'y' },
{ "track", required_argument, &iLongOpt, 'T' },
{ "AENC", required_argument, &optFrameID, ID3FID_AUDIOCRYPTO },
{ "APIC", required_argument, &optFrameID, ID3FID_PICTURE },
{ "COMM", required_argument, &optFrameID, ID3FID_COMMENT },
/* COMR too complex */
{ "ENCR", required_argument, &optFrameID, ID3FID_CRYPTOREG },
{ "EQUA", required_argument, &optFrameID, ID3FID_EQUALIZATION },
{ "ETCO", required_argument, &optFrameID, ID3FID_EVENTTIMING },
{ "GEOB", required_argument, &optFrameID, ID3FID_GENERALOBJECT },
{ "GRID", required_argument, &optFrameID, ID3FID_GROUPINGREG },
{ "IPLS", required_argument, &optFrameID, ID3FID_INVOLVEDPEOPLE },
{ "LINK", required_argument, &optFrameID, ID3FID_LINKEDINFO },
{ "MCDI", required_argument, &optFrameID, ID3FID_CDID },
{ "MLLT", required_argument, &optFrameID, ID3FID_MPEGLOOKUP },
{ "OWNE", required_argument, &optFrameID, ID3FID_OWNERSHIP },
{ "PRIV", required_argument, &optFrameID, ID3FID_PRIVATE },
{ "PCNT", required_argument, &optFrameID, ID3FID_PLAYCOUNTER },
{ "POPM", required_argument, &optFrameID, ID3FID_POPULARIMETER },
{ "POSS", required_argument, &optFrameID, ID3FID_POSITIONSYNC },
{ "RBUF", required_argument, &optFrameID, ID3FID_BUFFERSIZE },
{ "RVAD", required_argument, &optFrameID, ID3FID_VOLUMEADJ },
{ "RVRB", required_argument, &optFrameID, ID3FID_REVERB },
{ "SYLT", required_argument, &optFrameID, ID3FID_SYNCEDLYRICS },
{ "SYTC", required_argument, &optFrameID, ID3FID_SYNCEDTEMPO },
{ "TALB", required_argument, &optFrameID, ID3FID_ALBUM },
{ "TBPM", required_argument, &optFrameID, ID3FID_BPM },
{ "TCOM", required_argument, &optFrameID, ID3FID_COMPOSER },
{ "TCON", required_argument, &optFrameID, ID3FID_CONTENTTYPE },
{ "TCOP", required_argument, &optFrameID, ID3FID_COPYRIGHT },
{ "TDAT", required_argument, &optFrameID, ID3FID_DATE },
{ "TDLY", required_argument, &optFrameID, ID3FID_PLAYLISTDELAY },
{ "TENC", required_argument, &optFrameID, ID3FID_ENCODEDBY },
{ "TEXT", required_argument, &optFrameID, ID3FID_LYRICIST },
{ "TFLT", required_argument, &optFrameID, ID3FID_FILETYPE },
{ "TIME", required_argument, &optFrameID, ID3FID_TIME },
{ "TIT1", required_argument, &optFrameID, ID3FID_CONTENTGROUP },
{ "TIT2", required_argument, &optFrameID, ID3FID_TITLE },
{ "TIT3", required_argument, &optFrameID, ID3FID_SUBTITLE },
{ "TKEY", required_argument, &optFrameID, ID3FID_INITIALKEY },
{ "TLAN", required_argument, &optFrameID, ID3FID_LANGUAGE },
{ "TLEN", required_argument, &optFrameID, ID3FID_SONGLEN },
{ "TMED", required_argument, &optFrameID, ID3FID_MEDIATYPE },
{ "TOAL", required_argument, &optFrameID, ID3FID_ORIGALBUM },
{ "TOFN", required_argument, &optFrameID, ID3FID_ORIGFILENAME },
{ "TOLY", required_argument, &optFrameID, ID3FID_ORIGLYRICIST },
{ "TOPE", required_argument, &optFrameID, ID3FID_ORIGARTIST },
{ "TORY", required_argument, &optFrameID, ID3FID_ORIGYEAR },
{ "TOWN", required_argument, &optFrameID, ID3FID_FILEOWNER },
{ "TPE1", required_argument, &optFrameID, ID3FID_LEADARTIST },
{ "TPE2", required_argument, &optFrameID, ID3FID_BAND },
{ "TPE3", required_argument, &optFrameID, ID3FID_CONDUCTOR },
{ "TPE4", required_argument, &optFrameID, ID3FID_MIXARTIST },
{ "TPOS", required_argument, &optFrameID, ID3FID_PARTINSET },
{ "TPUB", required_argument, &optFrameID, ID3FID_PUBLISHER },
{ "TRCK", required_argument, &optFrameID, ID3FID_TRACKNUM },
{ "TRDA", required_argument, &optFrameID, ID3FID_RECORDINGDATES },
{ "TRSN", required_argument, &optFrameID, ID3FID_NETRADIOSTATION },
{ "TRSO", required_argument, &optFrameID, ID3FID_NETRADIOOWNER },
{ "TSIZ", required_argument, &optFrameID, ID3FID_SIZE },
{ "TSRC", required_argument, &optFrameID, ID3FID_ISRC },
{ "TSSE", required_argument, &optFrameID, ID3FID_ENCODERSETTINGS },
{ "TXXX", required_argument, &optFrameID, ID3FID_USERTEXT },
{ "TYER", required_argument, &optFrameID, ID3FID_YEAR },
{ "UFID", required_argument, &optFrameID, ID3FID_UNIQUEFILEID },
{ "USER", required_argument, &optFrameID, ID3FID_TERMSOFUSE },
{ "USLT", required_argument, &optFrameID, ID3FID_UNSYNCEDLYRICS },
{ "WCOM", required_argument, &optFrameID, ID3FID_WWWCOMMERCIALINFO },
{ "WCOP", required_argument, &optFrameID, ID3FID_WWWCOPYRIGHT },
{ "WOAF", required_argument, &optFrameID, ID3FID_WWWAUDIOFILE },
{ "WOAR", required_argument, &optFrameID, ID3FID_WWWARTIST },
{ "WOAS", required_argument, &optFrameID, ID3FID_WWWAUDIOSOURCE },
{ "WORS", required_argument, &optFrameID, ID3FID_WWWRADIOPAGE },
{ "WPAY", required_argument, &optFrameID, ID3FID_WWWPAYMENT },
{ "WPUB", required_argument, &optFrameID, ID3FID_WWWPUBLISHER },
{ "WXXX", required_argument, &optFrameID, ID3FID_WWWUSER },
{ 0, 0, 0, 0 }
};
iOpt = getopt_long (argc, argv, "12hfLvlRdsDCa:A:t:c:g:y:T:",
long_options, &option_index);
if (iOpt == -1 && argCounter == 0)
{
PrintUsage(argv[0]);
exit(0);
}
else if (iOpt == -1)
break;
argCounter++;
if (iOpt == 0) iOpt = iLongOpt;
// if (iOpt == 0) iOpt = optFrameID;
#ifdef SORT_RUNTIME
InitGenres();
#endif // SORT_RUNTIME
switch (iOpt)
{
case 0:
frameList[frameCounter].id = (enum ID3_FrameID)optFrameID;
frameList[frameCounter].data = optarg;
frameCounter++;
break;
case '?':
case 'h': PrintUsage(argv[0]); exit (0);
case 'f': PrintFrameHelp(argv[0]);exit (0);
case 'L': PrintGenreList(); exit (0);
case 'v': PrintVersion(argv[0]); exit (0);
// listing / remove / convert -- see list.cpp and convert.cpp
case 'l': ListTag(argc, argv, optind, 0);
exit (0);
case 'R': ListTag(argc, argv, optind, 1);
exit (0);
case 'd': DeleteTag(argc, argv, optind, 2);
exit (0);
case 's': DeleteTag(argc, argv, optind, 1);
exit (0);
case 'D': DeleteTag(argc, argv, optind, 0);
exit (0);
case 'C': ConvertTag(argc, argv, optind);
exit (0);
case '1':
UpdFlags = ID3TT_ID3V1;
break;
case '2':
UpdFlags = ID3TT_ID3V2;
break;
// Tagging stuff
case 'a':
frameList[frameCounter].id = ID3FID_LEADARTIST;
frameList[frameCounter].data = optarg;
frameCounter++;
break;
case 'A':
frameList[frameCounter].id = ID3FID_ALBUM;
frameList[frameCounter].data = optarg;
frameCounter++;
break;
case 't':
frameList[frameCounter].id = ID3FID_TITLE;
frameList[frameCounter].data = optarg;
frameCounter++;
break;
case 'c':
frameList[frameCounter].id = ID3FID_COMMENT;
frameList[frameCounter].data = optarg;
frameCounter++;
break;
case 'g':
{
int genre_id = 255;
char *genre_str;
sscanf(optarg, "%d", &genre_id);
if (genre_id == 255)
genre_id = GetNumFromGenre(optarg);
if (genre_id == 255)
genre_str = optarg;
else {
sprintf(tmp, "(%d)", genre_id);
genre_str = tmp;
}
frameList[frameCounter].id = ID3FID_CONTENTTYPE;
frameList[frameCounter].data = genre_str;
frameCounter++;
}
break;
case 'y':
frameList[frameCounter].id = ID3FID_YEAR;
frameList[frameCounter].data = optarg;
frameCounter++;
break;
case 'T':
frameList[frameCounter].id = ID3FID_TRACKNUM;
frameList[frameCounter].data = optarg;
frameCounter++;
break;
// other tags
default:
std::cerr << "This isn't supposed to happen" << std::endl;
exit(1);
}
}
// loop thru the files
if (optind == argc)
{
std::cerr << "No file to work on." << std::endl;
exit(1);
}
for (size_t nIndex = optind; (unsigned int) nIndex < argc; nIndex++)
{
ID3_Tag myTag;
struct stat filestat;
// std::cout << "Tagging " << argv[nIndex] << ": ";
// fix me - not checking to see if we can link to it
if (stat(argv[nIndex], &filestat))
{
std::cerr << "Couldn't stat file '" << argv[nIndex] << "'\n";
break;
}
/* cludgy to check if we have the proper perms */
fp = fopen(argv[nIndex], "r+");
if (fp == NULL) { /* file didn't open */
fprintf(stderr, "fopen: %s: ", argv[nIndex]);
perror("id3v2");
continue;
}
fclose(fp);
size_t ret;
ret = myTag.Link(argv[nIndex] /*, ID3TT_ID3V2 */);
// loop thru the frames we need to add/modify
for (ii = 0; ii < frameCounter; ii++)
{
ID3_Frame *myFrame;
myFrame = new ID3_Frame;
if (NULL == myFrame)
{
std::cout << "\nOut of memory\n" << std::endl;
exit(1);
}
myFrame->SetID(frameList[ii].id);
ID3_Frame *pFrame;
pFrame = myTag.Find(frameList[ii].id);
switch (frameList[ii].id)
{
// strings
case ID3FID_ALBUM:
case ID3FID_BPM:
case ID3FID_COMPOSER:
case ID3FID_CONTENTTYPE:
case ID3FID_COPYRIGHT:
case ID3FID_DATE:
case ID3FID_PLAYLISTDELAY:
case ID3FID_ENCODEDBY:
case ID3FID_LYRICIST:
case ID3FID_FILETYPE:
case ID3FID_TIME:
case ID3FID_CONTENTGROUP:
case ID3FID_TITLE:
case ID3FID_SUBTITLE:
case ID3FID_INITIALKEY:
case ID3FID_LANGUAGE:
case ID3FID_SONGLEN:
case ID3FID_MEDIATYPE:
case ID3FID_ORIGALBUM:
case ID3FID_ORIGFILENAME:
case ID3FID_ORIGLYRICIST:
case ID3FID_ORIGARTIST:
case ID3FID_ORIGYEAR:
case ID3FID_FILEOWNER:
case ID3FID_LEADARTIST:
case ID3FID_BAND:
case ID3FID_CONDUCTOR:
case ID3FID_MIXARTIST:
case ID3FID_PARTINSET:
case ID3FID_PUBLISHER:
case ID3FID_RECORDINGDATES:
case ID3FID_NETRADIOSTATION:
case ID3FID_NETRADIOOWNER:
case ID3FID_SIZE:
case ID3FID_ISRC:
case ID3FID_ENCODERSETTINGS:
case ID3FID_YEAR:
{
if (pFrame != NULL)
{
myTag.RemoveFrame(pFrame);
}
if (strlen(frameList[ii].data) > 0) {
myFrame->Field(ID3FN_TEXT) = frameList[ii].data;
myTag.AttachFrame(myFrame);
}
break;
}
case ID3FID_TRACKNUM:
{
// this ought to check if there is a total track number and
// combine it with the given track number, but it doesn't.
char *currentTrackNum = NULL;
char *newTrackNum = NULL;
if (pFrame != NULL)
{
currentTrackNum = ID3_GetString(pFrame, ID3FN_TEXT);
if (*currentTrackNum == '/')
{
newTrackNum = (char *)malloc(strlen(currentTrackNum)
+ strlen(frameList[ii].data));
strcpy(newTrackNum, frameList[ii].data);
strcat(newTrackNum, currentTrackNum);
}
else
{
myTag.RemoveFrame(pFrame);
}
}
myFrame->Field(ID3FN_TEXT) = frameList[ii].data;
myTag.AttachFrame(myFrame);
free(newTrackNum);
break;
}
case ID3FID_USERTEXT:
{
if (pFrame != NULL)
{
myTag.RemoveFrame(pFrame);
}
// split the string at the ':' remember if no : then leave
// descrip empty
char *text;
text = strchr(frameList[ii].data, ':');
if (text == NULL)
{
myFrame->Field(ID3FN_TEXT) = frameList[ii].data;
} else {
*text = '\0';
text++;
myFrame->Field(ID3FN_DESCRIPTION) = frameList[ii].data;
myFrame->Field(ID3FN_TEXT) = text;
}
if (strlen(ID3_GetString(myFrame, ID3FN_TEXT)) > 0) {
myTag.AttachFrame(myFrame);
}
break;
}
case ID3FID_COMMENT:
case ID3FID_UNSYNCEDLYRICS:
{
// split the string at the ':' remember if no : then leave
// descrip/lang empty
char *text;
text = strchr(frameList[ii].data, ':');
if (text == NULL)
{
myFrame->Field(ID3FN_TEXT) = frameList[ii].data;
} else {
*text = '\0';
text++;
char *lang;
lang = strchr(text, ':');
if (lang == NULL)
{
myFrame->Field(ID3FN_DESCRIPTION) = frameList[ii].data;
myFrame->Field(ID3FN_TEXT) = text;
} else {
*lang = '\0';
lang++;
myFrame->Field(ID3FN_DESCRIPTION) = frameList[ii].data;
myFrame->Field(ID3FN_TEXT) = text;
myFrame->Field(ID3FN_LANGUAGE) = lang;
}
}
/* debug
std::cout << ID3_GetString(myFrame, ID3FN_DESCRIPTION) << std::endl
<< ID3_GetString(myFrame, ID3FN_TEXT) << std::endl
<< ID3_GetString(myFrame, ID3FN_LANGUAGE) << std::endl;
*/
// now try and find a comment/lyrics with the same descript
// and lang as what we have
ID3_Frame *pFirstFrame = NULL;
do {
// if pFrame is NULL, either there were no comments/lyrics
// to begin with, or we removed them all in the process
if (pFrame == NULL) break;
if (pFirstFrame == NULL)
{
pFirstFrame = pFrame;
}
char *tmp_desc = ID3_GetString(pFrame, ID3FN_DESCRIPTION);
char *tmp_my_desc = ID3_GetString(myFrame, ID3FN_DESCRIPTION);
char *tmp_lang = ID3_GetString(pFrame, ID3FN_LANGUAGE);
char *tmp_my_lang = ID3_GetString(myFrame, ID3FN_LANGUAGE);
if ((strcmp(tmp_desc, tmp_my_desc) == 0) &&
(strcmp(tmp_lang, tmp_my_lang) == 0))
{
myTag.RemoveFrame(pFrame);
if (pFrame == pFirstFrame)
{
pFirstFrame = NULL;
}
}
delete [] tmp_desc;
delete [] tmp_my_desc;
delete [] tmp_lang;
delete [] tmp_my_lang;
// get the next frame until it wraps around
} while ((pFrame = myTag.Find(frameList[ii].id)) != pFirstFrame);
if (strlen(ID3_GetString(myFrame, ID3FN_TEXT)) > 0) {
myTag.AttachFrame(myFrame);
}
break;
}
case ID3FID_WWWAUDIOFILE:
case ID3FID_WWWARTIST:
case ID3FID_WWWAUDIOSOURCE:
case ID3FID_WWWCOMMERCIALINFO:
case ID3FID_WWWCOPYRIGHT:
case ID3FID_WWWPUBLISHER:
case ID3FID_WWWPAYMENT:
case ID3FID_WWWRADIOPAGE:
{
if (pFrame != NULL)
{
char *sURL = ID3_GetString(pFrame, ID3FN_URL);
if (strcmp(frameList[ii].data, sURL) == 0)
myTag.RemoveFrame(pFrame);
}
if (strlen(frameList[ii].data) > 0) {
myFrame->Field(ID3FN_URL) = frameList[ii].data;
myTag.AttachFrame(myFrame);
}
break;
}
case ID3FID_WWWUSER:
{
char
*sURL = ID3_GetString(myFrame, ID3FN_URL),
*sDesc = ID3_GetString(myFrame, ID3FN_DESCRIPTION);
std::cout << "(" << sDesc << "): " << sURL << std::endl;
delete [] sURL;
delete [] sDesc;
break;
}
case ID3FID_INVOLVEDPEOPLE:
{
// This isn't the right way to do it---will only get first person
size_t nItems = myFrame->Field(ID3FN_TEXT).GetNumTextItems();
for (size_t nIndex = 1; nIndex <= nItems; nIndex++)
{
char *sPeople = ID3_GetString(myFrame, ID3FN_TEXT, nIndex);
std::cout << sPeople;
delete [] sPeople;
if (nIndex < nItems)
{
std::cout << ", ";
}
}
std::cout << std::endl;
break;
}
case ID3FID_PICTURE:
{
myFrame->Field(ID3FN_DATA).FromFile(frameList[ii].data);
myTag.AttachFrame(myFrame);
break;
}
case ID3FID_GENERALOBJECT:
{
char
*sMimeType = ID3_GetString(myFrame, ID3FN_TEXT),
*sDesc = ID3_GetString(myFrame, ID3FN_DESCRIPTION),
*sFileName = ID3_GetString(myFrame, ID3FN_FILENAME);
size_t
nDataSize = myFrame->Field(ID3FN_DATA).Size();
std::cout << "(" << sDesc << ")["
<< sFileName << "]: " << sMimeType << ", " << nDataSize
<< " bytes" << std::endl;
delete [] sMimeType;
delete [] sDesc;
delete [] sFileName;
break;
}
case ID3FID_UNIQUEFILEID:
{
if (pFrame != NULL)
{
char *sOwner = ID3_GetString(pFrame, ID3FN_TEXT);
size_t nDataSize = pFrame->Field(ID3FN_DATA).Size();
std::cout << sOwner << ", " << nDataSize
<< " bytes" << std::endl;
delete [] sOwner;
}
break;
}
case ID3FID_PLAYCOUNTER:
{
if (pFrame != NULL)
{
size_t nCounter = pFrame->Field(ID3FN_COUNTER).Get();
std::cout << nCounter << std::endl;
}
break;
}
case ID3FID_POPULARIMETER:
{
if (pFrame != NULL)
{
char *sEmail = ID3_GetString(pFrame, ID3FN_EMAIL);
size_t
nCounter = pFrame->Field(ID3FN_COUNTER).Get(),
nRating = pFrame->Field(ID3FN_RATING).Get();
std::cout << sEmail << ", counter="
<< nCounter << " rating=" << nRating;
delete [] sEmail;
}
break;
}
case ID3FID_CRYPTOREG:
case ID3FID_GROUPINGREG:
{
char *sOwner = ID3_GetString(myFrame, ID3FN_OWNER);
size_t
nSymbol = myFrame->Field(ID3FN_ID).Get(),
nDataSize = myFrame->Field(ID3FN_DATA).Size();
std::cout << "(" << nSymbol << "): " << sOwner
<< ", " << nDataSize << " bytes";
break;
}
case ID3FID_AUDIOCRYPTO:
case ID3FID_EQUALIZATION:
case ID3FID_EVENTTIMING:
case ID3FID_CDID:
case ID3FID_MPEGLOOKUP:
case ID3FID_OWNERSHIP:
case ID3FID_PRIVATE:
case ID3FID_POSITIONSYNC:
case ID3FID_BUFFERSIZE:
case ID3FID_VOLUMEADJ:
case ID3FID_REVERB:
case ID3FID_SYNCEDLYRICS:
case ID3FID_SYNCEDTEMPO:
case ID3FID_METACRYPTO:
{
std::cout << " (unimplemented)" << std::endl;
break;
}
default:
{
std::cout << " frame" << std::endl;
break;
}
}
} // steping thru frames
luint nTags = myTag.Update(UpdFlags);
/* update file with old mode */
if (chmod(argv[nIndex], filestat.st_mode))
{
std::cerr << "Couldn't reset permissions on '" << argv[nIndex] << "'\n";
}
}
return 0;
}