298 lines
8.4 KiB
C++
298 lines
8.4 KiB
C++
/* Copyright (C) 2015 Alexander Schmidt <alex@treefish.org>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include <taglib/fileref.h>
|
|
#include <taglib/tag.h>
|
|
#include <taglib/tpropertymap.h>
|
|
#include <taglib/tstringlist.h>
|
|
#include <getopt.h>
|
|
#include <vector>
|
|
#include <sstream>
|
|
|
|
using namespace std;
|
|
|
|
enum action {LIST, REPLACE, INSERT, ERASE, AUDIO};
|
|
typedef pair<action,string> actionpair;
|
|
typedef vector<actionpair> actionqueue;
|
|
typedef pair<TagLib::String,TagLib::StringList> keyandvalues;
|
|
|
|
keyandvalues toKeyAndValues (const string &rawstring)
|
|
{
|
|
stringstream tmpss;
|
|
TagLib::String key;
|
|
TagLib::StringList values;
|
|
int isplit=0;
|
|
|
|
for (int ipos=0; ipos < rawstring.length(); ipos++) {
|
|
if ( rawstring[ipos] == '\\' ) {
|
|
switch (rawstring[ipos+1]) {
|
|
case '\\':
|
|
tmpss << '\\';
|
|
break;
|
|
case '=':
|
|
tmpss << '=';
|
|
break;
|
|
default:
|
|
tmpss << '\\' << rawstring[ipos+1];
|
|
break;
|
|
}
|
|
ipos++;
|
|
}
|
|
else
|
|
if ( rawstring[ipos] == '=' ) {
|
|
if ( isplit == 0 )
|
|
key = tmpss.str();
|
|
else
|
|
values.append(tmpss.str());
|
|
isplit++;
|
|
tmpss.str("");
|
|
}
|
|
else
|
|
tmpss << rawstring[ipos];
|
|
}
|
|
|
|
if (isplit==0)
|
|
key = tmpss.str();
|
|
else
|
|
values.append(tmpss.str());
|
|
|
|
return make_pair(key, values);
|
|
}
|
|
|
|
void action_eraseTag (TagLib::PropertyMap &propmap, const string &key)
|
|
{
|
|
propmap.erase(key);
|
|
}
|
|
|
|
void action_replaceTag (TagLib::PropertyMap &propmap, const keyandvalues &keyAndValues)
|
|
{
|
|
propmap.replace(keyAndValues.first, keyAndValues.second);
|
|
}
|
|
|
|
void action_insertTag (TagLib::PropertyMap &propmap, const keyandvalues &keyAndValues)
|
|
{
|
|
propmap.insert(keyAndValues.first, keyAndValues.second);
|
|
}
|
|
|
|
int action_printTags (const TagLib::FileRef f, TagLib::PropertyMap &propmap)
|
|
{
|
|
if(f.tag()) {
|
|
unsigned int longest = 0;
|
|
for(TagLib::PropertyMap::ConstIterator i = propmap.begin(); i != propmap.end(); ++i) {
|
|
if (i->first.size() > longest) {
|
|
longest = i->first.size();
|
|
}
|
|
}
|
|
cout << " \\_____/ TAGS \\_____ _ _ _" << endl;
|
|
for(TagLib::PropertyMap::ConstIterator i = propmap.begin(); i != propmap.end(); ++i) {
|
|
for(TagLib::StringList::ConstIterator j = i->second.begin(); j != i->second.end(); ++j) {
|
|
cout << i->first << "=" << *j << endl;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
int action_printAudio (const TagLib::FileRef f)
|
|
{
|
|
if(f.audioProperties()) {
|
|
TagLib::AudioProperties *properties = f.audioProperties();
|
|
int seconds = properties->length() % 60;
|
|
int minutes = (properties->length() - seconds) / 60;
|
|
cout << " \\_____/ AUDIO PROPERTIES \\_____ _ _ _" << endl;
|
|
cout << "BITRATE=" << properties->bitrate() << endl;
|
|
cout << "SAMPLERATE=" << properties->sampleRate() << endl;
|
|
cout << "CHANNELS=" << properties->channels() << endl;
|
|
cout << "LENGTH=" << minutes << ":" << setfill('0') << setw(2) << seconds << endl;
|
|
return 0;
|
|
}
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
void printHelp ()
|
|
{
|
|
cout <<
|
|
"Usage: usetaglib [ACTION]... [FILE]...\n"
|
|
"Read and edit meta-data of audio formats supported by taglib.\n"
|
|
"Multiple ACTIONS and FILES may be given in arbitrary order.\n"
|
|
"\n"
|
|
"-h, --help show help\n"
|
|
"-H, --longhelp show long help\n"
|
|
"\n"
|
|
"ACTIONS\n"
|
|
" If multiple actions are specified they are executed in given order.\n"
|
|
"\n"
|
|
" -l, --list list all tags (implicit if no action given)\n"
|
|
" -a, --audio show audio properties\n"
|
|
" -e, --erase=TAGNAME erase tag TAGNAME\n"
|
|
" -r, --replace=TAGNAME=TAGVAL replace tag TAGNAME with value TAGVAL\n"
|
|
" -i, --insert=TAGNAME=TAGVAL insert tag TAGNAME with value TAGVAL\n";
|
|
}
|
|
|
|
void printExtraHelp ()
|
|
{
|
|
cout <<
|
|
"\n"
|
|
"TAGNAME\n"
|
|
" TAGNAME is a media format independent id encoding the type of a tag.\n"
|
|
" Note that also in --list output, format specific tag ids are translated\n"
|
|
" to unified TAGNAMES.\n"
|
|
"\n"
|
|
" Some \"well-known\" tags you might want to use are:\n"
|
|
" TITLE ALBUM ARTIST ALBUMARTIST SUBTITLE TRACKNUMBER DISCNUMBER DATE\n"
|
|
" ORIGINALDATE GENRE COMMENT TITLESORT ALBUMSORT ARTISTSORT\n"
|
|
" ALBUMARTISTSORT COMPOSER LYRICIST CONDUCTOR REMIXER PERFORMER ISRC ASIN\n"
|
|
" BPM COPYRIGHT ENCODEDBY MOOD COMMENT MEDIA LABEL CATALOGNUMBER BARCODE\n"
|
|
"\n"
|
|
"TAGVAL\n"
|
|
" TAGVAL has to be either a single string or a list of strings separated\n"
|
|
" by equal signs (=). If a list is given, multiple tags of type TAGNAME\n"
|
|
" will be created and set to the respective values given by the list.\n"
|
|
" Note that equal signs have to be escaped with a leading backslash (\\=),\n"
|
|
" if they shall not be interpreted as list separators.\n"
|
|
"\n"
|
|
"EXAMPLES\n"
|
|
" usetaglib file.ogg\n"
|
|
" usetaglib -e ALBUM file.flac\n"
|
|
" usetaglib -r \"ALBUM=New Album\" -i ARTIST=Horst=Hubert file.mp3\n"
|
|
" usetaglib -r ARTIST=Horst -l file1.ogg file2.mp3\n"
|
|
" usetaglib -i \"ALBUMARTIST=Horst und Hubert\" file.ogg\n"
|
|
" usetaglib --insert=\"ALBUMARTIST=Horst und Hubert\" file.ogg\n"
|
|
" usetaglib --replace='ARTIST=This Band \\= Great' file.ogg\n";
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int c;
|
|
actionqueue requestedActions;
|
|
|
|
while (1)
|
|
{
|
|
static struct option long_options[] =
|
|
{
|
|
{"help", no_argument, 0, 'h'},
|
|
{"longhelp", no_argument, 0, 'H'},
|
|
{"list", no_argument, 0, 'l'},
|
|
{"audio", no_argument, 0, 'a'},
|
|
{"insert", required_argument, 0, 'i'},
|
|
{"erase", required_argument, 0, 'e'},
|
|
{"replace", required_argument, 0, 'r'},
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
int option_index = 0;
|
|
c = getopt_long (argc, argv, "hHlai:e:r:",
|
|
long_options, &option_index);
|
|
|
|
if (c == -1)
|
|
break;
|
|
|
|
switch (c)
|
|
{
|
|
case 0:
|
|
if (long_options[option_index].flag != 0)
|
|
break;
|
|
case 'h':
|
|
printHelp();
|
|
return 0;
|
|
break;
|
|
case 'H':
|
|
printHelp();
|
|
printExtraHelp();
|
|
return 0;
|
|
break;
|
|
case 'l':
|
|
requestedActions.push_back( make_pair(LIST, "") );
|
|
break;
|
|
case 'a':
|
|
requestedActions.push_back( make_pair(AUDIO, "") );
|
|
break;
|
|
case 'i':
|
|
requestedActions.push_back( make_pair(INSERT, optarg) );
|
|
break;
|
|
case 'e':
|
|
requestedActions.push_back( make_pair(ERASE, optarg) );
|
|
break;
|
|
case 'r':
|
|
requestedActions.push_back( make_pair(REPLACE, optarg) );
|
|
break;
|
|
case '?':
|
|
break;
|
|
default:
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
if ( optind == argc ) {
|
|
printHelp();
|
|
return 0;
|
|
}
|
|
|
|
if (requestedActions.size() == 0)
|
|
requestedActions.push_back( make_pair(LIST, "") );
|
|
|
|
for(int i = optind; i < argc; i++) {
|
|
cout << " _________________________________________ _ _ _" << endl;
|
|
cout << "/" << endl;
|
|
cout << " " << argv[i] << endl;
|
|
cout << "\\_________________________________________ _ _ _" << endl;
|
|
|
|
TagLib::FileRef f(argv[i]);
|
|
|
|
if(f.isNull())
|
|
continue;
|
|
|
|
TagLib::PropertyMap propmap = f.file()->properties();
|
|
bool FCHANGED = false;
|
|
|
|
for (actionqueue::iterator actit = requestedActions.begin(); actit != requestedActions.end(); ++actit) {
|
|
switch (actit->first) {
|
|
case LIST:
|
|
action_printTags(f, propmap);
|
|
break;
|
|
case AUDIO:
|
|
action_printAudio(f);
|
|
break;
|
|
case ERASE:
|
|
action_eraseTag(propmap, actit->second);
|
|
FCHANGED = true;
|
|
break;
|
|
case REPLACE:
|
|
action_replaceTag(propmap, toKeyAndValues(actit->second));
|
|
FCHANGED = true;
|
|
break;
|
|
case INSERT:
|
|
action_insertTag(propmap, toKeyAndValues(actit->second));
|
|
FCHANGED = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (FCHANGED) {
|
|
f.file()->setProperties(propmap);
|
|
f.file()->save();
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|