1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
#include <QtDebug>
#include <QStringList>
#include "track/keyfactory.h"
#include "track/keys.h"
#include "track/keyutils.h"
using mixxx::track::io::key::KeyMap;
// static
Keys KeyFactory::loadKeysFromByteArray(const QString& keysVersion,
const QString& keysSubVersion,
QByteArray* keysSerialized) {
if (keysVersion == KEY_MAP_VERSION) {
Keys keys(keysSerialized);
keys.setSubVersion(keysSubVersion);
qDebug() << "Successfully deserialized KeyMap";
return keys;
}
return Keys();
}
// static
Keys KeyFactory::makeBasicKeys(mixxx::track::io::key::ChromaticKey global_key,
mixxx::track::io::key::Source source) {
KeyMap key_map;
key_map.set_global_key(global_key);
key_map.set_source(source);
return Keys(key_map);
}
// static
Keys KeyFactory::makeBasicKeysFromText(const QString& global_key_text,
mixxx::track::io::key::Source source) {
KeyMap key_map;
key_map.set_source(source);
mixxx::track::io::key::ChromaticKey global_key = KeyUtils::guessKeyFromText(
global_key_text);
if (global_key != mixxx::track::io::key::INVALID) {
key_map.set_global_key(global_key);
} else {
// If we couldn't understand the key, save it as text.
key_map.set_global_key_text(global_key_text.toStdString());
}
return Keys(key_map);
}
// static
QString KeyFactory::getPreferredVersion() {
return KEY_MAP_VERSION;
}
// static
QString KeyFactory::getPreferredSubVersion(
const QHash<QString, QString>& extraVersionInfo) {
const char* kSubVersionKeyValueSeparator = "=";
const char* kSubVersionFragmentSeparator = "|";
QStringList fragments;
QHashIterator<QString, QString> it(extraVersionInfo);
while (it.hasNext()) {
it.next();
if (it.key().contains(kSubVersionKeyValueSeparator) ||
it.key().contains(kSubVersionFragmentSeparator) ||
it.value().contains(kSubVersionKeyValueSeparator) ||
it.value().contains(kSubVersionFragmentSeparator)) {
qDebug() << "ERROR: Your analyzer key/value contains invalid characters:"
<< it.key() << ":" << it.value() << "Skipping.";
continue;
}
fragments << QString("%1%2%3").arg(
it.key(), kSubVersionKeyValueSeparator, it.value());
}
std::sort(fragments.begin(), fragments.end());
return (fragments.size() > 0) ? fragments.join(kSubVersionFragmentSeparator) : "";
}
// static
Keys KeyFactory::makePreferredKeys(
const KeyChangeList& key_changes,
const QHash<QString, QString>& extraVersionInfo,
const int iSampleRate, const int iTotalSamples) {
Q_UNUSED(iSampleRate);
const QString version = getPreferredVersion();
const QString subVersion = getPreferredSubVersion(extraVersionInfo);
if (version == KEY_MAP_VERSION) {
KeyMap key_map;
for (const auto* it = key_changes.constBegin();
it != key_changes.constEnd();
++it) {
// Key position is in frames. Do not accept fractional frames.
double frame = floor(it->second);
KeyMap::KeyChange* pChange = key_map.add_key_change();
pChange->set_key(it->first);
pChange->set_frame_position(static_cast<int>(frame));
}
key_map.set_global_key(KeyUtils::calculateGlobalKey(key_changes, iTotalSamples, iSampleRate));
key_map.set_source(mixxx::track::io::key::ANALYZER);
Keys keys(key_map);
keys.setSubVersion(subVersion);
return keys;
}
qDebug() << "ERROR: Could not determine what type of keys to create.";
return Keys();
}
|
