void allocate()
{
metadata.setAllocated(true);
}
void Playlist::savePlaylist(QString a_name, QString a_host)
{
name = a_name.simplified();
if (name.length() < 1)
{
VERBOSE(VB_GENERAL, LOC_WARN +
"Not saving unnamed playlist");
return;
}
if (a_host.length() < 1)
{
VERBOSE(VB_GENERAL, LOC_WARN +
"Not saving playlist without a host name");
return;
}
if (name.length() < 1)
return;
fillSonglistFromSongs();
MSqlQuery query(MSqlQuery::InitCon());
int length = 0, songcount = 0, playtime = 0, an_int;
QStringList list = raw_songlist.split(",", QString::SkipEmptyParts);
QStringList::iterator it = list.begin();
for (; it != list.end(); it++)
{
an_int = QString(*it).toInt();
if (an_int != 0)
{
songcount++;
if (an_int > 0)
{
Metadata *md = all_available_music->getMetadata(an_int);
if (md)
length = md->Length();
}
else
{
query.prepare("SELECT length FROM music_playlists "
"WHERE playlist_id = :ID ;");
an_int *= -1;
query.bindValue(":ID", an_int);
if (query.exec() && query.next())
{
length = query.value(0).toInt();
}
}
playtime += length;
}
}
bool save_host = ("default_playlist_storage" == a_name
|| "backup_playlist_storage" == a_name);
if (playlistid > 0)
{
QString str_query = "UPDATE music_playlists SET "
"playlist_songs = :LIST, "
"playlist_name = :NAME, "
"songcount = :SONGCOUNT, "
"length = :PLAYTIME";
if (save_host)
str_query += ", hostname = :HOSTNAME";
str_query += " WHERE playlist_id = :ID ;";
query.prepare(str_query);
query.bindValue(":ID", playlistid);
}
else
{
QString str_query = "INSERT INTO music_playlists"
" (playlist_name, playlist_songs,"
" songcount, length";
if (save_host)
str_query += ", hostname";
str_query += ") VALUES(:NAME, :LIST, :SONGCOUNT, :PLAYTIME";
if (save_host)
str_query += ", :HOSTNAME";
str_query += ");";
query.prepare(str_query);
}
query.bindValue(":LIST", raw_songlist);
query.bindValue(":NAME", a_name);
query.bindValue(":SONGCOUNT", songcount);
query.bindValue(":PLAYTIME", playtime);
if (save_host)
query.bindValue(":HOSTNAME", a_host);
if (!query.exec() || (playlistid < 1 && query.numRowsAffected() < 1))
{
MythDB::DBError("Problem saving playlist", query);
}
if (playlistid < 1)
playlistid = query.lastInsertId().toInt();
}
// NOTE we don't clear the existing tracks just load any new ones found in the DB
// maybe we should also check for any removed tracks?
void AllMusic::resync()
{
m_done_loading = false;
QString aquery = "SELECT music_songs.song_id, music_artists.artist_id, music_artists.artist_name, "
"music_comp_artists.artist_name AS compilation_artist, "
"music_albums.album_id, music_albums.album_name, music_songs.name, music_genres.genre, music_songs.year, "
"music_songs.track, music_songs.length, music_songs.directory_id, "
"CONCAT_WS('/', music_directories.path, music_songs.filename) AS filename, "
"music_songs.rating, music_songs.numplays, music_songs.lastplay, music_songs.date_entered, "
"music_albums.compilation, music_songs.format, music_songs.track_count "
"FROM music_songs "
"LEFT JOIN music_directories ON music_songs.directory_id=music_directories.directory_id "
"LEFT JOIN music_artists ON music_songs.artist_id=music_artists.artist_id "
"LEFT JOIN music_albums ON music_songs.album_id=music_albums.album_id "
"LEFT JOIN music_artists AS music_comp_artists ON music_albums.artist_id=music_comp_artists.artist_id "
"LEFT JOIN music_genres ON music_songs.genre_id=music_genres.genre_id "
"ORDER BY music_songs.song_id;";
QString filename, artist, album, title, compartist;
MSqlQuery query(MSqlQuery::InitCon());
if (!query.exec(aquery))
MythDB::DBError("AllMusic::resync", query);
m_numPcs = query.size() * 2;
m_numLoaded = 0;
if (query.isActive() && query.size() > 0)
{
while (query.next())
{
int id = query.value(0).toInt();
if (!music_map.contains(id))
{
filename = query.value(12).toString();
Metadata *mdata = new Metadata(
filename,
query.value(2).toString(), // artist
query.value(3).toString(), // compilation artist
query.value(5).toString(), // album
query.value(6).toString(), // title
query.value(7).toString(), // genre
query.value(8).toInt(), // year
query.value(9).toInt(), // track no.
query.value(10).toInt(), // length
query.value(0).toInt(), // id
query.value(13).toInt(), // rating
query.value(14).toInt(), // playcount
query.value(15).toDateTime(), // lastplay
query.value(16).toDateTime(), // date_entered
(query.value(17).toInt() > 0), // compilation
query.value(18).toString()); // format
mdata->setDirectoryId(query.value(11).toInt());
mdata->setArtistId(query.value(1).toInt());
mdata->setAlbumId(query.value(4).toInt());
mdata->setTrackCount(query.value(19).toInt());
// Don't delete mdata, as PtrList now owns it
m_all_music.append(mdata);
music_map[id] = mdata;
}
// compute max/min playcount,lastplay for all music
if (query.at() == 0)
{
// first song
m_playcountMin = m_playcountMax = query.value(13).toInt();
m_lastplayMin = m_lastplayMax = query.value(14).toDateTime().toTime_t();
}
else
{
int playCount = query.value(13).toInt();
double lastPlay = query.value(14).toDateTime().toTime_t();
m_playcountMin = min(playCount, m_playcountMin);
m_playcountMax = max(playCount, m_playcountMax);
m_lastplayMin = min(lastPlay, m_lastplayMin);
m_lastplayMax = max(lastPlay, m_lastplayMax);
}
m_numLoaded++;
}
}
else
{
LOG(VB_GENERAL, LOG_ERR, "MythMusic hasn't found any tracks! "
"That's ok with me if it's ok with you.");
}
m_done_loading = true;
}
int Playlist::CreateCDMP3(void)
{
// Check & get global settings
if (!gCoreContext->GetNumSetting("CDWriterEnabled"))
{
LOG(VB_GENERAL, LOG_ERR, "CD Writer is not enabled.");
return 1;
}
QString scsidev = MediaMonitor::defaultCDWriter();
if (scsidev.isEmpty())
{
LOG(VB_GENERAL, LOG_ERR, "No CD Writer device defined.");
return 1;
}
int disksize = gCoreContext->GetNumSetting("CDDiskSize", 2);
QString writespeed = gCoreContext->GetSetting("CDWriteSpeed", "2");
bool MP3_dir_flag = gCoreContext->GetNumSetting("CDCreateDir", 1);
double size_in_MB = 0.0;
QStringList reclist;
SongList::const_iterator it = songs.begin();
for (; it != songs.end(); ++it)
{
if ((*it)->getCDFlag())
continue;
if ((*it)->getValue() == 0)
{
LOG(VB_GENERAL, LOG_ERR, kID0err);
}
else if ((*it)->getValue() > 0)
{
// Normal track
Metadata *tmpdata =
all_available_music->getMetadata((*it)->getValue());
if (tmpdata)
{
// check filename..
QFileInfo testit(tmpdata->Filename());
if (!testit.exists())
continue;
size_in_MB += testit.size() / 1000000.0;
QString outline;
if (MP3_dir_flag)
{
if (tmpdata->Artist().length() > 0)
outline += tmpdata->Artist() + "/";
if (tmpdata->Album().length() > 0)
outline += tmpdata->Album() + "/";
}
outline += "=";
outline += tmpdata->Filename();
reclist += outline;
}
}
else if ((*it)->getValue() < 0)
{
// FIXME: handle playlists
}
}
int max_size;
if (disksize == 0)
max_size = 650;
else
max_size = 700;
if (size_in_MB >= max_size)
{
LOG(VB_GENERAL, LOG_ERR, "MP3 CD creation aborted -- cd size too big.");
return 1;
}
// probably should tie stdout of mkisofs to stdin of cdrecord sometime
QString tmptemplate("/tmp/mythmusicXXXXXX");
QString tmprecordlist = createTempFile(tmptemplate);
if (tmprecordlist == tmptemplate)
{
LOG(VB_GENERAL, LOG_ERR, "Unable to open temporary file");
return 1;
}
QString tmprecordisofs = createTempFile(tmptemplate);
if (tmprecordisofs == tmptemplate)
{
LOG(VB_GENERAL, LOG_ERR, "Unable to open temporary file");
return 1;
}
QFile reclistfile(tmprecordlist);
if (!reclistfile.open(QIODevice::WriteOnly))
{
LOG(VB_GENERAL, LOG_ERR, "Unable to open temporary file");
return 1;
}
QTextStream recstream(&reclistfile);
QStringList::Iterator iter;
for (iter = reclist.begin(); iter != reclist.end(); ++iter)
{
recstream << *iter << "\n";
}
reclistfile.close();
progress = new MythProgressDialog(QObject::tr("Creating CD File System"),
100);
progress->setProgress(1);
QStringList args;
QString command;
command = "mkisofs";
args << "-graft-points";
args << "-path-list";
args << tmprecordlist;
args << "-o";
args << tmprecordisofs;
args << "-J";
args << "-R";
uint flags = kMSRunShell | kMSStdErr | kMSBuffered |
kMSDontDisableDrawing | kMSDontBlockInputDevs |
kMSRunBackground;
proc = new MythSystem(command, args, flags);
connect(proc, SIGNAL(readDataReady(int)), this, SLOT(mkisofsData(int)),
Qt::DirectConnection);
connect(proc, SIGNAL(finished()), this, SLOT(processExit()),
Qt::DirectConnection);
connect(proc, SIGNAL(error(uint)), this, SLOT(processExit(uint)),
Qt::DirectConnection);
procExitVal = GENERIC_EXIT_RUNNING;
proc->Run();
while( procExitVal == GENERIC_EXIT_RUNNING )
usleep( 100000 );
uint retval = procExitVal;
progress->Close();
progress->deleteLater();
proc->disconnect();
delete proc;
if (retval)
{
LOG(VB_GENERAL, LOG_ERR, QString("Unable to run mkisofs: returns %1")
.arg(retval));
}
else
{
progress = new MythProgressDialog(QObject::tr("Burning CD"), 100);
progress->setProgress(2);
command = "cdrecord";
args = QStringList();
args << "-v";
//args << "-dummy";
args << QString("dev=%1").arg(scsidev);
if (writespeed.toInt() > 0)
{
args << "-speed=";
args << writespeed;
}
args << "-data";
args << tmprecordisofs;
flags = kMSRunShell | kMSStdErr | kMSStdOut | kMSBuffered |
kMSDontDisableDrawing | kMSDontBlockInputDevs |
kMSRunBackground;
proc = new MythSystem(command, args, flags);
connect(proc, SIGNAL(readDataReady(int)),
this, SLOT(cdrecordData(int)), Qt::DirectConnection);
connect(proc, SIGNAL(finished()),
this, SLOT(processExit()), Qt::DirectConnection);
connect(proc, SIGNAL(error(uint)),
this, SLOT(processExit(uint)), Qt::DirectConnection);
procExitVal = GENERIC_EXIT_RUNNING;
proc->Run();
while( procExitVal == GENERIC_EXIT_RUNNING )
usleep( 100000 );
retval = procExitVal;
progress->Close();
progress->deleteLater();
proc->disconnect();
delete proc;
if (retval)
{
LOG(VB_GENERAL, LOG_ERR,
QString("Unable to run cdrecord: returns %1") .arg(retval));
}
}
QFile::remove(tmprecordlist);
QFile::remove(tmprecordisofs);
return retval;
}
void RequestThread::run(threaded_process_status &p_status, abort_callback &p_abort) {
Metadata *metadata = nullptr;
try {
metadata = query->perform(p_abort);
// Extracting releases from 3 possible locations
// /metadata/release
if (auto release = metadata->extract_release()) {
mbc->add(release);
// /metadata/discid/release-list/release
} else if (auto discid = metadata->get_discid()) {
if (auto release_list = discid->get_release_list()) {
auto id = discid->get_id();
auto count = release_list->count();
for (size_t i = 0; i < count; i++) {
auto release = release_list->extract(0);
// FIXME: this is incorrect, as only one of the discs has
// this discid, but it won't affect anyone (release must
// have two or more discs with the same amount of tracks,
// and user must choose the wrong one). Will be fixed when
// web service adds support for inc=discids param.
for (size_t i = 0; i < release->medium_count(); i++) {
release->get_medium(i)->set_discid(id);
}
mbc->add(release);
}
}
// /metadata/release-list/release
} else if (auto release_list = metadata->get_release_list()) {
auto count = release_list->count();
for (size_t i = 0; i < count; i++) {
release = release_list->get(i);
// Progress and title
p_status.set_progress(i + 1, count + 1);
pfc::string8 title = "Fetching: ";
title << release->get_artist_credit()->get_name() << " - " << release->get_title();
auto date = release->get_date();
if (date.get_year() != 0) {
title << " (" << static_cast<pfc::string8>(date) << ")";
}
p_status.set_title(title);
Query query("release", release->get_id());
query.add_param("inc", "artists+labels+recordings+release-groups+artist-credits", false);
auto release = query.perform(p_abort)->extract_release();
if (release != nullptr) {
mbc->add(release);
}
}
}
// Removing discs from multidisc releases with different track count
auto track_count = tracks->get_count();
for (size_t i = 0; i < mbc->count(); i++) {
auto release = mbc->get(i);
if (release->track_count() == track_count) continue;
for (size_t j = 0; j < release->medium_count(); j++) {
if (release->get_medium(j)->track_count() != track_count) {
release->remove_medium(j);
j--;
}
}
if (release->medium_count() == 0) {
mbc->remove(i);
i--;
}
}
if (mbc->count() == 0) {
throw NotFound();
}
MetadataProcessor::apply_all(*mbc);
mbc->sort();
ShowWindow(window, SW_SHOW);
} catch (GenericException e) {
PostMessage(window, WM_CLOSE, 0, 0);
popup_message::g_show(e.what(), COMPONENT_TITLE, popup_message::icon_error);
} catch (...) {
PostMessage(window, WM_CLOSE, 0, 0);
delete metadata;
delete query;
throw;
}
delete metadata;
delete query;
}
//virtual
Metadata *CdDecoder::getMetadata()
{
QString artist, album, compilation_artist, title, genre;
int year = 0;
unsigned long length = 0;
track_t tracknum = 0;
if (-1 == m_settracknum)
tracknum = getFilename().toUInt();
else
{
tracknum = m_settracknum;
setFilename(QString("%1" CDEXT).arg(tracknum));
}
QMutexLocker lock(&getCdioMutex());
StCdioDevice cdio(m_devicename);
if (!cdio)
return NULL;
const track_t lastTrack = cdio_get_last_track_num(cdio);
if (CDIO_INVALID_TRACK == lastTrack)
return NULL;
if (TRACK_FORMAT_AUDIO != cdio_get_track_format(cdio, tracknum))
return NULL;
// Assume disc changed if max LSN different
bool isDiscChanged = false;
static lsn_t s_totalSectors;
lsn_t totalSectors = cdio_get_track_lsn(cdio, CDIO_CDROM_LEADOUT_TRACK);
if (s_totalSectors != totalSectors)
{
s_totalSectors = totalSectors;
isDiscChanged = true;
}
// NB cdio_get_track_last_lsn is unreliable for the last audio track
// of discs with data tracks beyond
lsn_t end = cdio_get_track_last_lsn(cdio, tracknum);
if (isDiscChanged)
{
const track_t audioTracks = getNumCDAudioTracks();
s_lastAudioLsn = cdio_get_track_last_lsn(cdio, audioTracks);
if (audioTracks < lastTrack)
{
cdrom_drive_t *dev = cdio_cddap_identify_cdio(cdio, 0, NULL);
if (NULL != dev)
{
if (DRIVER_OP_SUCCESS == cdio_cddap_open(dev))
{
// NB this can be S L O W but is reliable
lsn_t end2 = cdio_cddap_track_lastsector(dev,
getNumCDAudioTracks());
if (CDIO_INVALID_LSN != end2)
s_lastAudioLsn = end2;
}
cdio_cddap_close_no_free_cdio(dev);
}
}
}
if (s_lastAudioLsn && s_lastAudioLsn < end)
end = s_lastAudioLsn;
const lsn_t start = cdio_get_track_lsn(cdio, tracknum);
if (CDIO_INVALID_LSN != start && CDIO_INVALID_LSN != end)
{
length = ((end - start + 1) * 1000 + CDIO_CD_FRAMES_PER_SEC/2) /
CDIO_CD_FRAMES_PER_SEC;
}
bool isCompilation = false;
#define CDTEXT 0 // Disabled - cd-text access on discs without it is S L O W
#if CDTEXT
static int s_iCdtext;
if (isDiscChanged)
s_iCdtext = -1;
if (s_iCdtext)
{
// cdio_get_cdtext can't take >5 seconds on some CD's without cdtext
if (s_iCdtext < 0)
LOG(VB_MEDIA, LOG_INFO,
QString("Getting cdtext for track %1...").arg(tracknum));
cdtext_t * cdtext = cdio_get_cdtext(m_cdio, tracknum);
if (NULL != cdtext)
{
genre = cdtext_get_const(CDTEXT_GENRE, cdtext);
artist = cdtext_get_const(CDTEXT_PERFORMER, cdtext);
title = cdtext_get_const(CDTEXT_TITLE, cdtext);
const char* isrc = cdtext_get_const(CDTEXT_ISRC, cdtext);
/* ISRC codes are 12 characters long, in the form CCXXXYYNNNNN
* CC = country code
* XXX = registrant e.g. BMG
* CC = year withou century
* NNNNN = unique ID
*/
if (isrc && strlen(isrc) >= 7)
{
year = (isrc[5] - '0') * 10 + (isrc[6] - '0');
year += (year <= 30) ? 2000 : 1900;
}
cdtext_destroy(cdtext);
if (!title.isNull())
{
if (s_iCdtext < 0)
LOG(VB_MEDIA, LOG_INFO, "Found cdtext track title");
s_iCdtext = 1;
// Get disc info
cdtext = cdio_get_cdtext(cdio, 0);
if (NULL != cdtext)
{
compilation_artist = cdtext_get_const(
CDTEXT_PERFORMER, cdtext);
if (!compilation_artist.isEmpty() &&
artist != compilation_artist)
isCompilation = true;
album = cdtext_get_const(CDTEXT_TITLE, cdtext);
if (genre.isNull())
genre = cdtext_get_const(CDTEXT_GENRE, cdtext);
cdtext_destroy(cdtext);
}
}
else
{
if (s_iCdtext < 0)
LOG(VB_MEDIA, LOG_INFO, "No cdtext title for track");
s_iCdtext = 0;
}
}
else
{
if (s_iCdtext < 0)
LOG(VB_MEDIA, LOG_INFO, "No cdtext");
s_iCdtext = 0;
}
}
if (title.isEmpty() || artist.isEmpty() || album.isEmpty())
#endif // CDTEXT
{
// CDDB lookup
Cddb::Toc toc;
Cddb::Matches r;
if (Cddb::Query(r, GetToc(cdio, toc)))
{
Cddb::Matches::match_t::const_iterator select = r.matches.begin();
if (r.matches.size() > 1)
{
// TODO prompt user to select one
// In the meantime, select the first non-generic genre
for (Cddb::Matches::match_t::const_iterator it = select;
it != r.matches.end(); ++it)
{
QString g = it->genre.toLower();
if (g != "misc" && g != "data")
{
select = it;
break;
}
}
}
Cddb::Album info;
if (Cddb::Read(info, select->genre, select->discID))
{
isCompilation = info.isCompilation;
if (info.genre.toLower() != "misc")
genre = info.genre;
album = info.title;
compilation_artist = info.artist;
year = info.year;
if (info.tracks.size() >= tracknum)
{
const Cddb::Track& track = info.tracks[tracknum - 1];
title = track.title;
artist = track.artist;
}
// Create a temporary local alias for future lookups
if (r.discID != info.discID)
Cddb::Alias(info, r.discID);
}
}
}
if (compilation_artist.toLower().left(7) == "various")
compilation_artist = QObject::tr("Various Artists");
if (artist.isEmpty())
{
artist = compilation_artist;
compilation_artist.clear();
}
if (title.isEmpty())
title = QObject::tr("Track %1").arg(tracknum);
Metadata *m = new Metadata(getFilename(), artist, compilation_artist,
album, title, genre, year, tracknum, length);
if (m)
m->setCompilation(isCompilation);
return m;
}
void SearchView::updateTracksList(void)
{
m_tracksList->Reset();
MythUIButtonListItem *item = m_fieldList->GetItemCurrent();
if (!item)
return;
QString searchStr = m_criteriaEdit->GetText();
int field = item->GetData().toInt();
QString sql;
MSqlQuery query(MSqlQuery::InitCon());
if (searchStr.isEmpty())
{
sql = "SELECT song_id "
"FROM music_songs ";
query.prepare(sql);
}
else
{
switch(field)
{
case 1: // artist
{
sql = "SELECT song_id "
"FROM music_songs "
"LEFT JOIN music_artists ON "
" music_songs.artist_id=music_artists.artist_id "
"WHERE music_artists.artist_name LIKE '%" + searchStr + "%' ";
query.prepare(sql);
break;
}
case 2: // album
{
sql = "SELECT song_id "
"FROM music_songs "
"LEFT JOIN music_albums ON music_songs.album_id=music_albums.album_id "
"WHERE music_albums.album_name LIKE '%" + searchStr + "%' ";
query.prepare(sql);
break;
}
case 3: // title
{
sql = "SELECT song_id "
"FROM music_songs "
"WHERE music_songs.name LIKE '%" + searchStr + "%' ";
query.prepare(sql);
break;
}
case 4: // genre
{
sql = "SELECT song_id "
"FROM music_songs "
"LEFT JOIN music_genres ON music_songs.genre_id=music_genres.genre_id "
"WHERE music_genres.genre LIKE '%" + searchStr + "%' ";
query.prepare(sql);
break;
}
case 5: // tags
{
//TODO add tag query
}
case 0: // all fields
default:
{
sql = "SELECT song_id "
"FROM music_songs "
"LEFT JOIN music_artists ON "
" music_songs.artist_id=music_artists.artist_id "
"LEFT JOIN music_albums ON music_songs.album_id=music_albums.album_id "
"LEFT JOIN music_artists AS music_comp_artists ON "
" music_albums.artist_id=music_comp_artists.artist_id "
"LEFT JOIN music_genres ON music_songs.genre_id=music_genres.genre_id "
"WHERE music_songs.name LIKE '%" + searchStr + "%' "
"OR music_artists.artist_name LIKE '%" + searchStr + "%' "
"OR music_albums.album_name LIKE '%" + searchStr + "%' "
"OR music_genres.genre LIKE '%" + searchStr + "%' ";
query.prepare(sql);
}
}
}
if (!query.exec() || !query.isActive())
{
MythDB::DBError("Search music database", query);
return;
}
while (query.next())
{
int trackid = query.value(0).toInt();
Metadata *mdata = gMusicData->all_music->getMetadata(trackid);
if (mdata)
{
MythUIButtonListItem *newitem = new MythUIButtonListItem(m_tracksList, "");
newitem->SetData(qVariantFromValue(mdata));
MetadataMap metadataMap;
mdata->toMap(metadataMap);
newitem->SetTextFromMap(metadataMap);
if (gPlayer->getPlaylist()->checkTrack(mdata->ID()))
newitem->DisplayState("on", "selectedstate");
else
newitem->DisplayState("off", "selectedstate");
// TODO rating state etc
}
}
trackVisible(m_tracksList->GetItemCurrent());
if (m_matchesText)
m_matchesText->SetText(QString("%1").arg(m_tracksList->GetCount()));
}
// CBMEN, HL, Begin
void
CacheStrategyUtility::_handleGetCacheStrategyAsMetadata(Metadata *m)
{
Metadata *dm = m->addMetadata("CacheStrategyUtility");
if (!dm) {
return;
}
dm->setParameter("knapsack_optimizer", getKnapsackOptimizer()->getName());
dm->setParameter("global_optimizer", getGlobalOptimizer()->getPrettyName());
dm->setParameter("utility_function", getUtilityFunction()->getPrettyName());
dm->setParameter("utility_compute_period_ms", computePeriodMs);
dm->setParameter("poll_period_ms", pollPeriodMs);
dm->setParameter("event_based_purging", purgeOnInsert ? "enabled" : "disabled");
dm->setParameter("keep_in_bloomfilter", keep_in_bloomfilter ? "enabled" : "disabled");
dm->setParameter("bloomfilter_remove_delay_ms", bloomfilter_remove_delay_ms);
dm->setParameter("handle_zero_size", handle_zero_size ? "enabled" : "disabled");
dm->setParameter("manage_only_remote_files", manage_only_remote_files ? "enabled" : "disabled");
dm->setParameter("manage_locally_sent_files", manage_locally_sent_files ? "enabled" : "disabled");
dm->setParameter("allow_db_purging", allow_db_purging ? "enabled" : "disabled");
dm->setParameter("db_size_threshold", db_size_threshold);
dm->setParameter("current_size_kb", current_size / (long long) 1024);
dm->setParameter("max_capacity_kb", max_capacity_kb);
dm->setParameter("current_capacity_ratio", 100*current_size/((double)max_capacity_kb * 1024));
dm->setParameter("watermark_capacity_kb", watermark_capacity_kb);
dm->setParameter("watermark_capacity_ratio", 100*current_size/((double)watermark_capacity_kb * 1024));
dm->setParameter("current_num_do", current_num_do);
dm->setParameter("total_db_evicted", total_db_evicted);
dm->setParameter("current_dupe_do_recv", current_dupe_do_recv);
dm->setParameter("current_drop_on_insert", current_drop_on_insert);
dm->setParameter("total_do_inserted", total_do_inserted);
dm->setParameter("total_do_inserted_bytes", total_do_inserted_bytes);
dm->setParameter("total_do_evicted", total_do_evicted);
dm->setParameter("total_do_evicted_bytes", total_do_evicted_bytes);
dm->setParameter("total_do_hard_evicted", total_do_hard_evicted);
dm->setParameter("total_do_hard_evicted_bytes", total_do_hard_evicted_bytes);
PrintHelperHeapItem::PrinterHelperType_t types[] = {PrintHelperHeapItem::HIGH_UTIL, PrintHelperHeapItem::LOW_UTIL, PrintHelperHeapItem::HIGH_COST, PrintHelperHeapItem::OLD_CREATION};
string names[] = {"Top10Utility", "Bottom10Utility", "Top10Largest", "Top10Oldest"};
do_util_metadata_list_t metadata_list;
for (size_t i = 0; i < 4; i++)
{
Metadata *dmm = dm->addMetadata(names[i]);
if (!dmm) {
continue;
}
PrintHelperHeapItem::getTopKHelper(10, types[i], utilMetadata, &metadata_list);
for (do_util_metadata_list_t::iterator it = metadata_list.begin(); it != metadata_list.end(); it++) {
Metadata *dmmm = dmm->addMetadata("DataObject");
if (!dmmm) {
break;
}
DataObjectUtilityMetadata *do_metadata = *it;
dmmm->setParameter("id", do_metadata->getId());
dmmm->setParameter("create_time", do_metadata->getCreateTime().getAsString());
dmmm->setParameter("computed_time", do_metadata->getComputedTime().getAsString());
dmmm->setParameter("cost", do_metadata->getCost());
dmmm->setParameter("utility", do_metadata->getUtility());
}
metadata_list.clear();
}
kernel->addEvent(new Event(EVENT_TYPE_SEND_OBSERVER_DATAOBJECT, m->copy()));
}
void
CacheStrategyUtility::_onConfig(
const Metadata& m)
{
const char *param;
const Metadata *dm;
if (m.getName() != getName()) {
HAGGLE_ERR("Wrong config.\n");
return;
}
// load knapsack optimizer
param = m.getParameter("knapsack_optimizer");
if (!param) {
HAGGLE_DBG("No knapsack optimizer specified, using default.\n");
ksOptimizer = CacheKnapsackOptimizerFactory::getNewKnapsackOptimizer(getManager()->getKernel());
}
else {
ksOptimizer = CacheKnapsackOptimizerFactory::getNewKnapsackOptimizer(getManager()->getKernel(), param);
}
if (!ksOptimizer) {
HAGGLE_ERR("Could not initialize knapsack optimizer.\n");
return;
}
dm = m.getMetadata(param);
if (dm) {
ksOptimizer->onConfig(*dm);
}
// load global optimizer
param = m.getParameter("global_optimizer");
if (!param) {
HAGGLE_DBG("No specified, using default.\n");
globalOptimizer = CacheGlobalOptimizerFactory::getNewGlobalOptimizer(getManager()->getKernel());
}
else {
globalOptimizer = CacheGlobalOptimizerFactory::getNewGlobalOptimizer(getManager()->getKernel(), param);
}
if (!globalOptimizer) {
HAGGLE_ERR("Could not initialize global optimizer.\n");
return;
}
dm = m.getMetadata(param);
if (dm) {
globalOptimizer->onConfig(*dm);
}
// load utility function
param = m.getParameter("utility_function");
if (!param) {
HAGGLE_DBG("No utility function specified, using default.\n");
utilFunction = CacheUtilityFunctionFactory::getNewUtilityFunction(getManager(), globalOptimizer);
}
else {
utilFunction = CacheUtilityFunctionFactory::getNewUtilityFunction(getManager(), globalOptimizer, param);
}
if (!utilFunction) {
HAGGLE_ERR("Could not initialize utility function.\n");
return;
}
dm = m.getMetadata(param);
if (dm) {
utilFunction->onConfig(*dm);
}
param = m.getParameter("max_capacity_kb");
if (!param) {
HAGGLE_ERR("No maximum capacity specified\n");
return;
}
max_capacity_kb = atoi(param);
if (max_capacity_kb < 0) {
HAGGLE_ERR("Invalid max capacity.\n");
return;
}
param = m.getParameter("watermark_capacity_kb");
if (!param) {
HAGGLE_ERR("No watermark capacity specified\n");
return;
}
watermark_capacity_kb = atoi(param);
if ((watermark_capacity_kb < 0) || (watermark_capacity_kb > max_capacity_kb)) {
HAGGLE_ERR("Invalid watermark capacity.\n");
return;
}
param = m.getParameter("compute_period_ms");
if (param) {
computePeriodMs = atoi(param);
}
if (computePeriodMs < 0) {
HAGGLE_ERR("Invalid compute period.\n");
return;
}
param = m.getParameter("purge_poll_period_ms");
if (param) {
pollPeriodMs = atoi(param);
}
if (pollPeriodMs < 0) {
HAGGLE_ERR("Invalid poll period.\n");
return;
}
param = m.getParameter("purge_on_insert");
if (param) {
purgeOnInsert = (0 == strcmp("true", param));
}
param = m.getParameter("manage_only_remote_files");
if (param) {
manage_only_remote_files = (0 == strcmp("true", param));
}
param = m.getParameter("manage_locally_sent_files");
if (param) {
manage_locally_sent_files = (0 == strcmp("true", param));
}
param = m.getParameter("publish_stats_dataobject");
if (param) {
publish_stats_dataobject = (0 == strcmp("true", param));
}
param = m.getParameter("keep_in_bloomfilter");
if (param) {
keep_in_bloomfilter = (0 == strcmp("true", param));
}
param = m.getParameter("handle_zero_size");
if (param) {
handle_zero_size = (0 == strcmp("true", param));
}
//JM: START DB
param = m.getParameter("manage_db_purging");
if (param) {
allow_db_purging = (0 == strcmp("true", param));
}
param = m.getParameter("db_size_threshold");
if (param) {
db_size_threshold = atoll(param);
}
param = m.getParameter("self_benchmark_test");
if (param) {
self_test = (0 == strcmp("true", param));
}
//JM: END
param = m.getParameter("bloomfilter_remove_delay_ms");
if (param) {
bloomfilter_remove_delay_ms = atoi(param);
}
// SW: START: remove from local bloomfilter.
if (bloomfilter_remove_delay_ms >= 0) {
bloomfilterRemoveDelayEventType = registerEventType("BFRemoveDelay", onBloomfilterRemoveDelay);
if (bloomfilterRemoveDelayEventType <= 0) {
HAGGLE_ERR("Could not register bloomfilter remove delay event.\n");
}
}
//SW: END: remove from local bloomfilter.
if (publish_stats_dataobject) {
CacheReplacementTotalOrder *replacement =
new CacheReplacementTotalOrder(
getManager(),
"Timestamp",
"PublisherID",
"CacheStrategyUtility",
"stats");
// only keep the most up to date stats in the data base
stats_replacement_strat =
new CacheStrategyReplacementPurger(
getManager(),
replacement,
NULL,
false);
if (!stats_replacement_strat) {
HAGGLE_ERR("Could not allocate replacement strat\n");
}
else {
stats_replacement_strat->start();
}
}
periodicPurgeEventType = registerEventType("periodic purge event", onPeriodicEvent);
periodicPurgeEvent = new Event(periodicPurgeEventType);
// we re-use the event
periodicPurgeEvent->setAutoDelete(false);
firePeriodic();
if (!purgeOnInsert && (pollPeriodMs <= 0)) {
HAGGLE_DBG("WARNING: All purging is disabled, was this intended?\n");
}
// add debug printing
HAGGLE_DBG("Successfully initialized utiltiy cache strategy, knapsack optimizer: %s, global optimizer: %s, utiltiy function: %s, max capacity kb: %lld, watermark capacity kb: %lld, compute period ms: %d, purge poll period ms: %d, purge on insert; %s, manage only remote files: %s, publish stats dataobject: %s, db_purge: %s (%lld), self test:%s \n", getKnapsackOptimizer()->getName().c_str(), getGlobalOptimizer()->getName().c_str(), getUtilityFunction()->getName().c_str(), max_capacity_kb, watermark_capacity_kb, computePeriodMs, pollPeriodMs, purgeOnInsert ? "yes" : "no", manage_only_remote_files ? "yes" : "no", publish_stats_dataobject ? "yes (CacheStrategyUtility=stats)" : "no", allow_db_purging ? "yes" : "no", db_size_threshold, self_test ? "yes" : "no");
}
void setLength(size_t amount)
{
metadata.setLength(amount);
}
void DataManager::onConfig(Metadata *m)
{
bool agingHasChanged = false;
const char *param = m->getParameter("set_createtime_on_bloomfilter_update");
if (param) {
if (strcmp(param, "true") == 0) {
setCreateTimeOnBloomfilterUpdate = true;
HAGGLE_DBG("setCreateTimeOnBloomfilterUpdate set to 'true'\n");
}
else if (strcmp(param, "false") == 0) {
setCreateTimeOnBloomfilterUpdate = false;
HAGGLE_DBG("setCreateTimeOnBloomfilterUpdate set to 'false'\n");
}
}
// MOS
param = m->getParameter("periodic_bloomfilter_update_interval");
if (param) {
char *endptr = NULL;
unsigned long period = strtoul(param, &endptr, 10);
if (endptr && endptr != param) {
if (periodicBloomfilterUpdateInterval == 0 &&
period > 0 &&
!periodicBloomfilterUpdateEvent->isScheduled()) {
kernel->addEvent(new Event(periodicBloomfilterUpdateCallback, NULL));
}
periodicBloomfilterUpdateInterval = period;
HAGGLE_DBG("periodic_bloomfilter_update_interval=%lu\n",
periodicBloomfilterUpdateInterval);
}
}
// MOS - experimental setting
param = m->getParameter("node_desc_update_on_reception");
if (param) {
if (strcmp(param, "true") == 0) {
isNodeDescUpdateOnReceptionEnabled = true;
HAGGLE_DBG("node_desc_update_on_reception set to 'true'\n");
}
else if (strcmp(param, "false") == 0) {
isNodeDescUpdateOnReceptionEnabled = false;
HAGGLE_DBG("node_desc_update_on_reception set to 'false'\n");
}
}
Metadata *dm = m->getMetadata("Bloomfilter");
if (dm) {
bool reset_bloomfilter = false;
const char *param = dm->getParameter("default_error_rate");
if (param) {
char *endptr = NULL;
double error_rate = strtod(param, &endptr);
if (endptr && endptr != param) {
Bloomfilter::setDefaultErrorRate(error_rate);
HAGGLE_DBG("config default bloomfilter error rate %.3lf\n",
Bloomfilter::getDefaultErrorRate());
reset_bloomfilter = true;
}
}
param = dm->getParameter("default_capacity");
if (param) {
char *endptr = NULL;
unsigned int capacity = (unsigned int)strtoul(param, &endptr, 10);
if (endptr && endptr != param) {
Bloomfilter::setDefaultCapacity(capacity);
HAGGLE_DBG("config default bloomfilter capacity %u\n",
Bloomfilter::getDefaultCapacity());
reset_bloomfilter = true;
}
}
if (reset_bloomfilter) {
if (localBF)
delete localBF;
localBF = Bloomfilter::create(Bloomfilter::TYPE_COUNTING);
if (!localBF) {
HAGGLE_ERR("Could not create data manager bloomfilter\n");
}
}
}
// Database timeout configuration
// Set default to 1.5 sec
max_wait.tv_sec = 1;
max_wait.tv_usec = 500000;
// Set default to true
setDropNewObjectWhenDatabaseTimeout = true;
dm = m->getMetadata("DatabaseTimeout");
if (dm) {
param = dm->getParameter("database_timeout_ms");
if (param) {
char *endptr = NULL;
unsigned long timeout = strtoul(param, &endptr, 10);
if (endptr && endptr != param) {
HAGGLE_DBG("database_timeout_ms=%lu\n", timeout);
max_wait.tv_sec = (timeout / 1000);
max_wait.tv_usec = 1000 * (timeout - (max_wait.tv_sec * 1000));
}
}
param = dm->getParameter("drop_new_object_when_database_timeout");
if (param) {
if (0 == (strcmp(param, "true"))) {
setDropNewObjectWhenDatabaseTimeout = true;
} else if (0 == (strcmp(param, "false"))) {
setDropNewObjectWhenDatabaseTimeout = false;
} else {
HAGGLE_ERR("Unknown parameter for drop_new_object_when_database_timeout, need `true` or `false`.\n");
}
}
}
HAGGLE_DBG("Database timeout max_wait.tv_sec=%lu\n", max_wait.tv_sec);
HAGGLE_DBG("Database timeout max_wait.tv_usec=%lu\n", max_wait.tv_usec);
if (setDropNewObjectWhenDatabaseTimeout) {
HAGGLE_DBG("drop_new_object_when_database_timeout=true\n");
} else {
HAGGLE_DBG("drop_new_object_when_database_timeout=false\n");
}
//
dm = m->getMetadata("Aging");
if (dm) {
const char *param = dm->getParameter("period");
if (param) {
char *endptr = NULL;
unsigned long period = strtoul(param, &endptr, 10);
if (endptr && endptr != param) {
agingPeriod = period;
HAGGLE_DBG("config agingPeriod=%lu\n", agingPeriod);
LOG_ADD("# %s: agingPeriod=%lu\n", getName(), agingPeriod);
agingHasChanged = true;
}
}
param = dm->getParameter("max_age");
if (param) {
char *endptr = NULL;
unsigned long period = strtoul(param, &endptr, 10);
if (endptr && endptr != param) {
agingMaxAge = period;
HAGGLE_DBG("config agingMaxAge=%lu\n", agingMaxAge);
LOG_ADD("# %s: agingMaxAge=%lu\n", getName(), agingMaxAge);
agingHasChanged = true;
}
}
param = dm->getParameter("keep_in_bloomfilter");
if (param) {
if (strcmp(param, "true") == 0) {
HAGGLE_DBG("config aging: keep_in_bloomfilter=true\n");
LOG_ADD("# %s: aging: keep_in_bloomfilter=true\n", getName());
keepInBloomfilterOnAging = true;
} else if (strcmp(param, "false") == 0) {
HAGGLE_DBG("config aging: keep_in_bloomfilter=false\n");
LOG_ADD("# %s: aging: keep_in_bloomfilter=false\n", getName());
keepInBloomfilterOnAging = false;
}
}
}
if (agingHasChanged)
onAging(NULL);
// SW: JLM: START CACHE STRATEGY:
dm = m->getMetadata("CacheStrategy");
if (dm) {
param = dm->getParameter("name");
CacheStrategy *_cacheStrategy =
CacheStrategyFactory::getNewCacheStrategy(this, param);
dm = dm->getMetadata(param);
if (dm && _cacheStrategy) {
_cacheStrategy->onConfig(*dm);
_cacheStrategy->start();
HAGGLE_DBG("Loaded cache strategy: %s\n", _cacheStrategy->getName());
}
setCacheStrategy(_cacheStrategy);
}
// SW: JLM: END CACHE STRATEGY.
// SW: START: config.xml options to DataStore:
dm = m->getMetadata("DataStore");
if (dm) {
kernel->getDataStore()->onConfig(dm);
}
}
bool isAllocated() const
{
return metadata.isAllocated();
}
std::size_t getLength() const
{
return metadata.getLength();
}
void deallocate()
{
metadata.setAllocated(false);
}
int CoreCallback::InsertImage(const MM::Device* caller, const unsigned char* buf, unsigned width, unsigned height, unsigned byteDepth, const char* serializedMetadata, const bool doProcess)
{
Metadata md;
md.Restore(serializedMetadata);
return InsertImage(caller, buf, width, height, byteDepth, &md, doProcess);
}
void PosixUtils::metadataToPosixMode ( const Metadata& md, mode_t& mode )
{
mode = 0;
if ( md.type() == Metadata::File || md.type() == Metadata::KeyValueFile )
mode |= S_IFREG;
else if ( md.type() == Metadata::Directory )
mode |= S_IFDIR;
else if ( md.type() == Metadata::Symlink )
mode |= S_IFLNK;
if ( md.modes().user().read() )
mode |= S_IRUSR;
if ( md.modes().user().write() )
mode |= S_IWUSR;
if ( md.modes().user().execute() )
mode |= S_IXUSR;
if ( md.modes().group().read() )
mode |= S_IRGRP;
if ( md.modes().group().write() )
mode |= S_IWGRP;
if ( md.modes().group().execute() )
mode |= S_IXGRP;
if ( md.modes().other().read() )
mode |= S_IROTH;
if ( md.modes().other().write() )
mode |= S_IWOTH;
if ( md.modes().other().execute() )
mode |= S_IXOTH;
}
/**
* Lookup FreeDB/CDDB, populate m_mData with results
*/
void CdDecoder::lookupCDDB(const QString &hexID, uint totalTracks)
{
QString helloID = getenv("USER");
QString queryID = "cddb+query+";
uint trk;
if (helloID.isEmpty())
helloID = "anon";
helloID += QString("+%1+MythTV+%2+")
.arg(gCoreContext->GetHostName()).arg(MYTH_BINARY_VERSION);
queryID += QString("%1+%2+").arg(hexID).arg(totalTracks);
for (trk = 0; trk < totalTracks; ++trk)
queryID += QString::number(m_tracks[trk]) + '+';
queryID += QString::number(m_lengthInSecs);
// First, try HTTP:
QString URL = "http://freedb.freedb.org/~cddb/cddb.cgi?cmd=";
QString URL2 = URL + queryID + "&hello=" + helloID + "&proto=5";
QString cddb = HttpComms::getHttp(URL2);
#if 0
LOG(VB_MEDIA, LOG_INFO, "CDDB lookup: " + URL2);
LOG(VB_MEDIA, LOG_INFO, "...returned: " + cddb);
#endif
//
// e.g. "200 rock 960b5e0c Nichole Nordeman / Woven & Spun"
// Extract/remove 3 digit status:
uint stat = cddb.left(3).toUInt();
cddb = cddb.mid(4);
// We should check for errors here, and possibly do a CDDB lookup
// (telnet 8880) if it failed, but Nigel is feeling lazy.
if (stat == 210 || stat == 211) // Multiple matches
{
// e.g. 210 Found exact matches, list follows (until terminating `.')
// folk 9c09590b Michael W Smith / Stand
// misc 9c09590b Michael W. Smith / Stand
// rock 9c09590b Michael W. Smith / Stand
// classical 9c09590b Michael W. Smith / Stand
// .
// TODO
// Parse disks, put up dialog box, select disk, prune cddb to selected
LOG(VB_MEDIA, LOG_INFO,
"Multiple CDDB matches. Please implement this code");
// For now, we just choose the first match.
//int EOL = cddb.indexOf('\n');
cddb.remove(0, cddb.indexOf('\n'));
LOG(VB_MEDIA, LOG_INFO, "String now: " + cddb);
stat = 200;
}
if (stat == 200) // One unique match
{
QString album;
QString artist;
bool compn = false;
QString genre = cddb.section(' ', 0, 0);
int year = 0;
// Now we can lookup all its details:
URL2 = URL + "cddb+read+" + genre + "+"
+ hexID + "&hello=" + helloID + "&proto=5";
cddb = HttpComms::getHttp(URL2);
#if 0
LOG(VB_MEDIA, LOG_INFO, "CDDB detail: " + URL2);
LOG(VB_MEDIA, LOG_INFO, "...returned: " + cddb);
#endif
// Successful lookup.
// Clear current titles (filenames), because we append to them
for (trk = 0; trk < totalTracks; ++trk)
m_mData[trk]->setTitle("");
// Parse returned data:
cddb.replace(QRegExp(".*#"), ""); // Remove comment block
while (cddb.length())
{
// Lines should be of the form "FIELD=value\r\n"
QString art;
QString line = cddb.section(QRegExp("(\r|\n)+"), 0, 0);
QString value = line.section('=', 1, 1);
if (value.contains(" / "))
{
art = value.section(" / ", 0, 0); // Artist in *TITLE
value = value.section(" / ", 1, 1);
}
if (line.startsWith("DGENRE="))
genre = value;
else if (line.startsWith("DYEAR="))
year = value.toInt();
else if (line.startsWith("DTITLE="))
{
// Albums (and maybe artists?) can wrap over multiple lines:
artist += art;
album += value;
}
else if (line.startsWith("TTITLE"))
{
trk = line.remove("TTITLE").remove(QRegExp("=.*")).toUInt();
if (trk < totalTracks)
{
Metadata *m = m_mData[trk];
// Titles can wrap over multiple lines, so we load+store:
m->setTitle(m->Title() + value);
if (art.length())
{
compn = true; // Probably a compilation
m->setArtist(M_QSTRING_UNICODE(art));
}
}
else
LOG(VB_GENERAL, LOG_INFO,
QString("CDDB returned %1 on a %2 track disk!")
.arg(trk+1).arg(totalTracks));
}
// Get next THINGY=value line:
cddb = cddb.section('\n', 1, 0xffffffff);
}
for (trk = 0; trk < totalTracks; ++trk)
{
Metadata *m = m_mData[trk];
if (compn)
m->setCompilation(true);
m->setGenre(M_QSTRING_UNICODE(genre));
if (year)
m->setYear(year);
if (album.length())
m->setAlbum(M_QSTRING_UNICODE(album));
if (artist.length())
if (compn)
m->setCompilationArtist(M_QSTRING_UNICODE(artist));
else
m->setArtist(M_QSTRING_UNICODE(artist));
}
}
}
void setComment(string _comment) {comment=_comment; info.add("Comment", comment);}
//add other Metadata, without first 2 entries ("default" metadata)
void Metadata::operator+=(const Metadata &other)
{
for (unsigned int i=2; i<other.size(); i++)
this->add(other.getLabel(i), other.getEntry(i));
}
void CDRipperThread::run(void)
{
RunProlog();
if (!m_tracks->size() > 0)
{
RunEpilog();
return;
}
Metadata *track = m_tracks->at(0)->metadata;
QString tots;
if (track->Compilation())
{
tots = track->CompilationArtist() + " ~ " + track->Album();
}
else
{
tots = track->Artist() + " ~ " + track->Album();
}
QApplication::postEvent(
m_parent,
new RipStatusEvent(RipStatusEvent::kOverallTextEvent, tots));
QApplication::postEvent(
m_parent,
new RipStatusEvent(RipStatusEvent::kOverallProgressEvent, 0));
QApplication::postEvent(
m_parent,
new RipStatusEvent(RipStatusEvent::kTrackProgressEvent, 0));
QString textstatus;
QString encodertype = gCoreContext->GetSetting("EncoderType");
bool mp3usevbr = gCoreContext->GetNumSetting("Mp3UseVBR", 0);
m_totalSectors = 0;
m_totalSectorsDone = 0;
for (int trackno = 0; trackno < m_tracks->size(); trackno++)
{
m_totalSectors += getSectorCount(m_CDdevice, trackno + 1);
}
QApplication::postEvent(m_parent,
new RipStatusEvent(RipStatusEvent::kOverallStartEvent, m_totalSectors));
if (LCD *lcd = LCD::Get())
{
QString lcd_tots = QObject::tr("Importing ") + tots;
QList<LCDTextItem> textItems;
textItems.append(LCDTextItem(1, ALIGN_CENTERED,
lcd_tots, "Generic", false));
lcd->switchToGeneric(textItems);
}
Metadata *titleTrack = NULL;
QString outfile;
std::auto_ptr<Encoder> encoder;
for (int trackno = 0; trackno < m_tracks->size(); trackno++)
{
if (isCancelled())
break;
QApplication::postEvent(
m_parent,
new RipStatusEvent(RipStatusEvent::kStatusTextEvent,
QString("Track %1 of %2")
.arg(trackno + 1).arg(m_tracks->size())));
QApplication::postEvent(
m_parent,
new RipStatusEvent(RipStatusEvent::kTrackProgressEvent, 0));
track = m_tracks->at(trackno)->metadata;
if (track)
{
textstatus = track->Title();
QApplication::postEvent(
m_parent,
new RipStatusEvent(
RipStatusEvent::kTrackTextEvent, textstatus));
QApplication::postEvent(
m_parent,
new RipStatusEvent(RipStatusEvent::kTrackProgressEvent, 0));
QApplication::postEvent(
m_parent,
new RipStatusEvent(RipStatusEvent::kTrackPercentEvent, 0));
// do we need to start a new file?
if (m_tracks->at(trackno)->active)
{
titleTrack = track;
titleTrack->setLength(m_tracks->at(trackno)->length);
outfile = Ripper::filenameFromMetadata(track);
if (m_quality < 3)
{
if (encodertype == "mp3")
{
outfile += ".mp3";
encoder.reset(new LameEncoder(outfile, m_quality,
titleTrack, mp3usevbr));
}
else // ogg
{
outfile += ".ogg";
encoder.reset(new VorbisEncoder(outfile, m_quality,
titleTrack));
}
}
else
{
outfile += ".flac";
encoder.reset(new FlacEncoder(outfile, m_quality,
titleTrack));
}
if (!encoder->isValid())
{
QApplication::postEvent(
m_parent,
new RipStatusEvent(
RipStatusEvent::kEncoderErrorEvent,
"Encoder failed to open file for writing"));
LOG(VB_GENERAL, LOG_ERR, "MythMusic: Encoder failed"
" to open file for writing");
RunEpilog();
return;
}
}
if (!encoder.get())
{
// This should never happen.
QApplication::postEvent(
m_parent,
new RipStatusEvent(RipStatusEvent::kEncoderErrorEvent,
"Failed to create encoder"));
LOG(VB_GENERAL, LOG_ERR, "MythMusic: No encoder, failing");
RunEpilog();
return;
}
ripTrack(m_CDdevice, encoder.get(), trackno + 1);
if (isCancelled())
{
RunEpilog();
return;
}
// save the metadata to the DB
if (m_tracks->at(trackno)->active)
{
titleTrack->setFilename(outfile);
titleTrack->dumpToDatabase();
}
}
}
QString PostRipCDScript = gCoreContext->GetSetting("PostCDRipScript");
if (!PostRipCDScript.isEmpty())
myth_system(PostRipCDScript);
QApplication::postEvent(
m_parent, new RipStatusEvent(RipStatusEvent::kFinishedEvent, ""));
RunEpilog();
}
void SearchView::customEvent(QEvent *event)
{
bool handled = false;
if (event->type() == MusicPlayerEvent::TrackRemovedEvent ||
event->type() == MusicPlayerEvent::TrackAddedEvent)
{
MusicPlayerEvent *mpe = dynamic_cast<MusicPlayerEvent *>(event);
if (!mpe)
return;
int trackID = mpe->TrackID;
for (int x = 0; x < m_tracksList->GetCount(); x++)
{
MythUIButtonListItem *item = m_tracksList->GetItemAt(x);
Metadata *mdata = qVariantValue<Metadata*> (item->GetData());
if (mdata && (mdata->ID() == (Metadata::IdType) trackID || trackID == -1))
{
if (gPlayer->getPlaylist()->checkTrack(mdata->ID()))
item->DisplayState("on", "selectedstate");
else
item->DisplayState("off", "selectedstate");
}
}
// call the default handler in MusicCommon so the playlist and UI is updated
MusicCommon::customEvent(event);
handled = true;
if (m_playTrack)
{
m_playTrack = false;
if (event->type() == MusicPlayerEvent::TrackAddedEvent)
{
// make the added track current and play it
m_currentPlaylist->SetItemCurrent(m_currentPlaylist->GetCount() - 1);
playlistItemClicked(m_currentPlaylist->GetItemCurrent());
}
}
}
else if (event->type() == MusicPlayerEvent::AllTracksRemovedEvent)
{
for (int x = 0; x < m_tracksList->GetCount(); x++)
{
MythUIButtonListItem *item = m_tracksList->GetItemAt(x);
if (item)
item->DisplayState("off", "selectedstate");
}
}
else if (event->type() == MusicPlayerEvent::MetadataChangedEvent)
{
MusicPlayerEvent *mpe = dynamic_cast<MusicPlayerEvent *>(event);
if (!mpe)
return;
uint trackID = mpe->TrackID;
for (int x = 0; x < m_tracksList->GetCount(); x++)
{
MythUIButtonListItem *item = m_tracksList->GetItemAt(x);
Metadata *mdata = qVariantValue<Metadata*> (item->GetData());
if (mdata && mdata->ID() == trackID)
{
MetadataMap metadataMap;
mdata->toMap(metadataMap);
item->SetTextFromMap(metadataMap);
}
}
// if (trackID == gPlayer->getCurrentMetadata()->ID())
// updateTrackInfo(gPlayer->getCurrentMetadata());
}
else if (event->type() == DialogCompletionEvent::kEventType)
{
DialogCompletionEvent *dce = dynamic_cast<DialogCompletionEvent *>(event);
if (!dce)
return;
// make sure the user didn't ESCAPE out of the menu
if (dce->GetResult() < 0)
return;
QString resultid = dce->GetId();
QString resulttext = dce->GetResultText();
if (resultid == "searchviewmenu")
{
if (resulttext == tr("Add To Playlist") || resulttext == tr("Remove From Playlist"))
{
if (GetFocusWidget() == m_tracksList)
{
MythUIButtonListItem *item = m_tracksList->GetItemCurrent();
if (item)
{
m_playTrack = false;
trackClicked(item);
}
}
}
else if (resulttext == tr("Add To Playlist And Play"))
{
if (GetFocusWidget() == m_tracksList)
{
MythUIButtonListItem *item = m_tracksList->GetItemCurrent();
if (item)
{
m_playTrack = true;
trackClicked(item);
}
}
}
else if (resulttext == tr("Search List..."))
searchButtonList();
}
}
if (!handled)
MusicCommon::customEvent(event);
}
void Ripper::ScanFinished()
{
delete m_scanThread;
m_scanThread = NULL;
m_tracks->clear();
bool isCompilation = false;
bool newTune = true;
if (m_decoder)
{
QString label;
Metadata *metadata;
m_artistName.clear();
m_albumName.clear();
m_genreName.clear();
m_year.clear();
bool yesToAll = false;
bool noToAll = false;
for (int trackno = 0; trackno < m_decoder->getNumTracks(); trackno++)
{
RipTrack *ripTrack = new RipTrack;
metadata = m_decoder->getMetadata(trackno + 1);
if (metadata)
{
ripTrack->metadata = metadata;
ripTrack->length = metadata->Length();
ripTrack->active = true;
if (metadata->Compilation())
{
isCompilation = true;
m_artistName = metadata->CompilationArtist();
}
else if (m_artistName.isEmpty())
{
m_artistName = metadata->Artist();
}
if (m_albumName.isEmpty())
m_albumName = metadata->Album();
if (m_genreName.isEmpty() && !metadata->Genre().isEmpty())
m_genreName = metadata->Genre();
if (m_year.isEmpty() && metadata->Year() > 0)
m_year = QString::number(metadata->Year());
QString title = metadata->Title();
newTune = Ripper::isNewTune(m_artistName, m_albumName, title);
if (newTune)
{
m_tracks->push_back(ripTrack);
}
else
{
if (yesToAll)
{
deleteTrack(m_artistName, m_albumName, title);
m_tracks->push_back(ripTrack);
}
else if (noToAll)
{
delete ripTrack;
delete metadata;
continue;
}
else
{
DialogBox *dlg = new DialogBox(
GetMythMainWindow(),
tr("Artist: %1\n"
"Album: %2\n"
"Track: %3\n\n"
"This track is already in the database. \n"
"Do you want to remove the existing track?")
.arg(m_artistName).arg(m_albumName).arg(title));
dlg->AddButton("No");
dlg->AddButton("No To All");
dlg->AddButton("Yes");
dlg->AddButton("Yes To All");
DialogCode res = dlg->exec();
dlg->deleteLater();
dlg = NULL;
if (kDialogCodeButton0 == res)
{
delete ripTrack;
delete metadata;
}
else if (kDialogCodeButton1 == res)
{
noToAll = true;
delete ripTrack;
delete metadata;
}
else if (kDialogCodeButton2 == res)
{
deleteTrack(m_artistName, m_albumName, title);
m_tracks->push_back(ripTrack);
}
else if (kDialogCodeButton3 == res)
{
yesToAll = true;
deleteTrack(m_artistName, m_albumName, title);
m_tracks->push_back(ripTrack);
}
else // treat cancel as no
{
delete ripTrack;
delete metadata;
}
}
}
}
else
delete ripTrack;
}
m_artistEdit->SetText(m_artistName);
m_albumEdit->SetText(m_albumName);
m_genreEdit->SetText(m_genreName);
m_yearEdit->SetText(m_year);
m_compilationCheck->SetCheckState(isCompilation);
if (!isCompilation)
m_switchTitleArtist->SetVisible(false);
else
m_switchTitleArtist->SetVisible(true);
}
BuildFocusList();
updateTrackList();
CloseBusyPopup();
}
static bool
SendCodeRangesToProfiler(JSContext* cx, CodeSegment& cs, const Bytes& bytecode,
const Metadata& metadata)
{
bool enabled = false;
#ifdef JS_ION_PERF
enabled |= PerfFuncEnabled();
#endif
#ifdef MOZ_VTUNE
enabled |= IsVTuneProfilingActive();
#endif
if (!enabled)
return true;
for (const CodeRange& codeRange : metadata.codeRanges) {
if (!codeRange.isFunction())
continue;
uintptr_t start = uintptr_t(cs.base() + codeRange.begin());
uintptr_t end = uintptr_t(cs.base() + codeRange.end());
uintptr_t size = end - start;
TwoByteName name(cx);
if (!metadata.getFuncName(cx, &bytecode, codeRange.funcIndex(), &name))
return false;
UniqueChars chars(
(char*)JS::LossyTwoByteCharsToNewLatin1CharsZ(cx, name.begin(), name.length()).get());
if (!chars)
return false;
// Avoid "unused" warnings
(void)start;
(void)size;
#ifdef JS_ION_PERF
if (PerfFuncEnabled()) {
const char* file = metadata.filename.get();
unsigned line = codeRange.funcLineOrBytecode();
unsigned column = 0;
writePerfSpewerAsmJSFunctionMap(start, size, file, line, column, chars.get());
}
#endif
#ifdef MOZ_VTUNE
if (IsVTuneProfilingActive()) {
unsigned method_id = iJIT_GetNewMethodID();
if (method_id == 0)
return true;
iJIT_Method_Load method;
method.method_id = method_id;
method.method_name = chars.get();
method.method_load_address = (void*)start;
method.method_size = size;
method.line_number_size = 0;
method.line_number_table = nullptr;
method.class_id = 0;
method.class_file_name = nullptr;
method.source_file_name = nullptr;
iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&method);
}
#endif
}
return true;
}
int Slave::connect()
{
// join the server
SSLTransport::init();
string cert = m_strBase + "/conf/master_node.cert";
// calculate total available disk size
struct statfs slavefs;
// <slr>
statfs(m_SysConfig.m_strHomeDir.c_str(), &slavefs);
int64_t availdisk = (int64_t)slavefs.f_bfree * slavefs.f_bsize;
m_iSlaveID = -1;
m_pLocalFile->serialize("/", m_strHomeDir + ".tmp/metadata.dat");
set<Address, AddrComp> masters;
Address m;
m.m_strIP = m_strMasterIP;
m.m_iPort = m_iMasterPort;
masters.insert(m);
bool first = true;
while (!masters.empty())
{
string mip = masters.begin()->m_strIP;
int mport = masters.begin()->m_iPort;
masters.erase(masters.begin());
SSLTransport secconn;
secconn.initClientCTX(cert.c_str());
secconn.open(NULL, 0);
if (secconn.connect(mip.c_str(), mport) < 0)
{
cerr << "unable to set up secure channel to the master.\n";
return -1;
}
if (first)
{
secconn.getLocalIP(m_strLocalHost);
// init data exchange channel
m_iDataPort = 0;
if (m_DataChn.init(m_strLocalHost, m_iDataPort) < 0)
{
cerr << "unable to create data channel.\n";
secconn.close();
return -1;
}
}
int32_t cmd = 1;
secconn.send((char*)&cmd, 4);
int32_t size = m_strHomeDir.length() + 1;
secconn.send((char*)&size, 4);
secconn.send(m_strHomeDir.c_str(), size);
int32_t res = -1;
secconn.recv((char*)&res, 4);
if (res < 0)
{
cerr << "slave join rejected. code: " << res << endl;
return res;
}
secconn.send((char*)&m_iLocalPort, 4);
secconn.send((char*)&m_iDataPort, 4);
secconn.send((char*)&(availdisk), 8);
secconn.send((char*)&(m_iSlaveID), 4);
if (first)
m_iSlaveID = res;
struct stat s;
stat((m_strHomeDir + ".tmp/metadata.dat").c_str(), &s);
size = s.st_size;
secconn.send((char*)&size, 4);
secconn.sendfile((m_strHomeDir + ".tmp/metadata.dat").c_str(), 0, size);
if (!first)
{
secconn.close();
continue;
}
// move out-of-date files to the ".attic" directory
size = 0;
secconn.recv((char*)&size, 4);
if (size > 0)
{
secconn.recvfile((m_strHomeDir + ".tmp/metadata.left.dat").c_str(), 0, size);
Metadata* attic = NULL;
if (m_SysConfig.m_MetaType == DISK)
attic = new Index2;
else
attic = new Index;
attic->init(m_strHomeDir + ".tmp/metadata.left");
attic->deserialize("/", m_strHomeDir + ".tmp/metadata.left.dat", NULL);
unlink((m_strHomeDir + ".tmp/metadata.left.dat").c_str());
vector<string> fl;
attic->list_r("/", fl);
for (vector<string>::iterator i = fl.begin(); i != fl.end(); ++ i)
move(*i, ".attic", "");
attic->clear();
delete attic;
m_SectorLog.insert("WARNING: certain files have been moved to ./attic due to conflicts.");
}
int id = 0;
secconn.recv((char*)&id, 4);
Address addr;
addr.m_strIP = mip;
addr.m_iPort = mport;
m_Routing.insert(id, addr);
int num;
secconn.recv((char*)&num, 4);
for (int i = 0; i < num; ++ i)
{
char ip[64];
size = 0;
secconn.recv((char*)&id, 4);
secconn.recv((char*)&size, 4);
secconn.recv(ip, size);
addr.m_strIP = ip;
secconn.recv((char*)&addr.m_iPort, 4);
m_Routing.insert(id, addr);
masters.insert(addr);
}
first = false;
secconn.close();
}
SSLTransport::destroy();
unlink((m_strHomeDir + ".tmp/metadata.dat").c_str());
// initialize slave statistics
m_SlaveStat.init();
cout << "This Sector slave is successfully initialized and running now.\n";
return 1;
}
int Playlist::CreateCDMP3(void)
{
// Check & get global settings
if (!gCoreContext->GetNumSetting("CDWriterEnabled"))
{
VERBOSE(VB_GENERAL, "CD Writer is not enabled.");
return 1;
}
QString scsidev = MediaMonitor::defaultCDWriter();
if (scsidev.isEmpty())
{
VERBOSE(VB_GENERAL, "No CD Writer device defined.");
return 1;
}
int disksize = gCoreContext->GetNumSetting("CDDiskSize", 2);
QString writespeed = gCoreContext->GetSetting("CDWriteSpeed", "2");
bool MP3_dir_flag = gCoreContext->GetNumSetting("CDCreateDir", 1);
double size_in_MB = 0.0;
QStringList reclist;
SongList::const_iterator it = songs.begin();
for (; it != songs.end(); ++it)
{
if ((*it)->getCDFlag())
continue;
if ((*it)->getValue() == 0)
{
VERBOSE(VB_IMPORTANT, kID0err);
}
else if ((*it)->getValue() > 0)
{
// Normal track
Metadata *tmpdata =
all_available_music->getMetadata((*it)->getValue());
if (tmpdata)
{
// check filename..
QFileInfo testit(tmpdata->Filename());
if (!testit.exists())
continue;
size_in_MB += testit.size() / 1000000.0;
QString outline;
if (MP3_dir_flag)
{
if (tmpdata->Artist().length() > 0)
outline += tmpdata->Artist() + "/";
if (tmpdata->Album().length() > 0)
outline += tmpdata->Album() + "/";
}
outline += "=";
outline += tmpdata->Filename();
reclist += outline;
}
}
else if ((*it)->getValue() < 0)
{
// FIXME: handle playlists
}
}
int max_size;
if (disksize == 0)
max_size = 650;
else
max_size = 700;
if (size_in_MB >= max_size)
{
VERBOSE(VB_GENERAL, "MP3 CD creation aborted -- cd size too big.");
return 1;
}
// probably should tie stdout of mkisofs to stdin of cdrecord sometime
QString tmptemplate("/tmp/mythmusicXXXXXX");
QString tmprecordlist = createTempFile(tmptemplate);
if (tmprecordlist == tmptemplate)
{
VERBOSE(VB_IMPORTANT, "Unable to open temporary file");
return 1;
}
QString tmprecordisofs = createTempFile(tmptemplate);
if (tmprecordisofs == tmptemplate)
{
VERBOSE(VB_IMPORTANT, "Unable to open temporary file");
return 1;
}
QFile reclistfile(tmprecordlist);
if (!reclistfile.open(QIODevice::WriteOnly))
{
VERBOSE(VB_IMPORTANT, "Unable to open temporary file");
return 1;
}
QTextStream recstream(&reclistfile);
QStringList::Iterator iter;
for (iter = reclist.begin(); iter != reclist.end(); ++iter)
{
recstream << *iter << "\n";
}
reclistfile.close();
MythProgressDialog *progress;
progress = new MythProgressDialog(QObject::tr("Creating CD File System"),
100);
progress->setProgress(1);
QStringList args("mkisofs");
args += "-graft-points";
args += "-path-list";
args += tmprecordlist;
args += "-o";
args += tmprecordisofs;
args += "-J";
args += "-R";
VERBOSE(VB_GENERAL, "Running: " + args.join(" "));
bool retval = 0;
Q3Process isofs(args);
if (isofs.start())
{
while (1)
{
while (isofs.canReadLineStderr())
{
QString buf = isofs.readLineStderr();
if (buf[6] == '%')
{
buf = buf.mid(0, 3);
progress->setProgress(buf.trimmed().toInt());
}
}
if (isofs.isRunning())
{
qApp->processEvents();
usleep(100000);
}
else
{
if (!isofs.normalExit())
{
VERBOSE(VB_IMPORTANT, "Unable to run 'mkisofs'");
retval = 1;
}
break;
}
}
}
else
{
VERBOSE(VB_IMPORTANT, "Unable to run 'mkisofs'");
retval = 1;
}
progress->Close();
progress->deleteLater();
progress = new MythProgressDialog(QObject::tr("Burning CD"), 100);
progress->setProgress(2);
args = QStringList("cdrecord");
args += "-v";
//args += "-dummy";
args += "dev=";
args += scsidev;
if (writespeed.toInt() > 0)
{
args += "-speed=";
args += writespeed;
}
args += "-data";
args += tmprecordisofs;
VERBOSE(VB_GENERAL, "Running: " + args.join(" "));
Q3Process burn(args);
if (burn.start())
{
while (1)
{
while (burn.canReadLineStderr())
{
QString err = burn.readLineStderr();
if (err == "cdrecord: Drive needs to reload the media" ||
err == "cdrecord: Input/output error." ||
err == "cdrecord: No disk / Wrong disk!")
{
VERBOSE(VB_IMPORTANT, err);
burn.kill();
retval = 1;
}
}
while (burn.canReadLineStdout())
{
QString line = burn.readLineStdout();
if (line.mid(15, 2) == "of")
{
int mbdone = line.mid(10, 5).trimmed().toInt();
int mbtotal = line.mid(17, 5).trimmed().toInt();
if (mbtotal > 0)
{
progress->setProgress((mbdone * 100) / mbtotal);
}
}
}
if (burn.isRunning())
{
qApp->processEvents();
usleep(10000);
}
else
{
if (!burn.normalExit())
{
VERBOSE(VB_IMPORTANT, "Unable to run 'cdrecord'");
retval = 1;
}
break;
}
}
}
else
{
VERBOSE(VB_IMPORTANT, "Unable to run 'cdrecord'");
retval = 1;
}
progress->Close();
progress->deleteLater();
QFile::remove(tmprecordlist);
QFile::remove(tmprecordisofs);
return retval;
}
void ReadCDThread::run()
{
#ifndef USING_MINGW
// lock all_music and cd_status_changed while running thread
QMutexLocker locker(getLock());
CdDecoder *decoder = new CdDecoder("cda", NULL, NULL, NULL);
decoder->setDevice(m_CDdevice);
int tracknum = decoder->getNumCDAudioTracks();
bool redo = false;
if (tracknum != gMusicData->all_music->getCDTrackCount())
{
cd_status_changed = true;
VERBOSE(VB_IMPORTANT, QString("CD status has changed."));
}
else
cd_status_changed = false;
if (tracknum == 0)
{
// No CD, or no recognizable CD
gMusicData->all_music->clearCDData();
gMusicData->all_playlists->clearCDList();
}
else if (tracknum > 0)
{
// Check the last track to see if it's differen than whatever it was
// before
Metadata *checker = decoder->getLastMetadata();
if (checker)
{
if (!gMusicData->all_music->checkCDTrack(checker))
{
redo = true;
cd_status_changed = true;
gMusicData->all_music->clearCDData();
gMusicData->all_playlists->clearCDList();
}
else
cd_status_changed = false;
delete checker;
}
else
{
VERBOSE(VB_IMPORTANT, "The cddecoder said it had audio tracks, "
"but it won't tell me about them");
}
}
int tracks = decoder->getNumTracks();
bool setTitle = false;
for (int actual_tracknum = 1;
redo && actual_tracknum <= tracks; actual_tracknum++)
{
Metadata *track = decoder->getMetadata(actual_tracknum);
if (track)
{
gMusicData->all_music->addCDTrack(track);
if (!setTitle)
{
QString parenttitle = " ";
if (track->FormatArtist().length() > 0)
{
parenttitle += track->FormatArtist();
parenttitle += " ~ ";
}
if (track->Album().length() > 0)
parenttitle += track->Album();
else
{
parenttitle = " " + QObject::tr("Unknown");
VERBOSE(VB_GENERAL, "Couldn't find your "
" CD. It may not be in the freedb database.\n"
" More likely, however, is that you need to delete\n"
" ~/.cddb and ~/.cdserverrc and restart mythmusic.");
}
gMusicData->all_music->setCDTitle(parenttitle);
setTitle = true;
}
delete track;
}
}
delete decoder;
#endif // USING_MINGW
}
int Playlist::writeTree(GenericTree *tree_to_write_to, int a_counter)
{
// compute max/min playcount,lastplay for this playlist
int playcountMin = 0;
int playcountMax = 0;
double lastplayMin = 0.0;
double lastplayMax = 0.0;
typedef map<QString, uint32_t> AlbumMap;
AlbumMap album_map;
AlbumMap::iterator Ialbum;
QString album;
typedef map<QString, uint32_t> ArtistMap;
ArtistMap artist_map;
ArtistMap::iterator Iartist;
QString artist;
uint idx = 0;
SongList::const_iterator it = songs.begin();
for (; it != songs.end(); ++it, ++idx)
{
if (!(*it)->getCDFlag())
{
if ((*it)->getValue() == 0)
{
VERBOSE(VB_IMPORTANT, LOC_ERR + kID0err);
}
if ((*it)->getValue() > 0)
{
// Normal track
Metadata *tmpdata =
all_available_music->getMetadata((*it)->getValue());
if (tmpdata)
{
if (tmpdata->isVisible())
{
if (0 == idx)
{ // first song
playcountMin = playcountMax = tmpdata->PlayCount();
lastplayMin = lastplayMax = tmpdata->LastPlay().toTime_t();
}
else
{
if (tmpdata->PlayCount() < playcountMin)
playcountMin = tmpdata->PlayCount();
else if (tmpdata->PlayCount() > playcountMax)
playcountMax = tmpdata->PlayCount();
if (tmpdata->LastPlay().toTime_t() < lastplayMin)
lastplayMin = tmpdata->LastPlay().toTime_t();
else if (tmpdata->LastPlay().toTime_t() > lastplayMax)
lastplayMax = tmpdata->LastPlay().toTime_t();
}
}
// pre-fill the album-map with the album name.
// This allows us to do album mode in album order
album = tmpdata->Album();
// pre-fill the artist map with the artist name and song title
artist = tmpdata->Artist() + "~" + tmpdata->Title();
}
if ((Ialbum = album_map.find(album)) == album_map.end())
album_map.insert(AlbumMap::value_type(album,0));
if ((Iartist = artist_map.find(artist)) == artist_map.end())
artist_map.insert(ArtistMap::value_type(artist,0));
}
}
}
// populate the sort id into the album map
uint32_t album_count = 1;
for (Ialbum = album_map.begin(); Ialbum != album_map.end(); Ialbum++)
{
Ialbum->second = album_count;
album_count++;
}
// populate the sort id into the artist map
uint32_t count = 1;
for (Iartist = artist_map.begin(); Iartist != artist_map.end(); Iartist++)
{
Iartist->second = count;
count++;
}
int RatingWeight = 2;
int PlayCountWeight = 2;
int LastPlayWeight = 2;
int RandomWeight = 2;
parent->FillIntelliWeights(RatingWeight, PlayCountWeight, LastPlayWeight,
RandomWeight);
for (it = songs.begin(); it != songs.end(); ++it)
{
if (!(*it)->getCDFlag())
{
if ((*it)->getValue() == 0)
{
VERBOSE(VB_IMPORTANT, LOC_ERR + kID0err);
}
if ((*it)->getValue() > 0)
{
// Normal track
Metadata *tmpdata =
all_available_music->getMetadata((*it)->getValue());
if (tmpdata && tmpdata->isVisible())
{
QString a_string = QString("%1 ~ %2")
.arg(tmpdata->FormatArtist())
.arg(tmpdata->FormatTitle());
GenericTree *added_node = tree_to_write_to->addNode(
a_string, (*it)->getValue(), true);
++a_counter;
added_node->setAttribute(0, 1);
added_node->setAttribute(1, a_counter); // regular order
added_node->setAttribute(2, rand()); // random order
//
// Compute "intelligent" weighting
//
int rating = tmpdata->Rating();
int playcount = tmpdata->PlayCount();
double lastplaydbl = tmpdata->LastPlay().toTime_t();
double ratingValue = (double)(rating) / 10;
double playcountValue, lastplayValue;
if (playcountMax == playcountMin)
playcountValue = 0;
else
playcountValue = ((playcountMin - (double)playcount)
/ (playcountMax - playcountMin) + 1);
if (lastplayMax == lastplayMin)
lastplayValue = 0;
else
lastplayValue = ((lastplayMin - lastplaydbl)
/ (lastplayMax - lastplayMin) + 1);
double rating_value = (RatingWeight * ratingValue +
PlayCountWeight * playcountValue +
LastPlayWeight * lastplayValue +
RandomWeight * (double)rand() /
(RAND_MAX + 1.0));
uint32_t integer_rating = (int) (4000001 -
rating_value * 10000);
// "intelligent" order
added_node->setAttribute(3, integer_rating);
// "intellegent/album" order
uint32_t album_order;
album = tmpdata->Album();
if ((Ialbum = album_map.find(album)) == album_map.end())
{
// we didn't find this album in the map,
// yet we pre-loaded them all. we are broken,
// but we just set the track order to 1, since there
// is no real point in reporting an error
album_order = 1;
}
else
{
album_order = Ialbum->second * 100;
}
album_order += tmpdata->Track();
added_node->setAttribute(4, album_order);
// "artist" order, sorts by artist name then track title
// uses the pre-prepared artist map to do this
uint32_t integer_order;
artist = tmpdata->Artist() + "~" + tmpdata->Title();
if ((Iartist = artist_map.find(artist)) == artist_map.end())
{
// we didn't find this track in the map,
// yet we pre-loaded them all. we are broken,
// but we just set the track order to 1, since there
// is no real point in reporting an error
integer_order = 1;
}
else
{
integer_order = Iartist->second;
}
added_node->setAttribute(5, integer_order);
}
}
if ((*it)->getValue() < 0)
{
// it's a playlist, recurse (mildly)
Playlist *level_down
= parent->getPlaylist(((*it)->getValue()) * -1);
if (level_down)
{
a_counter = level_down->writeTree(tree_to_write_to,
a_counter);
}
}
}
else
{
Metadata *tmpdata =
all_available_music->getMetadata((*it)->getValue());
if (tmpdata)
{
QString a_string = QString("(CD) %1 ~ %2")
.arg(tmpdata->FormatArtist()).arg(tmpdata->FormatTitle());
if (tmpdata->FormatArtist().length() < 1 ||
tmpdata->FormatTitle().length() < 1)
{
a_string = QString("(CD) Track %1").arg(tmpdata->Track());
}
GenericTree *added_node =
tree_to_write_to->addNode(a_string, (*it)->getValue(), true);
++a_counter;
added_node->setAttribute(0, 1);
added_node->setAttribute(1, a_counter); // regular order
added_node->setAttribute(2, rand()); // random order
added_node->setAttribute(3, rand()); // "intelligent" order
}
}
}
return a_counter;
}
void DatabaseBox::entered(UIListTreeType *treetype, UIListGenericTree *item)
{
if (!item || !treetype)
return;
// Determin if this is a CD entry
bool cd = false;
if (dynamic_cast<CDCheckItem*>(item))
cd = true;
TreeCheckItem *item_ptr = dynamic_cast<TreeCheckItem*>(item);
if (item_ptr
&& item->childCount() == 0
&& item_ptr->getLevel() == "title")
{
int id = item_ptr->getID();
Metadata *mdata;
if (!cd)
{
mdata = gMusicData->all_music->getMetadata(id);
if (!mdata)
return;
}
else
{
// Need to allocate storage for CD Metadata
mdata = new Metadata;
if (!gMusicData->all_music->getCDMetadata(id, mdata))
{
delete mdata;
return;
}
}
unsigned int line = 0;
QString tmpstr;
if (mdata->Compilation())
{
tmpstr = tr("Compilation Artist:\t") + mdata->CompilationArtist();
if (m_lines.at(line))
m_lines.at(line++)->SetText(tmpstr);
}
tmpstr = tr("Artist:\t") + mdata->Artist();
if (m_lines.at(line))
m_lines.at(line++)->SetText(tmpstr);
tmpstr = tr("Album:\t") + mdata->Album();
if (m_lines.at(line))
m_lines.at(line++)->SetText(tmpstr);
tmpstr = tr("Title:\t") + mdata->Title();
if (m_lines.at(line))
m_lines.at(line++)->SetText(tmpstr);
if (m_lines.at(line))
{
int maxTime = mdata->Length() / 1000;
int maxh = maxTime / 3600;
int maxm = (maxTime / 60) % 60;
int maxs = maxTime % 60;
QString timeStr;
if (maxh > 0)
timeStr.sprintf("%02d:%02d:%02d", maxh, maxm, maxs);
else
timeStr.sprintf("%02d:%02d", maxm, maxs);
tmpstr = tr("Length:\t") + timeStr;
m_lines.at(line++)->SetText(tmpstr);
}
tmpstr = tr("Genre: ") + mdata->Genre();
if (m_lines.at(line))
{
m_lines.at(line)->SetText(tmpstr);
}
else
{
QString prevvalue = m_lines.at(line-1)->GetText();
tmpstr = prevvalue + " " + tmpstr;
m_lines.at(line-1)->SetText(tmpstr);
}
// Pre increment as not incremented from previous use.
while (++line < (unsigned) m_lines.size())
m_lines.at(line)->SetText("");
// Don't forget to delete the mdata storage if we allocated it.
if (cd)
delete mdata;
return;
}
QStringList pathto = treetype->getRouteToCurrent();
int linelen = 0;
int dispat = 0;
QString data;
for (QStringList::Iterator it = pathto.begin();
it != pathto.end(); ++it)
{
if (it == pathto.begin())
continue;
if (!data.isEmpty())
data += " / ";
data += *it;
linelen++;
if (linelen == 2)
{
if (m_lines.at(dispat))
{
m_lines.at(dispat)->SetText(data);
}
data.clear();
linelen = 0;
dispat++;
}
}
if (linelen != 0)
{
if (m_lines.at(dispat))
{
m_lines.at(dispat)->SetText(data);
}
dispat++;
}
for (unsigned int i = dispat; i < (unsigned) m_lines.size(); i++)
m_lines.at(i)->SetText("");
}
bool operator!=(const Metadata& a, const Metadata& b)
{
if (a.Filename() != b.Filename())
return true;
return false;
}
/*!
* \brief Insert file details into database.
* If it is an audio file, read the metadata and insert
* that information at the same time.
*
* If it is an image file, just insert the filename and
* type.
*
* \param filename Full path to file.
*
* \returns Nothing.
*/
void FileScanner::AddFileToDB(const QString &filename)
{
QString extension = filename.section( '.', -1 ) ;
QString directory = filename;
directory.remove(0, m_startdir.length());
directory = directory.section( '/', 0, -2);
QString nameFilter = gCoreContext->GetSetting("AlbumArtFilter",
"*.png;*.jpg;*.jpeg;*.gif;*.bmp");
// If this file is an image, insert the details into the music_albumart table
if (nameFilter.indexOf(extension.toLower()) > -1)
{
QString name = filename.section( '/', -1);
MSqlQuery query(MSqlQuery::InitCon());
query.prepare("INSERT INTO music_albumart SET filename = :FILE, "
"directory_id = :DIRID, imagetype = :TYPE;");
query.bindValue(":FILE", name);
query.bindValue(":DIRID", m_directoryid[
QString(directory.toUtf8()).toLower()]);
query.bindValue(":TYPE", AlbumArtImages::guessImageType(name));
if (!query.exec() || query.numRowsAffected() <= 0)
{
MythDB::DBError("music insert artwork", query);
}
return;
}
Decoder *decoder = Decoder::create(filename, NULL, NULL, true);
if (decoder)
{
VERBOSE(VB_FILE, QString("Reading metadata from %1").arg(filename));
Metadata *data = decoder->readMetadata();
if (data) {
QString album_cache_string;
// Set values from cache
int did = m_directoryid[QString(directory.toUtf8()).toLower()];
if (did > 0)
data->setDirectoryId(did);
int aid = m_artistid[QString(data->Artist().toUtf8()).toLower()];
if (aid > 0)
{
data->setArtistId(aid);
// The album cache depends on the artist id
album_cache_string = data->getArtistId() + "#"
+ QString(data->Album().toUtf8()).toLower();
if (m_albumid[album_cache_string] > 0)
data->setAlbumId(m_albumid[album_cache_string]);
}
int gid = m_genreid[QString(data->Genre().toUtf8()).toLower()];
if (gid > 0)
data->setGenreId(gid);
// Commit track info to database
data->dumpToDatabase();
// Update the cache
m_artistid[QString(data->Artist().toUtf8()).toLower()] =
data->getArtistId();
m_genreid[QString(data->Genre().toUtf8()).toLower()] =
data->getGenreId();
album_cache_string = data->getArtistId() + "#"
+ QString(data->Album().toUtf8()).toLower();
m_albumid[album_cache_string] = data->getAlbumId();
delete data;
}
delete decoder;
}
}
